Merge pull request #27 from mizdra/support-add-typename

Add `skipTypename` option

Author: mizdra

e2e/codegen.ts

@@ -6,16 +6,17 @@ const config: CodegenConfig = {
     '__generated__/types.ts': {
       plugins: ['typescript'],
       config: {
-        skipTypename: true, // TODO: remove this
         nonOptionalTypename: true,
         enumsAsTypes: true,
         avoidOptionals: true,
+        skipTypename: true,
       },
     },
     './__generated__/fabbrica.ts': {
       plugins: ['@mizdra/graphql-fabbrica'],
       config: {
         typesFile: './types',
+        skipTypename: true,
       },
     },
   },

src/code-generator.test.ts

@@ -1,18 +1,20 @@
 import { describe, expect, it } from 'vitest';
 import { generateCode } from './code-generator.js';
-import { Options } from './option.js';
+import { Config } from './config.js';
 import { TypeInfo } from './schema-scanner.js';
+import { oneOf } from './test/util.js';
 
 describe('generateCode', () => {
   it('generates code', () => {
-    const options: Options = {
+    const config: Config = {
       typesFile: './types',
+      skipTypename: oneOf([true, false]),
     };
     const typeInfos: TypeInfo[] = [
       { name: 'Book', fieldNames: ['id', 'title', 'author'] },
       { name: 'Author', fieldNames: ['id', 'name', 'books'] },
     ];
-    const actual = generateCode(options, typeInfos);
+    const actual = generateCode(config, typeInfos);
     expect(actual).toMatchSnapshot();
   });
 });

src/code-generator.ts

@@ -1,7 +1,7 @@
-import { Options } from './option.js';
+import { Config } from './config.js';
 import { TypeInfo } from './schema-scanner.js';
 
-function generatePreludeCode(options: Options, typeInfos: TypeInfo[]): string {
+function generatePreludeCode(config: Config, typeInfos: TypeInfo[]): string {
   const joinedTypeNames = typeInfos.map(({ name }) => name).join(', ');
   const code = `
 import {
@@ -11,7 +11,7 @@ import {
   type DefaultFieldsResolver,
   defineTypeFactoryInternal,
 } from '@mizdra/graphql-fabbrica/helper';
-import type { ${joinedTypeNames} } from '${options.typesFile}';
+import type { ${joinedTypeNames} } from '${config.typesFile}';
 
 export * from '@mizdra/graphql-fabbrica/helper';
   `.trim();
@@ -63,9 +63,9 @@ export function define${name}Factory<
   return `${code}\n`;
 }
 
-export function generateCode(options: Options, typeInfos: TypeInfo[]): string {
+export function generateCode(config: Config, typeInfos: TypeInfo[]): string {
   let code = '';
-  code += generatePreludeCode(options, typeInfos);
+  code += generatePreludeCode(config, typeInfos);
   for (const typeInfo of typeInfos) {
     code += generateTypeFactoryCode(typeInfo);
   }

src/config.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { validateConfig } from './config.js';
+import { oneOf } from './test/util.js';
+
+describe('validateConfig', () => {
+  it('options must be an object', () => {
+    expect(() => validateConfig(1)).toThrow('`options` must be an object');
+    expect(() => validateConfig(null)).toThrow('`options` must be an object');
+  });
+  it('typesFile', () => {
+    expect(() => validateConfig({ typesFile: './types' })).not.toThrow();
+    expect(() => validateConfig({})).toThrow('`option.typesFile` is required');
+    expect(() => validateConfig({ typesFile: 1 })).toThrow('`options.typesFile` must be a string');
+  });
+  it('skipTypename', () => {
+    expect(() => validateConfig({ typesFile: './types', skipTypename: oneOf([true, false]) })).not.toThrow();
+    expect(() => validateConfig({ typesFile: './types' })).not.toThrow();
+    expect(() => validateConfig({ typesFile: './types', skipTypename: 1 })).toThrow(
+      '`options.skipTypename` must be a boolean',
+    );
+  });
+});

src/config.ts

@@ -0,0 +1,33 @@
+export type RawConfig = {
+  typesFile: string;
+  skipTypename?: boolean;
+  // TODO: support addIsAbstractType
+};
+
+export type Config = {
+  typesFile: string;
+  skipTypename: boolean;
+  // TODO: support addIsAbstractType
+};
+
+export function validateConfig(rawConfig: unknown): asserts rawConfig is RawConfig {
+  if (typeof rawConfig !== 'object' || rawConfig === null) {
+    throw new Error('`options` must be an object');
+  }
+  if (!('typesFile' in rawConfig)) {
+    throw new Error('`option.typesFile` is required');
+  }
+  if (typeof rawConfig['typesFile'] !== 'string') {
+    throw new Error('`options.typesFile` must be a string');
+  }
+  if ('skipTypename' in rawConfig && typeof rawConfig['skipTypename'] !== 'boolean') {
+    throw new Error('`options.skipTypename` must be a boolean');
+  }
+}
+
+export function normalizeConfig(rawConfig: RawConfig): Config {
+  return {
+    typesFile: rawConfig.typesFile,
+    skipTypename: rawConfig.skipTypename ?? false,
+  };
+}

src/index.ts

@@ -2,14 +2,15 @@
 
 import type { CodegenPlugin } from '@graphql-codegen/plugin-helpers';
 import { generateCode } from './code-generator.js';
-import { validateOptions } from './option.js';
+import { normalizeConfig, validateConfig } from './config.js';
 import { getTypeInfos } from './schema-scanner.js';
 
 const plugin: CodegenPlugin = {
   plugin(schema, _documents, config, _info) {
-    validateOptions(config);
-    const typeInfos = getTypeInfos(schema);
-    const code = generateCode(config, typeInfos);
+    validateConfig(config);
+    const normalizedConfig = normalizeConfig(config);
+    const typeInfos = getTypeInfos(normalizedConfig, schema);
+    const code = generateCode(normalizedConfig, typeInfos);
     return code;
   },
 };

src/option.test.ts

@@ -1,38 +1,56 @@
 import { parse, buildASTSchema } from 'graphql';
-import { expect, it } from 'vitest';
+import { describe, expect, it } from 'vitest';
+import { Config } from './config.js';
 import { getTypeInfos } from './schema-scanner.js';
 
-it('getTypeInfos', () => {
-  const ast = parse(`
-    interface Node {
-      id: ID!
-    }
-    type Book implements Node {
-      id: ID!
-      title: String!
-      author: Author!
-    }
-    type Author implements Node {
-      id: ID!
-      name: String!
-      books: [Book!]!
-    }
-    type Query {
-      node(id: ID!): Node
-    }
-    type Subscription {
-      bookAdded: Book!
-    }
-    type Mutation {
-      addBook(title: String!, authorId: ID!): Book!
-    }
-  `);
-  const schema = buildASTSchema(ast);
-  expect(getTypeInfos(schema)).toStrictEqual([
-    { name: 'Book', fieldNames: ['id', 'title', 'author'] },
-    { name: 'Author', fieldNames: ['id', 'name', 'books'] },
-    { name: 'Query', fieldNames: ['node'] },
-    { name: 'Subscription', fieldNames: ['bookAdded'] },
-    { name: 'Mutation', fieldNames: ['addBook'] },
-  ]);
+function buildSchemaFromString(schemaString: string) {
+  const ast = parse(schemaString);
+  return buildASTSchema(ast);
+}
+
+describe('getTypeInfos', () => {
+  it('returns typename and field names', () => {
+    const schema = buildSchemaFromString(`
+      interface Node {
+        id: ID!
+      }
+      type Book implements Node {
+        id: ID!
+        title: String!
+        author: Author!
+      }
+      type Author implements Node {
+        id: ID!
+        name: String!
+        books: [Book!]!
+      }
+      type Query {
+        node(id: ID!): Node
+      }
+      type Subscription {
+        bookAdded: Book!
+      }
+      type Mutation {
+        addBook(title: String!, authorId: ID!): Book!
+      }
+    `);
+    const config: Config = { typesFile: './types', skipTypename: true };
+    expect(getTypeInfos(config, schema)).toStrictEqual([
+      { name: 'Book', fieldNames: ['id', 'title', 'author'] },
+      { name: 'Author', fieldNames: ['id', 'name', 'books'] },
+      { name: 'Query', fieldNames: ['node'] },
+      { name: 'Subscription', fieldNames: ['bookAdded'] },
+      { name: 'Mutation', fieldNames: ['addBook'] },
+    ]);
+  });
+  it('includes __typename if skipTypename is false', () => {
+    const schema = buildSchemaFromString(`
+      type Book {
+        id: ID!
+        title: String!
+      }
+    `);
+    const config: Config = { typesFile: './types', skipTypename: false };
+    expect(getTypeInfos(config, schema)).toStrictEqual([{ name: 'Book', fieldNames: ['__typename', 'id', 'title'] }]);
+  });
 });

src/option.ts

@@ -1,8 +1,16 @@
 import { GraphQLObjectType, GraphQLSchema } from 'graphql';
+import { Config } from './config.js';
 
 export type TypeInfo = { name: string; fieldNames: string[] };
 
-export function getTypeInfos(schema: GraphQLSchema): TypeInfo[] {
+function getAdditionalFieldNames(config: Config): string[] {
+  // TODO: support __is<AbstractType> (__is<InterfaceType>, __is<UnionType>)
+  const result = [];
+  if (!config.skipTypename) result.push('__typename');
+  return result;
+}
+
+export function getTypeInfos(config: Config, schema: GraphQLSchema): TypeInfo[] {
   const result: TypeInfo[] = [];
   const types = Object.values(schema.getTypeMap());
   for (const type of types) {
@@ -13,10 +21,10 @@ export function getTypeInfos(schema: GraphQLSchema): TypeInfo[] {
     // ref: https://github.com/graphql/graphql-js/blob/b12dcffe83098922dcc6c0ec94eb6fc032bd9772/src/type/introspection.ts#L552-L559
     if (type.name.startsWith('__')) continue;
 
-    // TODO: support __typename, __is<AbstractType> (__is<Interface>, __is<Union>)
     const fieldMap = type.getFields();
     const fieldNames = Object.values(fieldMap).map((field) => field.name);
-    result.push({ name: type.name, fieldNames });
+    const additionalFieldNames = getAdditionalFieldNames(config);
+    result.push({ name: type.name, fieldNames: [...additionalFieldNames, ...fieldNames] });
   }
   return result;
 }