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

package/src/print.ts

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

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

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

package/src/enums.js

@@ -1,35 +0,0 @@
-const { GraphQLEnumType } = require('graphql/type');
-const findUsageEnums = (types, schema) => {
-  const enums = [];
-  for (let type of types) {
-    for (let e of findEnumInType(type, schema, enums)) {
-      if (!enums.includes(e)) {
-        enums.push(e);
-      }
-    }
-  }
-
-  return enums.map(e => ({
-    name: e.name,
-    values: e._values.map(({ name, value }) => ({ name, value })),
-  }));
-};
-
-const findEnumInType = (type, schema, ignore) => {
-  const enums = [];
-  for (let field of type.fields) {
-    const type = schema._typeMap[field.typeName];
-    if (type instanceof GraphQLEnumType && !ignore.includes(type)) {
-      enums.push(type);
-    }
-  }
-  return enums;
-};
-
-const findEnumInSchema = (name, schema) => {
-  const type = schema._typeMap[name];
-  if (type instanceof GraphQLEnumType) {
-    return type;
-  }
-};
-module.exports = { findUsageEnums, findEnumInSchema };

package/src/fragments.js

@@ -1,35 +0,0 @@
-const { GraphQLObjectType } = require('graphql/type');
-const { getGraphqlTypeInfo } = require('./types');
-const { getField } = require('./results');
-const findUsageFragments = (documents, schema) => {
-  const fragments = [];
-  for (let { document } of documents) {
-    for (const definition of document.definitions) {
-      if (definition.kind === 'FragmentDefinition') {
-        const name = definition.name.value;
-        const parentName = definition.typeCondition.name.value;
-        const parent = findObjectTypeInSchema(schema, parentName);
-        const nestedFragments = definition.selectionSet.selections.filter(s => s.kind === 'FragmentSpread');
-        const fields = definition.selectionSet.selections.filter(s => s.kind !== 'FragmentSpread');
-        const union = nestedFragments.map(f => f.name.value);
-
-        fragments.push({
-          name,
-          type: definition,
-          union,
-          fields: fields.map(f => getField(parent, f, schema)),
-          gqlType: 'fragment',
-        });
-      }
-    }
-  }
-  return fragments;
-};
-
-const findObjectTypeInSchema = (schema, name) => {
-  const type = schema._typeMap[name];
-  if (type instanceof GraphQLObjectType) {
-    return type;
-  }
-};
-module.exports = { findUsageFragments };

package/src/functions.js

@@ -1,34 +0,0 @@
-const getFunctionChain = (operation, useSingleResults) => {
-  const chain = [];
-  for (let selection of operation.selectionSet.selections) {
-    const directives = selection.directives.map(d => d.name.value);
-    const propertyName = selection.name.value;
-    for (let directive of directives) {
-      if (!['first', 'firstOrFail', 'nonNullable', 'singleResult'].includes(directive)) {
-        continue;
-      }
-      if (directive === 'nonNullable' || directive === 'firstOrFail') {
-        chain.push(`${directive}("${propertyName}", body)`);
-      } else if (directive === 'first') {
-        chain.push(`${directive}("${propertyName}")`);
-      } else {
-        chain.push(directive);
-      }
-    }
-  }
-
-  if (useSingleResults) {
-    const propertyName = operation.selectionSet.selections[0].name.value;
-    chain.push(`unpackSingleResults("${propertyName}")`);
-  }
-  return chain;
-};
-
-const isSingleResultOperation = (operation, config) => {
-  if (config.autoSingleResult === undefined || config.autoSingleResult === true) {
-    return operation.selectionSet.selections.length === 1;
-  }
-  return operation.directives.some(d => d.name.value === 'singleResult');
-};
-
-module.exports = { getFunctionChain, isSingleResultOperation };

package/src/helpers.ts

