fix: do not cache edge types in graphql eslint (#7936)

Author: jdolle

.changeset/wicked-seals-study.md

@@ -0,0 +1,6 @@
+---
+'hive': patch
+---
+
+Do not cache edge types in graphql eslint. This fixes an issue where edge types were cached between
+runs and only the cached edge types would be referenced for subsequent runs

packages/services/api/src/modules/schema/providers/models/composite.ts

@@ -241,6 +241,7 @@ export class CompositeModel {
       }),
       this.checks.policyCheck({
         selector,
+        // if schema check does not compose then there's no point in linting. Pass in null in this case.
         incomingSdl: compositionCheck.result?.fullSchemaSdl ?? null,
         modifiedSdl: incoming.sdl,
       }),

packages/services/api/src/modules/schema/providers/models/single.ts

@@ -107,7 +107,7 @@ export class SingleModel {
     });
 
     if (checksumResult === 'unchanged') {
-      this.logger.debug('No changes detected, skipping schema check');
+      this.logger.info('No changes detected, skipping schema check');
       return {
         conclusion: SchemaCheckConclusion.Skip,
       };

packages/services/api/src/modules/schema/providers/registry-checks.ts

@@ -225,7 +225,7 @@ export class RegistryChecks {
     );
 
     if (!args.existing) {
-      this.logger.debug('No exiting version');
+      this.logger.debug('No existing version');
       return 'initial' as const;
     }
 
@@ -400,7 +400,7 @@ export class RegistryChecks {
       this.logger.debug('Skip policy check due to no SDL being composed.');
       return {
         status: 'skipped',
-      };
+      } satisfies CheckResult;
     }
 
     const policyResult = await this.policy.checkPolicy(incomingSdl, modifiedSdl, selector);

packages/services/policy/__tests__/policy.spec.ts

@@ -105,6 +105,111 @@ describe('policy checks', () => {
     `);
   });
 
+  it('refreshes edge types per run', async () => {
+    const caller = schemaPolicyApiRouter.createCaller({ req: { log: console } as any });
+    const userSchema = `
+      type Query {
+        # 'first' limits results; 'after' is the cursor to start from
+        users(first: Int, after: String): UserConnection!
+      }
+
+      type UserConnection {
+        edges: [UserEdge!]!
+        pageInfo: PageInfo!
+        totalCount: Int!
+      }
+
+      type UserEdge {
+        node: User!
+        cursor: String!
+      }
+
+      type PageInfo {
+        hasNextPage: Boolean!
+        endCursor: String
+      }
+
+      interface Node {
+        id: ID!
+      }
+
+      type User {
+        id: ID!
+        name: String!
+      }
+    `;
+    const result = await caller.checkPolicy({
+      source: userSchema,
+      schema: userSchema,
+      target: '1',
+      policy: {
+        'relay-edge-types': [
+          2,
+          {
+            withEdgeSuffix: true,
+            shouldImplementNode: true,
+            listTypeCanWrapOnlyEdgeType: false,
+          },
+        ],
+      },
+    });
+
+    expect(result.length).toBe(1);
+    expect(result[0].message).toBe("Edge type's field \`node\` must implement \`Node\` interface.");
+
+    const noUserSchema = `
+      type Query {
+        # 'first' limits results; 'after' is the cursor to start from
+        noUsers(first: Int, after: String): NoUserConnection!
+      }
+
+      type NoUserConnection {
+        edges: [NoUserEdge!]!
+        pageInfo: PageInfo!
+        totalCount: Int!
+      }
+
+      type NoUserEdge {
+        node: NoUser!
+        cursor: String!
+      }
+
+      type PageInfo {
+        hasNextPage: Boolean!
+        endCursor: String
+      }
+
+      interface Node {
+        id: ID!
+      }
+
+      type NoUser {
+        id: ID!
+        name: String!
+      }
+    `;
+    const noUserResult = await caller.checkPolicy({
+      source: noUserSchema,
+      schema: noUserSchema,
+      target: '1',
+      policy: {
+        'relay-edge-types': [
+          2,
+          {
+            withEdgeSuffix: true,
+            shouldImplementNode: true,
+            listTypeCanWrapOnlyEdgeType: false,
+          },
+        ],
+      },
+    });
+
+    expect(noUserResult.length).toBe(1);
+    expect(noUserResult[0].message).toBe(
+      "Edge type's field \`node\` must implement \`Node\` interface.",
+    );
+  });
+
   /** To ensure existing policies dont break during upgrades */
   it.each(policies)('should support existing policies', async policy => {
     await expect(

patches/@graphql-eslint__eslint-plugin@3.20.1.patch

@@ -119,4 +119,30 @@ index d952cee1e10976459e7c5836b86ba6540c45fdb6..d314997bfd26477c7d823cad397eb5d6
 +  
    return {
      [ruleId]: {
-       meta: {
+       meta: {
+diff --git a/esm/rules/relay-edge-types.js b/esm/rules/relay-edge-types.js
+index 7a7eb179786103d9d72a4a84fb4bf811d11a4286..6fb12a5f56b71f56c9a14018d0494e9c7584f935 100644
+--- a/esm/rules/relay-edge-types.js
++++ b/esm/rules/relay-edge-types.js
+@@ -12,11 +12,7 @@ const MESSAGE_MUST_BE_OBJECT_TYPE = "MESSAGE_MUST_BE_OBJECT_TYPE";
+ const MESSAGE_MISSING_EDGE_SUFFIX = "MESSAGE_MISSING_EDGE_SUFFIX";
+ const MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE = "MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE";
+ const MESSAGE_SHOULD_IMPLEMENTS_NODE = "MESSAGE_SHOULD_IMPLEMENTS_NODE";
+-let edgeTypesCache;
+ function getEdgeTypes(schema2) {
+-  if (edgeTypesCache) {
+-    return edgeTypesCache;
+-  }
+   const edgeTypes = /* @__PURE__ */ new Set();
+   const visitor = {
+     ObjectTypeDefinition(node) {
+@@ -38,8 +34,7 @@ function getEdgeTypes(schema2) {
+   };
+   const astNode = getDocumentNodeFromSchema(schema2);
+   visit(astNode, visitor);
+-  edgeTypesCache = edgeTypes;
+-  return edgeTypesCache;
++  return edgeTypes;
+ }
+ const schema = {
+   type: "array",