Merge branch 'master' into update-typescript-input-output-type

Author: eddeee888

.changeset/long-owls-matter.md

@@ -0,0 +1,27 @@
+---
+'@graphql-codegen/visitor-plugin-common': minor
+'@graphql-codegen/typescript-resolvers': minor
+---
+
+Add excludeTypes config to resolversNonOptionalTypename
+
+This disables the adding of `__typename` in resolver types for any specified typename. This could be useful e.g. if you're wanting to enable this for all new types going forward but not do a big migration.
+
+Usage example:
+
+```typescript
+const config: CodegenConfig = {
+  schema: 'src/schema/**/*.graphql',
+  generates: {
+    'src/schema/types.ts': {
+      plugins: ['typescript', 'typescript-resolvers'],
+      config: {
+        resolversNonOptionalTypename: {
+          unionMember: true,
+          excludeTypes: ['MyType'],
+        }
+      }
+    },
+  },
+};
+```

.changeset/quiet-rocks-sin.md

@@ -0,0 +1,5 @@
+---
+'@graphql-codegen/cli': patch
+---
+
+Fixed option ignoreNoDocuments when using graphql configs

packages/graphql-codegen-cli/src/codegen.ts

@@ -274,10 +274,20 @@ export async function executeCodegen(input: CodegenContext | Types.Config): Prom
 
                           const hash = JSON.stringify(documentPointerMap);
                           const result = await cache('documents', hash, async () => {
-                            const documents = await context.loadDocuments(documentPointerMap);
-                            return {
-                              documents,
-                            };
+                            try {
+                              const documents = await context.loadDocuments(documentPointerMap);
+                              return {
+                                documents,
+                              };
+                            } catch (error) {
+                              if (config.ignoreNoDocuments) {
+                                return {
+                                  documents: [],
+                                };
+                              }
+
+                              throw error;
+                            }
                           });
 
                           outputDocuments = result.documents;

packages/graphql-codegen-cli/tests/generate-and-save.spec.ts

@@ -3,6 +3,7 @@ import { Types } from '@graphql-codegen/plugin-helpers';
 import { useMonorepo } from '@graphql-codegen/testing';
 import makeDir from 'make-dir';
 import { generate } from '../src/generate-and-save.js';
+import { createContext } from '../src/config.js';
 import * as fs from '../src/utils/file-system.js';
 
 const SIMPLE_TEST_SCHEMA = `type MyType { f: String } type Query { f: String }`;
@@ -76,6 +77,22 @@ describe('generate-and-save', () => {
     expect(writeSpy).not.toHaveBeenCalled();
   });
 
