@devticon-os/graphql-codegen-axios 0.2.17 → 0.3.0-test

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@devticon-os/graphql-codegen-axios",
-  "version": "0.2.17",
+  "version": "0.3.0-test",
   "license": "MIT",
-  "main": "src/index.js",
+  "main": "src/index.ts",
   "repository": "https://github.com/devticon/graphql-codegen-axios",
   "author": {
     "name": "krs",
@@ -12,13 +12,20 @@
     "src"
   ],
   "scripts": {
-    "start": "node src/index.js"
+    "start": "node src/index.ts",
+    "build": "tsc",
+    "build:watch": "tsc --watch"
   },
   "peerDependencies": {
     "axios": "^1.3.3",
     "graphql": "^16.6.0"
   },
   "devDependencies": {
-    "prettier": "^2.8.4"
+    "@types/node": "^18.15.0",
+    "axios": "^1.3.4",
+    "graphql": "^16.6.0",
+    "prettier": "^2.8.4",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.5"
   }
 }

package/src/_types.ts

@@ -0,0 +1,60 @@
+import { DocumentNode, OperationDefinitionNode } from 'graphql/language/ast';
+import { GraphQLSchema } from 'graphql/type';
+
+export type TsType = {
+  fields: TsTypeField[];
+  unions?: string[];
+};
+
+export type NamedTsType = TsType & {
+  name: string;
+};
+export type TsTypeFieldBase = {
+  name: string;
+  isList: boolean;
+  isNullable: boolean;
+};
+export type TsTypeFieldInLine = TsTypeFieldBase & { kind: 'inLine'; type: string };
+export type TsTypeFieldObject = TsTypeFieldBase & { kind: 'object' } & TsType;
+export type TsTypeField = TsTypeFieldInLine | TsTypeFieldObject;
+export type Query = {
+  name: string;
+  ast: OperationDefinitionNode;
+  allFragments: TsType[];
+};
+export type Config = {
+  autoSingleResult?: boolean;
+  prettier?: boolean;
+  emitDirectives?: string | boolean;
+  emitSchema?: string | boolean;
+
+  suffix?: {
+    fragment?: string;
+    input?: string;
+    enum?: string;
+  };
+  scalars?: Record<string, string>;
+};
+export type CodegenDocuments = { document: DocumentNode }[];
+export type CodegenPlugin = {
+  plugin: (schema: GraphQLSchema, documents: CodegenDocuments, config: Config) => string | Promise<string>;
+  addToSchema?: string;
+};
+
+export type Operation = {
+  name: string;
+  definition: OperationDefinitionNode;
+  singleResultKey?: string;
+  variables?: NamedTsType;
+  results: NamedTsType;
+  fragments: string[];
+  directives: Directive[];
+};
+
+export type Directive = {
+  name: string;
+  path: string;
+  args: Record<string, string>;
+};
+
+export type FieldsMap = Record<string, TsTypeFieldBase & { fields: FieldsMap }>;

package/src/enums.ts

@@ -0,0 +1,50 @@
+import {
+  assertEnumType,
+  assertObjectType,
+  GraphQLEnumType,
+  GraphQLInputObjectType,
+  GraphQLSchema,
+  isEnumType,
+} from 'graphql/type';
+import { getNamedType } from 'graphql/type/definition';
+import { FragmentDefinitionNode } from 'graphql/language/ast';
+import { Kind } from 'graphql/language';
+import { Operation } from './_types';
+
+export const findUsageEnums = (
+  inputs: GraphQLInputObjectType[],
+  fragments: FragmentDefinitionNode[],
+  operations: Operation[],
+  schema: GraphQLSchema,
+): GraphQLEnumType[] => {
+  const enums = new Set<GraphQLEnumType>();
+  for (let input of inputs) {
+    for (let field of Object.values(input.getFields())) {
+      if (isEnumType(getNamedType(field.type))) {
+        enums.add(assertEnumType(getNamedType(field.type)));
+      }
+    }
+  }
+  for (let fragment of fragments) {
+    const parent = assertObjectType(schema.getType(fragment.typeCondition.name.value));
+    for (let selection of fragment.selectionSet.selections) {
+      if (selection.kind === Kind.FIELD) {
+        const parentField = parent.getFields()[selection.name.value];
+        if (isEnumType(getNamedType(parentField.type))) {
+          enums.add(assertEnumType(getNamedType(parentField.type)));
+        }
+      }
+    }
+  }
+  for (let operation of operations) {
+    for (let field of operation.variables?.fields || []) {
+      if (field.kind === 'inLine') {
+        const type = schema.getType(field.type);
+        if (isEnumType(getNamedType(type))) {
+          enums.add(assertEnumType(getNamedType(type)));
+        }
+      }
+    }
+  }
+  return [...enums];
+};

