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

package/src/operation.ts

@@ -1,212 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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;
-  }
-};

package/src/print.ts

@@ -1,139 +0,0 @@
-import {
-  assertObjectType,
-  GraphQLEnumType,
-  GraphQLInputObjectType,
-  GraphQLScalarType,
-  GraphQLSchema,
-} from 'graphql/type';
-import { Config, NamedTsType, Operation, TsTypeField } from './_types';
-import { print } from 'graphql/language';
-import { FragmentDefinitionNode } from 'graphql/language/ast';
-import { getGraphqlTypeWrappers, graphqlTypeToTypescript, selectionSetToTsType } from './graphql';
-import * as fs from 'fs';
-import * as path from 'path';
-import { pluginDirectives } from './operation';
-
-export const printOperationTypes = (operation: Operation, config: Config) => {
-  const content: string[] = [];
-  if (operation.variables) {
-    content.push(printTsType(operation.variables));
-  }
-  content.push(printTsType(operation.results));
-
-  const queryFragments = operation.fragments.map(fragment => `$\{${fragment}FragmentQuery}\n`);
-  let query = print(operation.definition);
-  for (let pluginDirective of pluginDirectives) {
-    query = query.replace(new RegExp('@' + pluginDirective, 'g'), '');
-  }
-  content.push(`const ${getOperationQueryName(operation.name)} = \`${queryFragments.join('')}${query}\`;`);
-  return content.join('\n');
-};
-
-export const printCreateSdkFunction = (operations: Operation[], config: Config) => {
-  const fields = operations
-    .map(operation => {
-      const hasVariables = !!operation.variables;
-      const functions: string[] = [];
-
-      for (let directive of operation.directives) {
-        switch (directive.name) {
-          case 'first':
-          case 'firstOrFail':
-          case 'required':
-            functions.push(`${directive.name}("${directive.path}")`);
-            break;
-        }
-      }
-
-      if (operation.singleResultKey) {
-        functions.push(`singleResult("${operation.singleResultKey}")`);
-      }
-      const defArgs: string[] = [];
-      const execArgs: string[] = ['client'];
-      if (hasVariables) {
-        defArgs.push(`variables: ${operation.variables.name}`);
-        execArgs.push(`{variables, query: ${getOperationQueryName(operation.name)}}`);
-      } else {
-        execArgs.push(`{query: ${getOperationQueryName(operation.name)}}`);
-      }
-      execArgs.push(`[${functions.join(',')}]`);
-      execArgs.push('config');
-      defArgs.push(`config?: AxiosRequestConfig`);
-      return `${operation.name}: (${defArgs.join(',')}): Promise<${operation.results.name}> => execute(${execArgs.join(
-        ',',
-      )})`;
-    })
-    .join(',');
-  return `export const createSdk = (client: AxiosInstance) => ({${fields}});`;
-};
-export const printEnum = (e: GraphQLEnumType, config: Config) => {
-  const suffix = config?.suffix?.enum || '';
-  const values = e.getValues().map(({ name, value }) => `${name} = "${value}"`);
-  return `export enum ${e.name + suffix} {${values.join(',')}};`;
-};
-export const printFragmentType = (fragment: FragmentDefinitionNode, schema: GraphQLSchema, config: Config) => {
-  const suffix = config?.suffix?.input || '';
-  const parent = assertObjectType(schema.getType(fragment.typeCondition.name.value));
-  return printTsType({
-    name: fragment.name.value + suffix,
-    ...selectionSetToTsType(parent, fragment.selectionSet.selections, config),
-  });
-};
-
-export const printFragmentGql = (fragment: FragmentDefinitionNode) => {
-  return `const ${fragment.name.value}FragmentQuery = \`${print(fragment)}\``;
-};
-
-export const printInput = (input: GraphQLInputObjectType, config: Config) => {
-  const suffix = config?.suffix?.input || '';
-  return printTsType({
-    name: input.name + suffix,
-    fields: Object.values(input.getFields()).map(field => ({
-      name: field.name,
-      kind: 'inLine',
-      type: graphqlTypeToTypescript(field.type, config),
-      ...getGraphqlTypeWrappers(field.type),
-    })),
-  });
-};
-
-export const printHelpers = () => {
-  return fs.readFileSync(path.resolve(__dirname, '../templates/helpers.ts'));
-};
-
-export const printScalars = (scalars: GraphQLScalarType[], config: Config) => {
-  const map: Record<string, string> = {
-    String: 'string',
-    Int: 'number',
-    Float: 'number',
-    Boolean: 'boolean',
-    ...(config.scalars || {}),
-  };
-
-  return `export type Scalar = {${Object.entries(map).map(([name, value]) => `${name}: ${value}`)}};`;
-};
-const printTsTypeFields = (fields: TsTypeField[]) => {
-  const ts: string[] = fields.map(field => {
-    let fieldType: string;
-    if (field.kind === 'inLine') {
-      fieldType = field.type;
-    } else {
-      const unions = field.unions?.length ? field.unions.join(' & ') + ' &' : '';
-      fieldType = unions + printTsTypeFields(field.fields);
-    }
-    if (field.isList) {
-      fieldType += '[]';
-    }
-    if (field.isNullable) {
-      fieldType = `Nullable<${fieldType}>`;
-    }
-    return `${field.name}${field.isNullable ? '?' : ''}: ${fieldType}`;
-  });
-  return `{${ts.join(',')}}`;
-};
-const printTsType = (type: NamedTsType) => {
-  const union = type.unions && type.unions.length ? type.unions.join(' & ') + ' &' : '';
-  return `export type ${type.name} = ${union} ${printTsTypeFields(type.fields)};`;
-};
-
-const getOperationQueryName = (name: string) => `${name}Query`;

package/src/scalar.ts

@@ -1,5 +0,0 @@
-import { GraphQLScalarType, GraphQLSchema } from 'graphql/type';
-
-export const findScalars = (schema: GraphQLSchema) => {
-  return Object.values(schema.getTypeMap()).filter(t => t instanceof GraphQLScalarType) as GraphQLScalarType[];
-};

package/src/utils.ts

@@ -1 +0,0 @@
-export const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);