+  test('should not error when ignoreNoDocuments config option is present', async () => {
+    jest.spyOn(fs, 'writeFile').mockImplementation();
+    const config = await createContext({
+      config: './tests/test-files/graphql.config.json',
+      project: undefined,
+      errorsOnly: true,
+      overwrite: true,
+      profile: true,
+      require: [],
+      silent: false,
+      watch: false,
+    });
+
+    await generate(config, false);
+  });
+
   test('should use global overwrite option and write a file', async () => {
     const filename = 'overwrite.ts';
     const writeSpy = jest.spyOn(fs, 'writeFile').mockImplementation();

packages/graphql-codegen-cli/tests/test-files/graphql.config.json

@@ -0,0 +1,14 @@
+{
+  "schema": ["../test-documents/schema.graphql"],
+  "documents": ["../test-documents/empty.graphql"],
+  "extensions": {
+    "codegen": {
+      "ignoreNoDocuments": true,
+      "generates": {
+        "./gql/": {
+          "preset": "client"
+        }
+      }
+    }
+  }
+}

packages/plugins/other/visitor-plugin-common/src/base-resolvers-visitor.ts

@@ -542,6 +542,49 @@ export interface RawResolversConfig extends RawConfig {
   /**
    * @description Makes `__typename` of resolver mappings non-optional without affecting the base types.
    * @default false
+   *
+   * @exampleMarkdown
+   * ## Enable for all
+   *
+   * ```ts filename="codegen.ts"
+   *  import type { CodegenConfig } from '@graphql-codegen/cli';
+   *
+   *  const config: CodegenConfig = {
+   *    // ...
+   *    generates: {
+   *      'path/to/file': {
+   *        plugins: ['typescript', 'typescript-resolver'],
+   *        config: {
+   *          resolversNonOptionalTypename: true // or { unionMember: true, interfaceImplementingType: true }
+   *        },
+   *      },
+   *    },
+   *  };
+   *  export default config;
+   * ```
+   *
+   * ## Enable except for some types
+   *
+   * ```ts filename="codegen.ts"
+   *  import type { CodegenConfig } from '@graphql-codegen/cli';
+   *
+   *  const config: CodegenConfig = {
+   *    // ...
+   *    generates: {
+   *      'path/to/file': {
+   *        plugins: ['typescript', 'typescript-resolver'],
+   *        config: {
+   *          resolversNonOptionalTypename: {
+   *            unionMember: true,
+   *            interfaceImplementingType: true,
+   *            excludeTypes: ['MyType'],
+   *          }
+   *        },
+   *      },
+   *    },
+   *  };
+   *  export default config;
+   * ```
    */
   resolversNonOptionalTypename?: boolean | ResolversNonOptionalTypenameConfig;
   /**
@@ -876,10 +919,11 @@ export class BaseResolversVisitor<
       const schemaType = allSchemaTypes[typeName];
 
       if (isUnionType(schemaType)) {
+        const { unionMember, excludeTypes } = this.config.resolversNonOptionalTypename;
         res[typeName] = this.getAbstractMembersType({
           typeName,
           memberTypes: schemaType.getTypes(),
-          isTypenameNonOptional: this.config.resolversNonOptionalTypename.unionMember,
+          isTypenameNonOptional: unionMember && !excludeTypes?.includes(typeName),
         });
       }
       return res;
@@ -913,10 +957,12 @@ export class BaseResolversVisitor<
           }
         }
 
+        const { interfaceImplementingType, excludeTypes } = this.config.resolversNonOptionalTypename;
+
         res[typeName] = this.getAbstractMembersType({
           typeName,
           memberTypes: implementingTypes,
-          isTypenameNonOptional: this.config.resolversNonOptionalTypename.interfaceImplementingType,
+          isTypenameNonOptional: interfaceImplementingType && !excludeTypes?.includes(typeName),
         });
       }
 

packages/plugins/other/visitor-plugin-common/src/types.ts

@@ -120,4 +120,5 @@ export type FragmentDirectives = {
 export interface ResolversNonOptionalTypenameConfig {
   unionMember?: boolean;
   interfaceImplementingType?: boolean;
+  excludeTypes?: string[];
 }

packages/plugins/typescript/resolvers/tests/ts-resolvers.spec.ts

@@ -431,6 +431,37 @@ export type MyTypeResolvers<ContextType = any, ParentType extends ResolversParen
 
       expect(result.content).not.toBeSimilarStringTo('export type ResolversInterfaceTypes');
     });
+
+    it('resolversNonOptionalTypename - excludes types', async () => {
+      const result = await plugin(
+        resolversTestingSchema,
+        [],
+        {
+          resolversNonOptionalTypename: {
+            unionMember: true,
+            interfaceImplementingType: true,
+            excludeTypes: ['ChildUnion', 'AnotherNode', 'Node'],
+          },
+        },
+        { outputFile: '' }
+      );
+
+      expect(result.content).toBeSimilarStringTo(`
+        export type ResolversUnionTypes<RefType extends Record<string, unknown>> = {
+          ChildUnion: ( Child ) | ( MyOtherType );
+          MyUnion: ( Omit<MyType, 'unionChild'> & { unionChild?: Maybe<RefType['ChildUnion']> } & { __typename: 'MyType' } ) | ( MyOtherType & { __typename: 'MyOtherType' } );
+        };
+      `);
+
+      expect(result.content).toBeSimilarStringTo(`
+        export type ResolversInterfaceTypes<RefType extends Record<string, unknown>> = {
+          Node: ( SomeNode );
+          AnotherNode: ( Omit<AnotherNodeWithChild, 'unionChild'> & { unionChild?: Maybe<RefType['ChildUnion']> } ) | ( Omit<AnotherNodeWithAll, 'unionChild' | 'unionChildren'> & { unionChild?: Maybe<RefType['ChildUnion']>, unionChildren: Array<RefType['ChildUnion']> } );
+          WithChild: ( Omit<AnotherNodeWithChild, 'unionChild'> & { unionChild?: Maybe<RefType['ChildUnion']> } & { __typename: 'AnotherNodeWithChild' } ) | ( Omit<AnotherNodeWithAll, 'unionChild' | 'unionChildren'> & { unionChild?: Maybe<RefType['ChildUnion']>, unionChildren: Array<RefType['ChildUnion']> } & { __typename: 'AnotherNodeWithAll' } );
+          WithChildren: ( Omit<AnotherNodeWithAll, 'unionChild' | 'unionChildren'> & { unionChild?: Maybe<RefType['ChildUnion']>, unionChildren: Array<RefType['ChildUnion']> } & { __typename: 'AnotherNodeWithAll' } );
+        };
+      `);
+    });
   });
 
   it('directiveResolverMappings - should generate correct types (import definition)', async () => {