package/src/fragments.ts

@@ -0,0 +1,15 @@
+import { FragmentDefinitionNode } from 'graphql/language/ast';
+import { CodegenDocuments } from './_types';
+import { Kind } from 'graphql/language';
+
+export const findUsageFragments = (documents: CodegenDocuments) => {
+  const fragments: FragmentDefinitionNode[] = [];
+  for (let { document } of documents) {
+    for (const definition of document.definitions) {
+      if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+        fragments.push(definition);
+      }
+    }
+  }
+  return fragments;
+};

package/src/graphql.ts

@@ -0,0 +1,101 @@
+import { SelectionNode, TypeNode } from 'graphql/language/ast';
+import { Config, TsType } from './_types';
+import { getNamedType, GraphQLType } from 'graphql/type/definition';
+import {
+  assertObjectType,
+  getNullableType,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLScalarType,
+  GraphQLSchema,
+  isListType,
+  isNonNullType,
+  isNullableType,
+} from 'graphql/type';
+import { Kind } from 'graphql/language';
+
+export const selectionSetToTsType = (
+  parent: GraphQLObjectType,
+  selections: SelectionNode[] | readonly SelectionNode[],
+  config: Config,
+): TsType => {
+  const type: TsType = {
+    fields: [],
+    unions: [],
+  };
+  for (let selection of selections) {
+    if (selection.kind === Kind.FRAGMENT_SPREAD) {
+      type.unions.push(selection.name.value);
+    }
+
+    if (selection.kind === Kind.FIELD) {
+      const parentField = parent.getFields()[selection.name.value];
+      if (selection.selectionSet && selection.selectionSet.selections.length) {
+        const nestedParent = assertObjectType(getNamedType(parentField.type));
+        type.fields.push({
+          kind: 'object',
+          name: selection.alias?.value || selection.name.value,
+          ...selectionSetToTsType(nestedParent, selection.selectionSet.selections, config),
+          ...getGraphqlTypeWrappers(parentField.type),
+        });
+      } else {
+        type.fields.push({
+          kind: 'inLine',
+          name: selection.alias?.value || selection.name.value,
+          type: graphqlTypeToTypescript(parentField.type, config),
+          ...getGraphqlTypeWrappers(parentField.type),
+        });
+      }
+    }
+  }
+  return type;
+};
+
+export const getGraphqlTypeWrappers = (type: GraphQLType) => {
+  return {
+    isList: isListType(isNonNullType(type) ? getNullableType(type) : type),
+    isNullable: isNullableType(type),
+  };
+};
+
+export const graphqlTypeToTypescript = (type: GraphQLType, config: Config) => {
+  const namedType = getNamedType(type);
+
+  if (namedType instanceof GraphQLScalarType) {
+    return `Scalar["${namedType.name}"]`;
+  }
+
+  switch (namedType.astNode.kind) {
+    case Kind.ENUM_TYPE_DEFINITION:
+      return namedType.name + (config?.suffix?.enum || '');
+    case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+      return namedType.name + (config?.suffix?.input || '');
+    default:
+      throw new Error(`unsupported kind: ${namedType.astNode.kind}`);
+  }
+};
+
+const typeNodeToGraphqlType = (
+  type: TypeNode,
+  schema: GraphQLSchema,
+  isNullable = true,
+  isList = false,
+): GraphQLType => {
+  if (type.kind === Kind.NON_NULL_TYPE) {
+    return typeNodeToGraphqlType(type.type, schema, false, isList);
+  }
+  if (type.kind === Kind.LIST_TYPE) {
+    return typeNodeToGraphqlType(type.type, schema, isNullable, true);
+  }
+
+  let gqlType: GraphQLType = schema.getType(type.name.value);
+  if (isList) {
+    gqlType = new GraphQLList(gqlType);
+  }
+  if (!isNullable) {
+    gqlType = new GraphQLNonNull(gqlType);
+  }
+
+  return gqlType;
+};