@@ -1,59 +0,0 @@
-import { AxiosResponse, AxiosInstance, AxiosRequestConfig } from 'axios';
-import { GraphQLError } from 'graphql';
-
-type Nullable<T> = T | undefined;
-
-type GraphqlResponse<T> = {
-  data: T;
-  errors?: GraphQLError[];
-};
-
-type GraphqlRequestParams = {
-  query: string;
-  variables: any;
-};
-const first = (key: string) => (data: any) => {
-  data[key] = data[key][0];
-  return data;
-};
-
-const firstOrFail = (key: string, reqParams: GraphqlRequestParams) => (data: any) => {
-  data[key] = (data as any)[key][0];
-  if (!data[key]) {
-    throw new QueryNoResultsError(reqParams);
-  }
-  return data;
-};
-
-const nonNullable = (key: string, reqParams: GraphqlRequestParams) => (data: any) => {
-  const row = data[key];
-  if (!row) {
-    throw new QueryNoResultsError(reqParams);
-  }
-  return data;
-};
-
-export const handleResponse = ({ data }: AxiosResponse<GraphqlResponse<any>>): any => {
-  const errors = data.errors;
-  if (errors && errors.length > 0) {
-    throw new GraphqlError('Request failed', errors);
-  }
-  return data.data;
-};
-export const unpackSingleResults = (key: string) => (data: any) => data[key];
-
-export class GraphqlError extends Error {
-  constructor(message: string, public gqlErrors: GraphQLError[]) {
-    super(`${message} ${gqlErrors.map(e => e.message).join('\n')}`);
-  }
-}
-
-export class QueryNoResultsError extends Error {
-  query: string;
-  variables: any;
-  constructor(params: GraphqlRequestParams) {
-    super(`Query has no results`);
-    this.query = params.query;
-    this.variables = params.variables;
-  }
-}

package/src/index.js

@@ -1,94 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { findUsageInputs } = require('./input');
-const { getVariablesFields } = require('./variables');
-const { getResultType } = require('./results');
-const { findScalars } = require('./scalar');
-const {
-  renderType,
-  renderQuery,
-  renderSdk,
-  renderScalars,
-  renderEnum,
-  renderHeader,
-  renderFragment,
-} = require('./render');
-const { findUsageEnums } = require('./enums');
-const { findUsageFragments } = require('./fragments');
-const { getFunctionChain, isSingleResultOperation } = require('./functions');
-const { capitalize } = require('./utils');
-
-const helpers = fs.readFileSync(path.join(__dirname, 'helpers.ts'), 'utf-8');
-const directives = `directive @first on FIELD
-directive @firstOrFail on FIELD
-directive @singleResult on QUERY | MUTATION
-directive @nonNullable on FIELD`;
-module.exports = {
-  plugin(schema, documents, config) {
-    try {
-      fs.writeFileSync(path.join(config.directivesFilePath || '', 'directives.graphql'), directives);
-      const functions = [];
-      const queries = [];
-      const inputs = findUsageInputs(documents, schema);
-      const fragments = findUsageFragments(documents, schema);
-      const types = [];
-      const scalars = findScalars(schema);
-
-      for (let { document } of documents) {
-        for (const definition of document.definitions) {
-          if (definition.kind !== 'OperationDefinition') {
-            continue;
-          }
-          const name = definition.name.value;
-          const useSingleResults = isSingleResultOperation(definition, config);
-
-          const results = getResultType(definition, schema, document, useSingleResults);
-          types.push(results);
-
-          const variables = {
-            name: capitalize(`${name}Variables`),
-            fields: getVariablesFields(definition, schema),
-          };
-          types.push(variables);
-
-          queries.push({
-            name,
-            ast: definition,
-            allFragments: fragments,
-          });
-
-          functions.push({
-            name,
-            results,
-            variables,
-            chain: getFunctionChain(definition, useSingleResults),
-          });
-        }
-      }
-
-      const enums = findUsageEnums([...types, ...inputs, ...fragments], schema);
-      return [
-        renderHeader('HELPERS'),
-        helpers,
-        renderHeader('Scalars'),
-        renderScalars(scalars, config),
-        renderHeader('Enum'),
-        ...enums.map(e => renderEnum(e, config)),
-        renderHeader('FRAGMENTS'),
-        ...fragments.map(t => renderType(t, config)),
-        ...fragments.map(f => renderFragment(f)),
-        renderHeader('INPUTS'),
-        ...inputs.map(t => renderType(t, config)),
-        renderHeader('TYPES'),
-        ...types.map(t => renderType(t, config)),
-        renderHeader('QUERIES'),
-        ...queries.map(q => renderQuery(q)),
-        renderSdk(functions),
-      ].join('\n');
-    } catch (e) {
-      console.log(e);
-      process.exit(1);
-    }
-  },
-  addToSchema: directives,
-};

package/src/input.js

