@devticon-os/graphql-codegen-axios 0.1.4 → 0.2.0

package/package.json

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

package/src/enums.js

@@ -0,0 +1,24 @@
+const { GraphQLEnumType } = require('graphql/type');
+const findUsageEnums = (types, schema) => {
+  const enums = [];
+  for (let type of types) {
+    enums.push(...findEnumInType(type, schema, enums));
+  }
+
+  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;
+};
+module.exports = { findUsageEnums };

package/src/fragments.js

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

package/src/index.js

@@ -1,111 +1,96 @@
-const fs = require("fs");
-const path = require("path");
-const { print } = require("graphql");
+const fs = require('fs');
+const path = require('path');
+const { print } = require('graphql');
+const { GraphQLList, GraphQLNonNull, GraphQLInputObjectType } = require('graphql/type');
+const { findUsageInputs } = require('./input');
+const { getVariablesFields } = require('./variables');
+const { getResultsFields } = require('./results');
+const { findScalars } = require('./scalar');
+const { renderType, renderQuery, renderSdk, renderScalars, renderEnum } = require('./render');
+const { findUsageEnums } = require('./enums');
+const { findUsageFragments } = require('./fragments');
 
-const getType = (name, operationType, type) => {
-  name = name.charAt(0).toUpperCase() + name.slice(1);
-  operationType =
-    operationType.charAt(0).toUpperCase() + operationType.slice(1);
-  switch (type) {
-    case "variables":
-      return `${name}${operationType}Variables`;
-    case "results":
-      return `${name}${operationType}`;
-  }
-};
-
-const functionsToString = (functions) => {
-  let str = "{";
-  for (let [name, body] of Object.entries(functions)) {
-    str += `${name}: ${body},\n`;
-  }
-  str += "}";
-  return str;
-};
-
-const getUsedFragments = (raw, allFragments, results = []) => {
-  const fragments = [...raw.matchAll(/\.\.\.(\w*)$/gm)]
-    .map(([_, name]) => name)
-    .map((name) => allFragments.find((d) => d.name.value === name));
-
-  for (let fragment of fragments) {
-    getUsedFragments(print(fragment), allFragments, results);
-  }
-  results.push(...fragments);
-  return results;
-};
-const printOperation = (ast, allFragments) => {
-  ast.directives = ast.directives.filter(
-    (d) => !["first", "firstOrFail"].includes(d.name.value)
-  );
-  const raw = print(ast)
-    .replace("@firstOrFail", "")
-    .replace("@first", "")
-    .replace("@nonNullable", "");
+const capitalize = str => str.charAt(0).toUpperCase() + str.slice(1);
 
-  let fragments = getUsedFragments(raw, allFragments);
-  fragments = [...new Set(fragments)].map((f) => print(f));
-
-  return fragments.join("\n") + "\n" + raw;
-};
-
-const helpers = fs.readFileSync(path.join(__dirname, "helpers.ts"), "utf-8");
+const helpers = fs.readFileSync(path.join(__dirname, 'helpers.ts'), 'utf-8');
 module.exports = {
   plugin(schema, documents, config) {
-    const functions = {};
-    const queries = [];
-    const fragments = [];
+    try {
+      const functions = [];
+      const queries = [];
+      const fragments = findUsageFragments(documents, schema);
+      const types = [...fragments];
+      const scalars = findScalars(schema);
 
-    for (let { document } of documents) {
-      for (const definition of document.definitions) {
-        if (definition.kind === "FragmentDefinition") {
-          fragments.push(definition);
-        }
-      }
-    }
+      for (let { document } of documents) {
+        const inputs = findUsageInputs(document, schema);
+        types.push(...inputs);
 
-    for (let { document } of documents) {
-      for (const definition of document.definitions) {
-        const name = definition.name.value;
+        for (const definition of document.definitions) {
+          if (definition.kind !== 'OperationDefinition') {
+            continue;
+          }
+          const name = definition.name.value;
 
-        if (definition.kind !== "OperationDefinition") {
-          continue;
-        }
-        const variablesType = getType(name, definition.operation, "variables");
-        const resultsType = getType(name, definition.operation, "results");
+          const results = {
+            name: capitalize(`${name}Results`),
+            fields: getResultsFields(definition, schema, document),
+          };
+          types.push(results);
 
-        queries.push(
-          `const ${name}RawQuery = \`${printOperation(
-            definition,
-            fragments
-          )}\`;`
-        );
-        let func = `(variables: ${variablesType}, config?: AxiosRequestConfig) => client.post<GraphqlResponse<${resultsType}>>("", {variables, query: ${name}RawQuery}, config).then(handleResponse)`;
+          const variables = {
+            name: capitalize(`${name}Variables`),
+            fields: getVariablesFields(definition, schema),
+          };
+          types.push(variables);
 
-        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`;
-            }
-          }
+          queries.push({
+            name,
+            ast: definition,
+            allFragments: fragments,
+          });
+
+          functions.push({
+            name,
+            results,
+            variables,
+            chain: [],
+          });
         }
-        functions[name] = func;
+
+        //   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 sdk = `export const getSdk = (client: AxiosInstance) => (${functionsToString(
-      functions
-    )})`;
-    return [...queries, helpers, sdk].join("\n");
+      const enums = findUsageEnums(types, schema);
+      return [
+        helpers,
+        renderScalars(scalars),
+        ...enums.map(e => renderEnum(e)),
+        ...types.map(t => renderType(t)),
+        ...queries.map(q => renderQuery(q)),
+        renderSdk(functions),
+      ].join('\n');
+    } catch (e) {
+      console.log(e);
+      process.exit(1);
+    }
   },
   addToSchema: /* GraphQL */ `
     directive @first on OBJECT

package/src/input.js

@@ -0,0 +1,62 @@
+const { GraphQLInputObjectType, GraphQLNonNull, GraphQLList } = require('graphql/type');
+const { getGraphqlTypeInfo } = require('./types');
+const findUsageInputs = (document, schema) => {
+  const inputs = [];
+  for (let definition of document.definitions) {
+    if (definition.kind !== 'OperationDefinition') {
+      continue;
+    }
+    for (const variableDefinition of definition.variableDefinitions) {
+      const name = variableDefinition.type.name.value;
+      const input = findInputInSchema(name, schema);
+      if (input) {
+        inputs.push(input);
+        inputs.push(...findInputDependencies(input, schema, inputs));
+      }
+    }
+  }
+  return inputs.map(input => ({
+    name: input.name,
+    fields: getInputFields(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,
+    };
+  });
+};
+
+const unpackInputType = type => {
+  if (type instanceof GraphQLNonNull) {
+    return unpackInputType(type.ofType);
+  }
+  if (type instanceof GraphQLList) {
+    return unpackInputType(type.ofType);
+  }
+  return type;
+};
+
+module.exports = { findUsageInputs, findInputInSchema };

package/src/query.js

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

@@ -0,0 +1,74 @@
+const { print } = require('graphql/index');
+const { getUsedFragments } = require('./query');
+const renderType = ({ name, fields }) => {
+  return `export type ${name} = { ${renderTypeField(fields)} };`;
+};
+const renderTypeField = fields => {
+  return fields
+    .map(({ isList, isNullable, typeName, name, fields, isScalar, union }) => {
+      let tsType = '';
+      if (union && union.length) {
+        tsType += [...union, ''].join(' & ');
+      }
+      if (isScalar) {
+        tsType += getScalarTsType(typeName);
+      } else {
+        if (fields.length) {
+          tsType += `{${renderTypeField(fields)}}`;
+        } else {
+          tsType += typeName;
+        }
+      }
+      return `${name}${isNullable ? '?' : ''}: ${tsType}${isList ? '[]' : ''}`;
+    })
+    .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 }) => {
+  return `(variables: ${variables.name}, config?: AxiosRequestConfig) => client.post<GraphqlResponse<${results.name}>>("", {variables, query: ${name}RawQuery}, config).then(handleResponse)`;
+};
+
+const renderQuery = ({ name, ast, allFragments }) => {
+  const raw = print(ast).replace('@firstOrFail', '').replace('@first', '').replace('@nonNullable', '');
+
+  let fragments = getUsedFragments(raw, allFragments);
+  fragments = [...new Set(fragments)].map(f => print(f.type));
+
+  const gql = fragments.join('\n') + '\n' + raw;
+  return `const ${name}RawQuery = \`${gql}\`;`;
+};
+
+const getScalarTsType = name => `Scalar["${name}"]`;
+
+const renderEnum = e => {
+  let str = `export enum ${e.name} {`;
+  for (let { name, value } of e.values) {
+    str += `${name} = "${value}",`;
+  }
+  str += `};`;
+  return str;
+};
+const renderScalars = (scalars, map = {}) => {
+  map = {
+    String: 'string',
+    Boolean: 'boolean',
+    Int: 'number',
+    Float: 'number',
+    ...map,
+  };
+  return `export type Scalar = {${scalars
+    .map(({ name }) => {
+      const type = map[name] || 'string';
+      return `${name}: ${type}`;
+    })
+    .join(',')}};`;
+};
+module.exports = { renderType, renderQuery, renderSdk, renderScalars, renderEnum };

package/src/results.js

@@ -0,0 +1,34 @@
+const { getGraphqlTypeInfo } = require('./types');
+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 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);
+  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,
+    fields,
+    union,
+  };
+};
+
+module.exports = { getResultsFields };

package/src/scalar.js

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

package/src/types.js

@@ -0,0 +1,15 @@
+const { GraphQLList, GraphQLNonNull, GraphQLScalarType } = require('graphql/type');
+const getGraphqlTypeInfo = (type, isList = false, isNullable = true) => {
+  if (type instanceof GraphQLList) {
+    isList = true;
+    return getGraphqlTypeInfo(type.ofType, isList, isNullable);
+  }
+  if (type instanceof GraphQLNonNull) {
+    isNullable = false;
+    return getGraphqlTypeInfo(type.ofType, isList, isNullable);
+  }
+  const isScalar = type instanceof GraphQLScalarType;
+  return { type, isList, isNullable, typeName: type.name, isScalar };
+};
+
+module.exports = { getGraphqlTypeInfo };

package/src/variables.js

@@ -0,0 +1,24 @@
+const { findInputInSchema } = require('./input');
+const getVariablesFields = (definition, schema) => {
+  return definition.variableDefinitions.map(variable => ({
+    name: variable.variable.name.value,
+    ...getVariableType(variable.type, schema),
+    fields: [],
+  }));
+};
+
+const getVariableType = (type, schema, isList = false, isNullable = true) => {
+  if (type.kind === 'ListType') {
+    isList = true;
+    return getVariableType(type.type, schema, isList, isNullable);
+  }
+  if (type.kind === 'NonNullType') {
+    isNullable = false;
+    return getVariableType(type.type, schema, isList, isNullable);
+  }
+  const typeName = type.name.value;
+  const isScalar = !findInputInSchema(typeName, schema);
+  return { type: type.type, isList, isNullable, typeName, isScalar };
+};
+
+module.exports = { getVariablesFields };