package/src/index.ts

@@ -0,0 +1,70 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { findUsageInputs } from './input';
+import { CodegenPlugin, Config } from './_types';
+import {
+  printCreateSdkFunction,
+  printEnum,
+  printFragmentGql,
+  printFragmentType,
+  printHelpers,
+  printInput,
+  printOperationTypes,
+  printScalars,
+} from './print';
+import { findUsageEnums } from './enums';
+import { findUsageFragments } from './fragments';
+import { findUsageOperation, pluginDirectives } from './operation';
+import { findScalars } from './scalar';
+import { runPrettierIfExists } from './prettier';
+import { printSchema } from 'graphql/utilities';
+
+const configDefaults: Partial<Config> = {
+  autoSingleResult: true,
+  prettier: true,
+};
+const directives = pluginDirectives.map(d => `directive @${d} on FIELD`).join('\n');
+const plugin: CodegenPlugin = {
+  plugin(schema, documents, config) {
+    try {
+      config = {
+        ...configDefaults,
+        ...config,
+      };
+      if (config.emitDirectives) {
+        const directivesPath = typeof config.emitDirectives === 'string' ? config.emitDirectives : 'directives.graphql';
+        fs.writeFileSync(path.join(directivesPath), directives);
+      }
+      if (config.emitSchema) {
+        const schemaPath = typeof config.emitSchema === 'string' ? config.emitSchema : 'schema.graphql';
+        fs.writeFileSync(path.join(schemaPath), printSchema(schema));
+      }
+
+      const imports = findUsageInputs(documents, schema);
+      const fragments = findUsageFragments(documents);
+      const operations = findUsageOperation(documents, schema, config);
+      const enums = findUsageEnums(imports, fragments, operations, schema);
+      const scalars = findScalars(schema);
+
+      return runPrettierIfExists(
+        config,
+        [
+          printHelpers(),
+          printScalars(scalars, config),
+          ...enums.map(e => printEnum(e, config)),
+          ...imports.map(i => printInput(i, config)),
+          ...fragments.map(f => printFragmentType(f, schema, config)),
+          ...fragments.map(f => printFragmentGql(f)),
+          ...operations.map(o => printOperationTypes(o, config)),
+          printCreateSdkFunction(operations, config),
+        ].join('\n'),
+      );
+    } catch (e) {
+      console.log(e);
+      process.exit(1);
+    }
+  },
+  addToSchema: directives,
+};
+
+module.exports = plugin;

package/src/input.ts

@@ -0,0 +1,65 @@
+import { GraphQLInputObjectType, GraphQLList, GraphQLNonNull, GraphQLSchema } from 'graphql/type';
+import { getNamedType, GraphQLEnumType, GraphQLInputType, GraphQLScalarType } from 'graphql/type/definition';
+import { CodegenDocuments, TsType } from './_types';
+import { NamedTypeNode, TypeNode } from 'graphql/language/ast';
+import { Kind } from 'graphql/language';
+
+export const findUsageInputs = (documents: CodegenDocuments, schema: GraphQLSchema) => {
+  const inputs = new Set<GraphQLInputObjectType>();
+  for (let { document } of documents) {
+    for (let definition of document.definitions) {
+      if (definition.kind === Kind.OPERATION_DEFINITION) {
+        for (const variableDefinition of definition.variableDefinitions) {
+          const type = unpackVariableType(variableDefinition.type);
+          const name = type.name.value;
+          const input = findInputInSchema(name, schema);
+          if (input) {
+            inputs.add(input);
+            findDeepInputs(input, inputs);
+          }
+        }
+      }
+    }
+  }
+
+  return [...inputs];
+};
+
+const findDeepInputs = (parent: GraphQLInputObjectType, imports = new Set<GraphQLInputObjectType>()) => {
+  for (let field of Object.values(parent.getFields())) {
+    const fieldType = getNamedType(field.type);
+    if (fieldType instanceof GraphQLInputObjectType) {
+      imports.add(fieldType);
+      findDeepInputs(fieldType, imports);
+    }
+  }
+  return imports;
+};
+
+export const findInputInSchema = (name: string, schema: GraphQLSchema) => {
+  const type = schema.getType(name);
+  if (type instanceof GraphQLInputObjectType) {
+    return type;
+  }
+};
+
+const unpackInputType = (type: GraphQLInputType): GraphQLScalarType | GraphQLEnumType | GraphQLInputObjectType => {
+  if (type instanceof GraphQLNonNull) {
+    return unpackInputType(type.ofType);
+  }
+  if (type instanceof GraphQLList) {
+    return unpackInputType(type.ofType);
+  }
+  return type;
+};
+
+const unpackVariableType = (type: TypeNode): NamedTypeNode => {
+  if (type.kind === Kind.NON_NULL_TYPE) {
+    return unpackVariableType(type.type);
+  }
+  if (type.kind === Kind.LIST_TYPE) {
+    return unpackVariableType(type.type);
+  }
+
+  return type;
+};