@@ -1,77 +0,0 @@
-const { GraphQLInputObjectType, GraphQLNonNull, GraphQLList } = require('graphql/type');
-const { getGraphqlTypeInfo } = require('./types');
-const findUsageInputs = (documents, schema) => {
-  const inputs = [];
-  for (let { document } of documents) {
-    for (let definition of document.definitions) {
-      if (definition.kind !== 'OperationDefinition') {
-        continue;
-      }
-      for (const variableDefinition of definition.variableDefinitions) {
-        const type = unpackVariableType(variableDefinition.type);
-        const name = type.name.value;
-        const input = findInputInSchema(name, schema);
-        if (input && !inputs.includes(input)) {
-          inputs.push(input);
-          inputs.push(...findInputDependencies(input, schema, inputs));
-        }
-      }
-    }
-  }
-  return [...new Set(inputs)].map(input => ({
-    name: input.name,
-    fields: getInputFields(input),
-    gqlType: 'input',
-  }));
-};
-const findInputInSchema = (name, schema) => {
-  const type = schema._typeMap[name];
-  if (type instanceof GraphQLInputObjectType) {
-    return type;
-  }
-};
-const findInputDependencies = (input, schema, ignore) => {
-  const dependencies = [];
-  for (let field of Object.values(input._fields)) {
-    const type = unpackInputType(field.type);
-    if (type instanceof GraphQLInputObjectType && !ignore.includes(type)) {
-      dependencies.push(type);
-      dependencies.push(...findInputDependencies(type, schema, [...ignore, ...dependencies]));
-    }
-  }
-  return dependencies;
-};
-
-const getInputFields = input => {
-  return Object.values(input._fields).map(field => {
-    const typeInfo = getGraphqlTypeInfo(field.type);
-    return {
-      name: field.name,
-      fields: [],
-      ...typeInfo,
-      inLine: !typeInfo.isScalar,
-    };
-  });
-};
-
-const unpackInputType = type => {
-  if (type instanceof GraphQLNonNull) {
-    return unpackInputType(type.ofType);
-  }
-  if (type instanceof GraphQLList) {
-    return unpackInputType(type.ofType);
-  }
-  return type;
-};
-
-const unpackVariableType = type => {
-  if (type.kind === 'ListType') {
-    return unpackVariableType(type.type);
-  }
-  if (type.kind === 'NonNullType') {
-    return unpackVariableType(type.type);
-  }
-  return type;
-};
-
-module.exports = { findUsageInputs, findInputInSchema };

package/src/query.js

@@ -1,14 +0,0 @@
-const { print } = require('graphql/index');
-const getUsedFragments = (raw, allFragments, results = []) => {
-  const fragments = [...raw.matchAll(/\.\.\.(\w*)$/gm)]
-    .map(([_, name]) => name)
-    .map(name => allFragments.find(d => d.name === name));
-
-  for (let fragment of fragments) {
-    getUsedFragments(print(fragment.type), allFragments, results);
-  }
-  results.push(...fragments);
-  return results;
-};
-
-module.exports = { getUsedFragments };

package/src/render.js

