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

package/lib/variables.js

@@ -0,0 +1,44 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVariablesFields = void 0;
+var input_1 = require("./input");
+var enums_1 = require("./enums");
+var language_1 = require("graphql/language");
+var getVariablesFields = function (definition, schema) {
+    return definition.variableDefinitions.map(function (variable) { return (__assign(__assign({ name: variable.variable.name.value, alias: variable.variable.name.value, union: [] }, getVariableType(variable.type, schema)), { fields: [] })); });
+};
+exports.getVariablesFields = getVariablesFields;
+var getVariableType = function (type, schema, isList, isNullable) {
+    if (isList === void 0) { isList = false; }
+    if (isNullable === void 0) { isNullable = true; }
+    if (type.kind === language_1.Kind.LIST_TYPE) {
+        isList = true;
+        return getVariableType(type.type, schema, isList, isNullable);
+    }
+    if (type.kind === language_1.Kind.NON_NULL_TYPE) {
+        isNullable = false;
+        return getVariableType(type.type, schema, isList, isNullable);
+    }
+    var typeName = type.name.value;
+    var isScalar = !(0, input_1.findInputInSchema)(typeName, schema) && !(0, enums_1.findEnumInSchema)(typeName, schema);
+    return {
+        isList: isList,
+        isNullable: isNullable,
+        typeName: typeName,
+        isScalar: isScalar,
+        inLine: !isScalar,
+        gqlType: isScalar ? 'scalar' : 'input',
+    };
+};
+//# sourceMappingURL=variables.js.map

package/lib/variables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variables.js","sourceRoot":"","sources":["../src/variables.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,iCAA4C;AAC5C,iCAA2C;AAG3C,6CAAwC;AAGjC,IAAM,kBAAkB,GAAG,UAAC,UAAmC,EAAE,MAAqB;IAC3F,OAAO,UAAU,CAAC,mBAAmB,CAAC,GAAG,CAAC,UAAA,QAAQ,IAAI,OAAA,qBACpD,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,EAClC,KAAK,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,EACnC,KAAK,EAAE,EAAE,IACN,eAAe,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,KACzC,MAAM,EAAE,EAAE,IACV,EANoD,CAMpD,CAAC,CAAC;AACN,CAAC,CAAC;AARW,QAAA,kBAAkB,sBAQ7B;AAEF,IAAM,eAAe,GAAG,UACtB,IAAc,EACd,MAAqB,EACrB,MAAc,EACd,UAAiB;IADjB,uBAAA,EAAA,cAAc;IACd,2BAAA,EAAA,iBAAiB;IAEjB,IAAI,IAAI,CAAC,IAAI,KAAK,eAAI,CAAC,SAAS,EAAE;QAChC,MAAM,GAAG,IAAI,CAAC;QACd,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;KAC/D;IACD,IAAI,IAAI,CAAC,IAAI,KAAK,eAAI,CAAC,aAAa,EAAE;QACpC,UAAU,GAAG,KAAK,CAAC;QACnB,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;KAC/D;IACD,IAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;IACjC,IAAM,QAAQ,GAAG,CAAC,IAAA,yBAAiB,EAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,IAAA,wBAAgB,EAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC7F,OAAO;QACL,MAAM,QAAA;QACN,UAAU,YAAA;QACV,QAAQ,UAAA;QACR,QAAQ,UAAA;QACR,MAAM,EAAE,CAAC,QAAQ;QACjB,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO;KACvC,CAAC;AACJ,CAAC,CAAC"}

package/package.json

@@ -1,24 +1,32 @@
 {
   "name": "@devticon-os/graphql-codegen-axios",
-  "version": "0.2.18",
+  "version": "0.3.1-test",
   "license": "MIT",
-  "main": "src/index.js",
+  "main": "lib/index.js",
   "repository": "https://github.com/devticon/graphql-codegen-axios",
   "author": {
     "name": "krs",
     "email": "k.kamasa@gmail.com"
   },
   "files": [
-    "src"
+    "lib",
+    "templates"
   ],
   "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/templates/helpers.ts

@@ -0,0 +1,95 @@
+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) => (data: any) => {
+  data[key] = (data as any)[key][0];
+  if (!data[key]) {
+    throw {
+      message: `Empty list for ${key} `,
+      code: 'EMPTY_LIST',
+    };
+  }
+  return data;
+};
+
+const required = (path: string) => (data: any) => {
+  const p = path.split('.');
+  let d = data;
+  while (p.length) {
+    const k = p.shift();
+    const f = d[k];
+    if (Array.isArray(f)) {
+      for (let i of f) {
+        required(p.join('.'))(f);
+      }
+    } else if (p.length > 0) {
+      d = f;
+    } else if (!f) {
+      throw {
+        message: `missing required field: ${path}`,
+        code: 'MISSING_FIELD',
+      };
+    }
+  }
+  return data;
+};
+
+const execute = (
+  client: AxiosInstance,
+  body: GraphqlRequestParams,
+  functions: ((data: any) => any)[],
+  config?: AxiosRequestConfig,
+) =>
+  client.post('', body, config).then(({ data }: AxiosResponse<GraphqlResponse<any>>) => {
+    const errors = data.errors;
+    if (errors && errors.length > 0) {
+      throw new GraphqlError('Request failed', errors);
+    }
+    let d = data.data;
+    for (let func of functions) {
+      try {
+        d = func(d);
+      } catch (e) {
+        if (e.code) {
+          throw new QueryError(e.message, e.code, body);
+        } else {
+          throw e;
+        }
+      }
+    }
+    return d;
+  });
+
+export const singleResult = (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 QueryError extends Error {
+  query: string;
+  variables: any;
+  constructor(message: string, code: string, params: GraphqlRequestParams) {
+    super(message);
+    this.query = params.query;
+    this.variables = params.variables;
+  }
+}

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 };