graphql-code-generator-plugins

Minor Changes

• f7831c1: Use resolversNonOptionalTypename instead of nonOptionalTypename

  This makes using abstract types simpler because we do not return __typename for all types, only for union members and interface implementing types.

• f7831c1: Add scalarsOverrides config option

  Record<string, { resolver?: string; type?: string | { input: string; output: string } }> (Default: {})

  Overrides scalars' resolver implementation, type or both.

  Example:

  // codegen.ts
  {
    generates: {
      'src/schema': defineConfig({
        scalarsOverrides: {
          DateTime: {
            resolver: './localDateTimeResolver#Resolver',
          }
          Currency: {
            type: 'unknown'
          },
          BigInt: {
            resolver: '@other/scalars#BigIntResolver',
            type: 'bigint'
          }
        }
      })
    }
  }
  

  BREAKING CHANGE: typesPluginsConfig.scalars can no longer be used. Please use scalarOverrides instead.

• f7831c1: Use optionalResolveType=true because resolversNonOptionalTypename works

• f7831c1: Add scalarsModule config option

  string or false (Default: graphql-scalars)

  Where Scalar implementation and codegen types come from. Use false to implement your own Scalars.

  If using an module that is not graphql-scalars, the module must export resolver implementation and codegen type the same way graphql-scalars does e.g.

  {
    resolvers: {
      DateTime: DateTimeResolver,
    },
    DateTimeResolver: {
      // ... resolver implementation
      extensions: {
        codegenScalarType: 'Date | string',
      },
    }
  }
  

Patch Changes

• f7831c1: Allows overriding native scalar types' type (Equivalent of typescript plugin's scalars option)
• f7831c1: Correctly implement ID Scalar's input/output type: input is string and output is string | number

By default, ID scalar types are targeted at client types. Example generated type:

type Scalars = {
  ID: { 
    input: string | number; 
    output: string 
  }
}

Server preset manages the default ID scalar to be correct for server types. Example generated type for the server:

type Scalars = {
  ID: { 
    input: string; 
    output: string | number;
  }
}

Minor Changes

• 037afdc: Add resolverMainFileMode. merged or modules (Default: merged)

  How to generate file/s that put resolvers map together:

  • merged: one file
  • modules: one file per module. This can be used with module-based libraries like graphql-modules

  Example codegen config:

  // codegen.ts
  import type { CodegenConfig } from '@graphql-codegen/cli';
  import { defineConfig } from '@eddeee888/gcg-typescript-resolver-files';
  
  const config: CodegenConfig = {
    schema: '**/*.graphql',
    generates: {
      'src/schema': defineConfig({
        resolverMainFileMode: 'modules',
      }),
    },
  };
  
  export default config;
  

  resolverMainFileMode=modules generates one resolvers.generated.ts file in each module:

  ├── src/
  │   ├── schema/
  │   │   ├── base/
  │   │   │   ├── schema.graphql
  │   │   │   ├── resolvers.generated.ts # contains resolvers of types in `src/schema/base/schema.graphql`
  │   │   ├── user/
  │   │   │   ├── schema.graphql
  │   │   │   ├── resolvers.generated.ts # contains resolvers of types in `src/schema/user/schema.graphql`
  │   │   ├── book/
  │   │   │   ├── schema.graphql
  │   │   │   ├── resolvers.generated.ts # contains resolvers of types in `src/schema/book/schema.graphql`
  

  If you are using graphql-modules, you can use the resolvers map like this:

  // src/schema/user/index.ts
  import { createModule } from 'graphql-modules';
  import { resolvers } from './resolvers.generated.ts';
  
  export const userModule = createModule({
    id: 'user-module',
    dirname: __dirname,
    typeDefs: [
      /* Your typeDefs*/
    ],
    resolvers,
  });
  

• df06e3b: Add typeDefsFileMode. merged or mergedWhitelisted or modules (Default: merged)

  How to generate typeDefs file/s:

  • merged: one file
  • mergedWhitelisted: one file but only contains whitelisted modules. This is useful if your blacklisted modules handle their own type defs
  • modules: one file per module. This can be used with module-based libraries like graphql-modules

  Example codegen config:

  // codegen.ts
  import type { CodegenConfig } from '@graphql-codegen/cli';
  import { defineConfig } from '@eddeee888/gcg-typescript-resolver-files';
  
  const config: CodegenConfig = {
    schema: '**/*.graphql',
    generates: {
      'src/schema': defineConfig({
        typeDefsFileMode: 'modules',
      }),
    },
  };
  
  export default config;
  

  typeDefsFileMode=modules generates one typeDefs.generated.ts file in each module:

  ├── src/
  │   ├── schema/
  │   │   ├── base/
  │   │   │   ├── schema.graphql
  │   │   │   ├── typeDefs.generated.ts # contains typeDefs of `src/schema/base/schema.graphql`
  │   │   ├── user/
  │   │   │   ├── schema.graphql
  │   │   │   ├── typeDefs.generated.ts # contains typeDefs of `src/schema/user/schema.graphql`
  │   │   ├── book/
  │   │   │   ├── schema.graphql
  │   │   │   ├── typeDefs.generated.ts # contains typeDefs of `src/schema/book/schema.graphql`
  

  If you are using graphql-modules, you can use the resolvers map like this:

  // src/schema/user/index.ts
  import { createModule } from 'graphql-modules';
  import { typeDefs } from './typeDefs.generated.ts';
  
  export const userModule = createModule({
    id: 'user-module',
    dirname: __dirname,
    typeDefs: [typeDefs],
    resolvers: {
      /* Your resolver map */
    },
  });
  

• 086802e: Add defineConfig. This sets up preset, presetConfig and watchPattern.

  Example:

  import type { CodegenConfig } from '@graphql-codegen/cli';
  import { defineConfig } from '@eddeee888/typescript-resolver-files';
  
  const config: CodegenConfig = {
    schema: 'src/schema/**/*.graphql',
    generates: {
      'src/schema': defineConfig(),
    },
  };
  
  export default config;
  

Patch Changes

• fe0ca5d: Bump ts-morph to v18
• d5aac16: Handle intersection typeNode usually seen in GQL Interface types e.g. type TypeA = TypeB & { something: string } & { somethingelse: string }
• 6324453: Fix Subscription default generation template
• b70ee7f: Use path.posix to fix Windows errors
• 5302e38: Add example for custom preset config in README