@devticon-os/graphql-codegen-axios 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devticon-os/graphql-codegen-axios",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "license": "MIT",
   "main": "src/index.js",
   "repository": "https://github.com/devticon/graphql-codegen-axios",

package/src/fragments.js

@@ -18,6 +18,7 @@ const findUsageFragments = (documents, schema) => {
           type: definition,
           union,
           fields: fields.map(f => getField(parent, f, schema)),
+          gqlType: 'fragment',
         });
       }
     }

package/src/functions.js

@@ -0,0 +1,26 @@
+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 (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 => operation.selectionSet.selections.length === 1;
+
+module.exports = { getFunctionChain, isSingleResultOperation };

package/src/helpers.ts

@@ -1,5 +1,7 @@
-import { AxiosResponse, AxiosInstance, AxiosRequestConfig } from "axios";
-import { GraphQLError } from "graphql";
+import { AxiosResponse, AxiosInstance, AxiosRequestConfig } from 'axios';
+import { GraphQLError } from 'graphql';
+
+type Nullable<T> = T | undefined;
 
 type GraphqlResponse<T> = {
   data: T;
@@ -10,45 +12,41 @@ type GraphqlRequestParams = {
   query: string;
   variables: any;
 };
-const first = <T>(data: T[]) => data[0];
+const first = (key: string) => (data: any) => {
+  data[key] = data[key][0];
+  return data;
+};
 
-const firstOrFail =
-  <T>(reqParams: GraphqlRequestParams) =>
-    (data: T[]) => {
-      const row = data[0];
-      if (!row) {
-        throw new QueryNoResultsError(reqParams);
-      }
-      return row;
-    };
+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 =
   <T>(reqParams: GraphqlRequestParams) =>
-    (data: T) => {
-      const row = data;
-      if (!row) {
-        throw new QueryNoResultsError(reqParams);
-      }
-      return row;
-    };
+  (data: T) => {
+    const row = data;
+    if (!row) {
+      throw new QueryNoResultsError(reqParams);
+    }
+    return row;
+  };
 
-export const handleResponse = <T>({
-                                    data,
-                                  }: AxiosResponse<GraphqlResponse<T>>) => {
+export const handleResponse = <T>({ data }: AxiosResponse<GraphqlResponse<T>>) => {
   const errors = data.errors;
   if (errors && errors.length > 0) {
-    throw new GraphqlError("Request failed", errors);
+    throw new GraphqlError('Request failed', errors);
   }
   return data.data;
 };
-export const unpackSingleResults =
-  <T extends Object, K extends keyof T>(key: K) =>
-    (data: T) =>
-      data[key];
+export const unpackSingleResults = (key: string) => (data: any) => data[key];
 
 export class GraphqlError extends Error {
   constructor(message: string, public gqlErrors: GraphQLError[]) {
-    const msg = `${message} ${gqlErrors.map((e) => e.message).join("\n")}`;
+    const msg = `${message} ${gqlErrors.map(e => e.message).join('\n')}`;
     super(msg);
   }
 }

package/src/index.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const { findUsageInputs } = require('./input');
 const { getVariablesFields } = require('./variables');
-const { getResultsFields } = require('./results');
+const { getResultsFields, getResultType } = require('./results');
 const { findScalars } = require('./scalar');
 const {
   renderType,
@@ -15,8 +15,8 @@ const {
 } = require('./render');
 const { findUsageEnums } = require('./enums');
 const { findUsageFragments } = require('./fragments');
-
-const capitalize = str => str.charAt(0).toUpperCase() + str.slice(1);
+const { getFunctionChain, isSingleResultOperation } = require('./functions');
+const { capitalize } = require('./utils');
 
 const helpers = fs.readFileSync(path.join(__dirname, 'helpers.ts'), 'utf-8');
 module.exports = {
@@ -35,11 +35,9 @@ module.exports = {
             continue;
           }
           const name = definition.name.value;
+          const useSingleResults = isSingleResultOperation(definition);
 
-          const results = {
-            name: capitalize(`${name}Results`),
-            fields: getResultsFields(definition, schema, document),
-          };
+          const results = getResultType(definition, schema, document, useSingleResults);
           types.push(results);
 
           const variables = {
@@ -58,28 +56,9 @@ module.exports = {
             name,
             results,
             variables,
-            chain: [],
+            chain: getFunctionChain(definition, useSingleResults),
           });
         }
-
-        //   if (definition.selectionSet.selections.length === 1) {
-        //     if (!['query', 'mutation'].includes(definition.operation)) {
-        //       continue;
-        //     }
-        //     const selection = definition.selectionSet.selections[0];
-        //     const directives = selection.directives.map(d => d.name.value);
-        //     const propertyName = selection.name.value;
-        //     func += `.then(unpackSingleResults("${propertyName}"))\n`;
-        //     for (let directive of directives) {
-        //       if (directive === 'nonNullable' || directive === 'firstOrFail') {
-        //         func += `.then(${directive}({variables, query: ${name}RawQuery}))\n`;
-        //       } else {
-        //         func += `.then(${directive})\n`;
-        //       }
-        //     }
-        //   }
-        //   functions[name] = func;
-        // }
       }
 
       const enums = findUsageEnums([...types, ...inputs, ...fragments], schema);
@@ -89,14 +68,14 @@ module.exports = {
         renderHeader('Scalars'),
         renderScalars(scalars),
         renderHeader('Enum'),
-        ...enums.map(e => renderEnum(e)),
+        ...enums.map(e => renderEnum(e, config)),
         renderHeader('FRAGMENTS'),
-        ...fragments.map(t => renderType(t)),
+        ...fragments.map(t => renderType(t, config)),
         ...fragments.map(f => renderFragment(f)),
         renderHeader('INPUTS'),
-        ...inputs.map(t => renderType(t)),
+        ...inputs.map(t => renderType(t, config)),
         renderHeader('TYPES'),
-        ...types.map(t => renderType(t)),
+        ...types.map(t => renderType(t, config)),
         renderHeader('QUERIES'),
         ...queries.map(q => renderQuery(q)),
         renderSdk(functions),

package/src/input.js

@@ -21,6 +21,7 @@ const findUsageInputs = (documents, schema) => {
   return [...new Set(inputs)].map(input => ({
     name: input.name,
     fields: getInputFields(input),
+    gqlType: 'input',
   }));
 };
 const findInputInSchema = (name, schema) => {

package/src/render.js

@@ -1,22 +1,39 @@
 const { print } = require('graphql/index');
 const { getUsedFragments } = require('./query');
 const { GraphQLInputObjectType } = require('graphql/type');
-const renderType = ({ name, fields, union }) => {
-  return `export type ${name} = ${union ? union.join('&') + '&' : ''} { ${renderTypeField(fields)} };`;
+
+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)}}`;
+  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 => {
+const renderTypeField = (fields, config) => {
   return fields
-    .map(({ isList, isNullable, typeName, name, fields, isScalar, union, type, inLine }) => {
+    .map(({ isList, isNullable, typeName, name, fields, isScalar, union, type, inLine, gqlType }) => {
       let tsType = '';
       if (union && union.length) {
-        tsType += [...union, ''].join(' & ');
+        tsType += [...union.map(u => getName(u, 'fragment', config)), ''].join(' & ');
       }
       if (isScalar) {
         tsType += getScalarTsType(typeName);
       } else if (inLine) {
-        tsType += typeName;
+        tsType += gqlType ? getName(typeName, gqlType, config) : typeName;
       } else {
         if (type instanceof GraphQLInputObjectType) {
           tsType += typeName;
@@ -24,7 +41,13 @@ const renderTypeField = fields => {
           tsType += `{${renderTypeField(fields)}}`;
         }
       }
-      return `${name}${isNullable ? '?' : ''}: ${tsType}${isList ? '[]' : ''}`;
+      if (isList) {
+        tsType += '[]';
+      }
+      if (isNullable) {
+        tsType = `Nullable<${tsType}>`;
+      }
+      return `${name}: ${tsType}`;
     })
     .join(',\n');
 };
@@ -37,8 +60,12 @@ const renderSdk = functions => {
   str += '}';
   return `export const getSdk = (client: AxiosInstance) => (${str})`;
 };
-const renderFunction = ({ name, variables, results }) => {
-  return `(variables: ${variables.name}, config?: AxiosRequestConfig) => client.post<GraphqlResponse<${results.name}>>("", {variables, query: ${name}RawQuery}, config).then(handleResponse)`;
+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 }) => {
@@ -53,8 +80,8 @@ const renderQuery = ({ name, ast, allFragments }) => {
 
 const getScalarTsType = name => `Scalar["${name}"]`;
 
-const renderEnum = e => {
-  let str = `export enum ${e.name} {`;
+const renderEnum = (e, config) => {
+  let str = `export enum ${getName(e.name, 'enum', config)} {`;
   for (let { name, value } of e.values) {
     str += `${name} = "${value}",`;
   }

package/src/results.js

@@ -1,28 +1,36 @@
-const { getGraphqlTypeInfo } = require('./types');
+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.charAt(0).toUpperCase() + definition.operation.slice(1);
-  const parent = schema._typeMap[operationType];
-  return definition.selectionSet.selections.map(field => getField(parent, field, 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 = getGraphqlTypeInfo(parent._fields[name].type);
+  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));
 
-  //
-  // const fields = [];
-  // for (let selection of selections) {
-  //   const isFragment = selection.kind === 'FragmentSpread';
-  //   if (isFragment) {
-  //     fields.push({ typeName: selection.name.value, isScalar: false, isList: false, isNullable: false, fields: [] });
-  //   } else {
-  //     fields.push(getField(type.type, selection, schema, document));
-  //   }
-  // }
   return {
     name,
     ...type,
@@ -31,4 +39,4 @@ const getField = (parent, field, schema, document) => {
   };
 };
 
-module.exports = { getResultsFields, getField };
+module.exports = { getResultType, getField };

package/src/types.js

@@ -1,4 +1,11 @@
-const { GraphQLList, GraphQLNonNull, GraphQLScalarType } = require('graphql/type');
+const {
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLScalarType,
+  GraphQLEnumType,
+  GraphQLInputObjectType,
+  GraphQLObjectType,
+} = require('graphql/type');
 const getGraphqlTypeInfo = (type, isList = false, isNullable = true) => {
   if (type instanceof GraphQLList) {
     isList = true;
@@ -9,7 +16,34 @@ const getGraphqlTypeInfo = (type, isList = false, isNullable = true) => {
     return getGraphqlTypeInfo(type.ofType, isList, isNullable);
   }
   const isScalar = type instanceof GraphQLScalarType;
-  return { type, isList, isNullable, typeName: type.name, isScalar };
+  return { type, isList, isNullable, typeName: type.name, isScalar, gqlType: getGraphqlType(type) };
 };
 
-module.exports = { getGraphqlTypeInfo };
+const getGraphqlType = type => {
+  if (type instanceof GraphQLEnumType) {
+    return 'enum';
+  }
+  if (type instanceof GraphQLInputObjectType) {
+    return 'input';
+  }
+};
+const assignDirectivesToType = (typeInfo, directives) => {
+  const newType = { ...typeInfo };
+  for (let directive of directives) {
+    switch (directive.name.value) {
+      case 'firstOrFail':
+        newType.isList = false;
+        newType.isNullable = false;
+        break;
+      case 'first':
+        newType.isList = false;
+        newType.isNullable = true;
+        break;
+      case 'nonNullable':
+        newType.isNullable = false;
+        break;
+    }
+  }
+  return newType;
+};
+module.exports = { getGraphqlTypeInfo, assignDirectivesToType, getGraphqlType };

package/src/utils.js

@@ -0,0 +1,3 @@
+const capitalize = str => str.charAt(0).toUpperCase() + str.slice(1);
+
+module.exports = { capitalize };

package/src/variables.js

@@ -1,4 +1,5 @@
 const { findInputInSchema } = require('./input');
+const { getGraphqlType } = require('./types');
 const getVariablesFields = (definition, schema) => {
   return definition.variableDefinitions.map(variable => ({
     name: variable.variable.name.value,
@@ -18,7 +19,15 @@ const getVariableType = (type, schema, isList = false, isNullable = true) => {
   }
   const typeName = type.name.value;
   const isScalar = !findInputInSchema(typeName, schema);
-  return { type: type.type, isList, isNullable, typeName, isScalar, inLine: !isScalar };
+  return {
+    type: type.type,
+    isList,
+    isNullable,
+    typeName,
+    isScalar,
+    inLine: !isScalar,
+    gqlType: isScalar ? 'scalar' : 'input',
+  };
 };
 
 module.exports = { getVariablesFields };