package/src/operation.ts

@@ -0,0 +1,212 @@
+import {
+  CodegenDocuments,
+  Config,
+  Directive,
+  FieldsMap,
+  NamedTsType,
+  Operation,
+  TsType,
+  TsTypeField,
+  TsTypeFieldObject,
+} from './_types';
+import { Kind } from 'graphql/language/kinds';
+import { FieldNode, FragmentDefinitionNode, OperationTypeNode, SelectionNode, TypeNode } from 'graphql/language/ast';
+import { capitalize } from './utils';
+import { getGraphqlTypeWrappers, graphqlTypeToTypescript, selectionSetToTsType } from './graphql';
+import { GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLSchema } from 'graphql/type';
+import { GraphQLType } from 'graphql/type/definition';
+import { findUsageFragments } from './fragments';
+
+export const pluginDirectives = ['firstOrFail', 'first', 'singleResult', 'required'];
+export const findUsageOperation = (documents: CodegenDocuments, schema: GraphQLSchema, config: Config) => {
+  const allFragments = findUsageFragments(documents);
+  const operations: Operation[] = [];
+  for (let { document } of documents) {
+    for (let definition of document.definitions) {
+      if (definition.kind === Kind.OPERATION_DEFINITION) {
+        const name = definition.name.value;
+        let root: GraphQLObjectType;
+        if (definition.operation === OperationTypeNode.QUERY) {
+          root = schema.getQueryType();
+        } else if (definition.operation === OperationTypeNode.MUTATION) {
+          root = schema.getMutationType();
+        } else if (definition.operation === OperationTypeNode.SUBSCRIPTION) {
+          throw new Error('subscription operation is not supported');
+        }
+
+        const directives = findDirectives(definition.selectionSet.selections);
+        if (
+          config.autoSingleResult !== false &&
+          definition.selectionSet.selections.length === 1 &&
+          !directives.some(d => d.name === 'singleResult')
+        ) {
+          const fields = definition.selectionSet.selections.filter(f => f.kind === Kind.FIELD) as FieldNode[];
+          directives.push({
+            name: 'singleResult',
+            path: fields[0].name.value,
+            args: {},
+          });
+        }
+
+        let resultsType: NamedTsType = {
+          name: capitalize(name) + 'Results',
+          ...selectionSetToTsType(root, definition.selectionSet.selections, config),
+        };
+        for (let directive of directives) {
+          switch (directive.name) {
+            case 'first':
+              changeTsTypeField(resultsType, directive.path, { isList: false });
+              break;
+            case 'firstOrFail':
+              changeTsTypeField(resultsType, directive.path, { isList: false, isNullable: false });
+              break;
+            case 'required':
+              changeTsTypeField(resultsType, directive.path, { isNullable: false });
+              break;
+          }
+        }
+        const singleResult = directives.find(d => d.name === 'singleResult');
+
+        if (singleResult) {
+          const type = getNestedType(resultsType, singleResult.path);
+          resultsType = {
+            ...type,
+            name: resultsType.name,
+          };
+        }
+
+        operations.push({
+          name,
+          definition,
+          directives,
+          singleResultKey: singleResult ? singleResult.path : '',
+          variables: definition.variableDefinitions.length
+            ? {
+                name: capitalize(name) + 'Variables',
+                fields: definition.variableDefinitions.map(variableDefinition => {
+                  const type = parseVariableNode(variableDefinition.type, schema);
+                  return {
+                    name: variableDefinition.variable.name.value,
+                    kind: 'inLine',
+                    type: graphqlTypeToTypescript(type, config),
+                    ...getGraphqlTypeWrappers(type),
+                  };
+                }),
+              }
+            : undefined,
+          results: resultsType,
+          fragments: findFragmentsUsedInSelection(definition.selectionSet.selections, allFragments),
+        });
+      }
+    }
+  }
+  return operations;
+};
+
+const findDirectives = (selections: readonly SelectionNode[], key = '') => {
+  const directives: Directive[] = [];
+  for (let selection of selections) {
+    if (selection.kind === Kind.FIELD) {
+      const path = key + selection.name.value;
+      for (let directive of selection.directives) {
+        if (pluginDirectives.includes(directive.name.value)) {
+          directives.push({
+            name: directive.name.value,
+            path,
+            args: directive.arguments.reduce((args, arg) => {
+              if ('value' in arg.value) {
+                args[arg.name.value] = arg.value.value;
+              }
+              return args;
+            }, {} as Record<string, any>),
+          });
+        }
+      }
+      if (selection.selectionSet?.selections.length) {
+        directives.push(...findDirectives(selection.selectionSet.selections, path + '.'));
+      }
+    }
+  }
+  return directives;
+};
+
+const getNestedType = (type: TsType, path: string) => {
+  let t: TsType = type;
+  for (let key of path.split('.')) {
+    const field = t.fields.find(f => f.name === key);
+    if (!field) {
+      throw new Error(`cannot find field ${key}`);
+    }
+    t = field as TsType;
+  }
+  return t;
+};
+
+const changeTsTypeField = <T extends any>(type: TsType, path: string, value: Partial<TsTypeField>) => {
+  const p = path.split('.');
+  let t: { fields: TsTypeField[] } = type;
+  while (p.length) {
+    const k = p.shift();
+    const f = t.fields.find(f => f.name === k);
+    if (!f) {
+      throw new Error(`cannot find field ${k}`);
+    }
+    if (p.length === 0) {
+      Object.assign(f, value);
+    } else if (f.kind === 'object') {
+      t = f;
+    } else {
+      throw new Error('logic error');
+    }
+  }
+};
+
+const toFieldsMap = (f: TsTypeFieldObject) => {
+  const fields: FieldsMap = {};
+  for (let field of f.fields) {
+    fields[field.name] = {
+      ...field,
+      fields: field.kind === 'object' ? toFieldsMap(field) : {},
+    };
+  }
+  return fields;
+};
+
+const parseVariableNode = (type: TypeNode, schema: GraphQLSchema, isNullable = true, isList = false): GraphQLType => {
+  if (type.kind === Kind.NON_NULL_TYPE) {
+    return parseVariableNode(type.type, schema, false, isList);
+  }
+  if (type.kind === Kind.LIST_TYPE) {
+    return parseVariableNode(type.type, schema, isNullable, true);
+  }
+
+  let gqlType: GraphQLType = schema.getType(type.name.value);
+  if (isList) {
+    gqlType = new GraphQLList(gqlType);
+  }
+  if (!isNullable) {
+    gqlType = new GraphQLNonNull(gqlType);
+  }
+
+  return gqlType;
+};
+
+const findFragmentsUsedInSelection = (
+  selections: readonly SelectionNode[],
+  allFragments: FragmentDefinitionNode[],
+  fragments = new Set<string>(),
+) => {
+  for (let selection of selections) {
+    if (selection.kind === Kind.FRAGMENT_SPREAD) {
+      const name = selection.name.value;
+      const fragment = allFragments.find(f => f.name.value === name);
+      fragments.add(name);
+      findFragmentsUsedInSelection(fragment.selectionSet.selections, allFragments, fragments);
+    }
+    if (selection.kind === Kind.FIELD && selection.selectionSet?.selections.length) {
+      findFragmentsUsedInSelection(selection.selectionSet.selections, allFragments, fragments);
+    }
+  }
+
+  return [...fragments];
+};

package/src/prettier.ts

@@ -0,0 +1,13 @@
+import { Config } from './_types';
+
+export const runPrettierIfExists = (config: Config, content: string) => {
+  if (config.prettier === false) {
+    return content;
+  }
+  try {
+    const prettier = require('prettier');
+    return prettier.format(content, { parser: 'typescript' });
+  } catch (e) {
+    return content;
+  }
+};