@@ -1,118 +0,0 @@
-const { print } = require('graphql/index');
-const { getUsedFragments } = require('./query');
-const { GraphQLInputObjectType, GraphQLEnumType } = require('graphql/type');
-const { get } = require('axios');
-const { capitalize } = require('./utils');
-
-const getName = (name, type, config) => {
-  const suffix = config.suffix ? config.suffix[type] || '' : '';
-  return `${name}${suffix}`;
-};
-const renderType = ({ name, fields, union, isList, isNullable, gqlType }, config) => {
-  let tsType = '';
-  if (union && union.length) {
-    tsType += [...union.map(u => getName(u, 'fragment', config)), ''].join(' & ');
-  }
-  tsType += `{${renderTypeField(fields, config)}}`;
-  tsType = `(${tsType})`;
-  if (isList) {
-    tsType += '[]';
-  }
-  if (isNullable) {
-    tsType = `Nullable<${tsType}>`;
-  }
-
-  return `export type ${gqlType ? getName(name, gqlType, config) : name} =  ${tsType}`;
-};
-
-const renderHeader = text => `/** \n ${text} \n **/`;
-const renderTypeField = (fields, config) => {
-  return fields
-    .map(({ isList, isNullable, typeName, name, fields, isScalar, union, type, inLine, gqlType, alias }) => {
-      let tsType = '';
-      if (union && union.length) {
-        tsType += [...union.map(u => getName(u, 'fragment', config)), ''].join(' & ');
-      }
-      if (isScalar) {
-        tsType += getScalarTsType(typeName);
-      } else if (inLine) {
-        tsType += gqlType ? getName(typeName, gqlType, config) : typeName;
-      } else {
-        if (type instanceof GraphQLInputObjectType || type instanceof GraphQLEnumType) {
-          tsType += gqlType ? getName(typeName, gqlType, config) : typeName;
-        } else {
-          tsType += `{${renderTypeField(fields, config)}}`;
-        }
-      }
-      tsType = `(${tsType})`;
-      if (isList) {
-        tsType += '[]';
-      }
-      if (isNullable) {
-        tsType = `Nullable<${tsType}>`;
-      }
-      return `${alias || name}${isNullable ? '?' : ''}: ${tsType}`;
-    })
-    .join(',\n');
-};
-
-const renderSdk = functions => {
-  let str = '{';
-  for (let func of functions) {
-    str += `${func.name}: ${renderFunction(func)},\n`;
-  }
-  str += '}';
-  return `export const getSdk = (client: AxiosInstance) => (${str})`;
-};
-const renderFunction = ({ name, variables, results, chain }) => {
-  const chainStr = chain.map(f => `.then(${f})`).join('');
-  return `(variables: ${variables.name}, config?: AxiosRequestConfig): Promise<${results.name}> => {
-    const body = {variables, query: ${name}RawQuery};
-    return client.post("", body, config).then(handleResponse)${chainStr}
-}`;
-};
-
-const renderQuery = ({ name, ast, allFragments }) => {
-  const raw = print(ast)
-    .replace(/@firstOrFail/g, '')
-    .replace(/@first/g, '')
-    .replace(/@nonNullable/g, '')
-    .replace(/@singleResult/g, '');
-
-  let fragments = getUsedFragments(raw, allFragments);
-  fragments = [...new Set(fragments)].map(f => `\${${f.name}FragmentQuery}`);
-
-  const gql = fragments.join('\n') + '\n' + raw;
-  return `const ${name}RawQuery = \`${gql}\`;`;
-};
-
-const getScalarTsType = name => `Scalar["${name}"]`;
-
-const renderEnum = (e, config) => {
-  let str = `export enum ${getName(e.name, 'enum', config)} {`;
-  for (let { name, value } of e.values) {
-    str += `${capitalize(name.toLowerCase())} = "${value}",`;
-  }
-  str += `};`;
-  return str;
-};
-
-const renderFragment = fragment => {
-  return `export const ${fragment.name}FragmentQuery = \`${print(fragment.type)}\`;`;
-};
-const renderScalars = (scalars, config = {}) => {
-  const map = {
-    String: 'string',
-    Boolean: 'boolean',
-    Int: 'number',
-    Float: 'number',
-    ...(config.scalars || {}),
-  };
-  return `export type Scalar = {${scalars
-    .map(({ name }) => {
-      const type = map[name] || 'string';
-      return `${name}: ${type}`;
-    })
-    .join(',')}};`;
-};
-module.exports = { renderType, renderQuery, renderSdk, renderScalars, renderEnum, renderHeader, renderFragment };

package/src/results.js

@@ -1,43 +0,0 @@
-const { getGraphqlTypeInfo, assignDirectivesToType } = require('./types');
-const { capitalize } = require('./utils');
-
-const getResultType = (definition, schema, document, useSingleResults) => {
-  const name = capitalize(`${definition.name.value}Results`);
-  const fields = getResultsFields(definition, schema, document, useSingleResults);
-  if (useSingleResults) {
-    return {
-      ...fields[0],
-      name,
-    };
-  }
-  return {
-    name,
-    fields,
-  };
-};
-const getResultsFields = (definition, schema, document) => {
-  const operationType = definition.operation;
-  const name = schema[`_${operationType}Type`].name;
-  const parent = schema._typeMap[name];
-  const fields = definition.selectionSet.selections.map(field => getField(parent, field, schema, document));
-  return fields;
-};
-
-const getField = (parent, field, schema, document) => {
-  const name = field.name.value;
-  const selections = field.selectionSet?.selections || [];
-  const fragments = selections.filter(s => s.kind === 'FragmentSpread');
-  let type = assignDirectivesToType(getGraphqlTypeInfo(parent._fields[name].type), field.directives);
-  const union = fragments.map(f => f.name.value);
-  const fields = selections.filter(s => s.kind !== 'FragmentSpread').map(f => getField(type.type, f, schema, document));
-
-  return {
-    name,
-    ...type,
-    fields,
-    union,
-    alias: field.alias?.value,
-  };
-};
-
-module.exports = { getResultType, getField };

package/src/scalar.js

@@ -1,6 +0,0 @@
-const { GraphQLScalarType } = require('graphql/type');
-const findScalars = schema => {
-  return Object.values(schema._typeMap).filter(t => t instanceof GraphQLScalarType);
-};
-
-module.exports = { findScalars };