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

package/lib/types.js

@@ -0,0 +1,81 @@
+"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);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignDirectivesToType = exports.getGraphqlTypeInfo = void 0;
+var type_1 = require("graphql/type");
+var getGraphqlTypeInfo = function (type, isList, isNullable) {
+    if (isList === void 0) { isList = false; }
+    if (isNullable === void 0) { isNullable = true; }
+    if (type instanceof type_1.GraphQLList) {
+        isList = true;
+        return (0, exports.getGraphqlTypeInfo)(type.ofType, isList, isNullable);
+    }
+    if (type instanceof type_1.GraphQLNonNull) {
+        isNullable = false;
+        return (0, exports.getGraphqlTypeInfo)(type.ofType, isList, isNullable);
+    }
+    var isScalar = type instanceof type_1.GraphQLScalarType;
+    return { type: type, isList: isList, isNullable: isNullable, typeName: type.name, isScalar: isScalar, gqlType: getGraphqlType(type) };
+};
+exports.getGraphqlTypeInfo = getGraphqlTypeInfo;
+var getGraphqlType = function (type) {
+    if (type instanceof type_1.GraphQLEnumType) {
+        return 'enum';
+    }
+    if (type instanceof type_1.GraphQLInputObjectType) {
+        return 'input';
+    }
+};
+var assignDirectivesToType = function (typeInfo, directives) {
+    var e_1, _a;
+    var newType = __assign({}, typeInfo);
+    try {
+        for (var directives_1 = __values(directives), directives_1_1 = directives_1.next(); !directives_1_1.done; directives_1_1 = directives_1.next()) {
+            var directive = directives_1_1.value;
+            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;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (directives_1_1 && !directives_1_1.done && (_a = directives_1.return)) _a.call(directives_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return newType;
+};
+exports.assignDirectivesToType = assignDirectivesToType;
+//# sourceMappingURL=types.js.map

package/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qCAAuH;AAKhH,IAAM,kBAAkB,GAAG,UAChC,IAAiB,EACjB,MAAc,EACd,UAAiB;IADjB,uBAAA,EAAA,cAAc;IACd,2BAAA,EAAA,iBAAiB;IAEjB,IAAI,IAAI,YAAY,kBAAW,EAAE;QAC/B,MAAM,GAAG,IAAI,CAAC;QACd,OAAO,IAAA,0BAAkB,EAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;KAC5D;IACD,IAAI,IAAI,YAAY,qBAAc,EAAE;QAClC,UAAU,GAAG,KAAK,CAAC;QACnB,OAAO,IAAA,0BAAkB,EAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;KAC5D;IACD,IAAM,QAAQ,GAAG,IAAI,YAAY,wBAAiB,CAAC;IACnD,OAAO,EAAE,IAAI,MAAA,EAAE,MAAM,QAAA,EAAE,UAAU,YAAA,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,EAAE,QAAQ,UAAA,EAAE,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;AACpG,CAAC,CAAC;AAfW,QAAA,kBAAkB,sBAe7B;AAEF,IAAM,cAAc,GAAG,UAAC,IAA0C;IAChE,IAAI,IAAI,YAAY,sBAAe,EAAE;QACnC,OAAO,MAAM,CAAC;KACf;IACD,IAAI,IAAI,YAAY,6BAAsB,EAAE;QAC1C,OAAO,OAAO,CAAC;KAChB;AACH,CAAC,CAAC;AACK,IAAM,sBAAsB,GAAG,UACpC,QAA6E,EAC7E,UAAoC;;IAEpC,IAAM,OAAO,gBAAQ,QAAQ,CAAE,CAAC;;QAChC,KAAsB,IAAA,eAAA,SAAA,UAAU,CAAA,sCAAA,8DAAE;YAA7B,IAAI,SAAS,uBAAA;YAChB,QAAQ,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE;gBAC5B,KAAK,aAAa;oBAChB,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC;oBACvB,OAAO,CAAC,UAAU,GAAG,KAAK,CAAC;oBAC3B,MAAM;gBACR,KAAK,OAAO;oBACV,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC;oBACvB,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;oBAC1B,MAAM;gBACR,KAAK,aAAa;oBAChB,OAAO,CAAC,UAAU,GAAG,KAAK,CAAC;oBAC3B,MAAM;aACT;SACF;;;;;;;;;IACD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AArBW,QAAA,sBAAsB,0BAqBjC"}

package/lib/utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalize = void 0;
+var capitalize = function (str) { return str.charAt(0).toUpperCase() + str.slice(1); };
+exports.capitalize = capitalize;
+//# sourceMappingURL=utils.js.map

package/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":";;;AAAO,IAAM,UAAU,GAAG,UAAC,GAAW,IAAK,OAAA,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAA1C,CAA0C,CAAC;AAAzE,QAAA,UAAU,cAA+D"}

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,15 +1,16 @@
 {
   "name": "@devticon-os/graphql-codegen-axios",
-  "version": "0.3.0-test",
+  "version": "0.3.1",
   "license": "MIT",
-  "main": "src/index.ts",
+  "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.ts",

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: any = data;
+  while (p.length) {
+    const k = p.shift();
+    const f = d[k!];
+    if (Array.isArray(f)) {
+      for (let i of f) {
+        required(p.join('.'))(i);
+      }
+    } 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: any) {
+        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/_types.ts

@@ -1,60 +0,0 @@
-import { DocumentNode, OperationDefinitionNode } from 'graphql/language/ast';
-import { GraphQLSchema } from 'graphql/type';
-
-export type TsType = {
-  fields: TsTypeField[];
-  unions?: string[];
-};
-
-export type NamedTsType = TsType & {
-  name: string;
-};
-export type TsTypeFieldBase = {
-  name: string;
-  isList: boolean;
-  isNullable: boolean;
-};
-export type TsTypeFieldInLine = TsTypeFieldBase & { kind: 'inLine'; type: string };
-export type TsTypeFieldObject = TsTypeFieldBase & { kind: 'object' } & TsType;
-export type TsTypeField = TsTypeFieldInLine | TsTypeFieldObject;
-export type Query = {
-  name: string;
-  ast: OperationDefinitionNode;
-  allFragments: TsType[];
-};
-export type Config = {
-  autoSingleResult?: boolean;
-  prettier?: boolean;
-  emitDirectives?: string | boolean;
-  emitSchema?: string | boolean;
-
-  suffix?: {
-    fragment?: string;
-    input?: string;
-    enum?: string;
-  };
-  scalars?: Record<string, string>;
-};
-export type CodegenDocuments = { document: DocumentNode }[];
-export type CodegenPlugin = {
-  plugin: (schema: GraphQLSchema, documents: CodegenDocuments, config: Config) => string | Promise<string>;
-  addToSchema?: string;
-};
-
-export type Operation = {
-  name: string;
-  definition: OperationDefinitionNode;
-  singleResultKey?: string;
-  variables?: NamedTsType;
-  results: NamedTsType;
-  fragments: string[];
-  directives: Directive[];
-};
-
-export type Directive = {
-  name: string;
-  path: string;
-  args: Record<string, string>;
-};
-
-export type FieldsMap = Record<string, TsTypeFieldBase & { fields: FieldsMap }>;

package/src/enums.ts

@@ -1,50 +0,0 @@
-import {
-  assertEnumType,
-  assertObjectType,
-  GraphQLEnumType,
-  GraphQLInputObjectType,
-  GraphQLSchema,
-  isEnumType,
-} from 'graphql/type';
-import { getNamedType } from 'graphql/type/definition';
-import { FragmentDefinitionNode } from 'graphql/language/ast';
-import { Kind } from 'graphql/language';
-import { Operation } from './_types';
-
-export const findUsageEnums = (
-  inputs: GraphQLInputObjectType[],
-  fragments: FragmentDefinitionNode[],
-  operations: Operation[],
-  schema: GraphQLSchema,
-): GraphQLEnumType[] => {
-  const enums = new Set<GraphQLEnumType>();
-  for (let input of inputs) {
-    for (let field of Object.values(input.getFields())) {
-      if (isEnumType(getNamedType(field.type))) {
-        enums.add(assertEnumType(getNamedType(field.type)));
-      }
-    }
-  }
-  for (let fragment of fragments) {
-    const parent = assertObjectType(schema.getType(fragment.typeCondition.name.value));
-    for (let selection of fragment.selectionSet.selections) {
-      if (selection.kind === Kind.FIELD) {
-        const parentField = parent.getFields()[selection.name.value];
-        if (isEnumType(getNamedType(parentField.type))) {
-          enums.add(assertEnumType(getNamedType(parentField.type)));
-        }
-      }
-    }
-  }
-  for (let operation of operations) {
-    for (let field of operation.variables?.fields || []) {
-      if (field.kind === 'inLine') {
-        const type = schema.getType(field.type);
-        if (isEnumType(getNamedType(type))) {
-          enums.add(assertEnumType(getNamedType(type)));
-        }
-      }
-    }
-  }
-  return [...enums];
-};

package/src/fragments.ts

@@ -1,15 +0,0 @@
-import { FragmentDefinitionNode } from 'graphql/language/ast';
-import { CodegenDocuments } from './_types';
-import { Kind } from 'graphql/language';
-
-export const findUsageFragments = (documents: CodegenDocuments) => {
-  const fragments: FragmentDefinitionNode[] = [];
-  for (let { document } of documents) {
-    for (const definition of document.definitions) {
-      if (definition.kind === Kind.FRAGMENT_DEFINITION) {
-        fragments.push(definition);
-      }
-    }
-  }
-  return fragments;
-};

package/src/graphql.ts

@@ -1,101 +0,0 @@
-import { SelectionNode, TypeNode } from 'graphql/language/ast';
-import { Config, TsType } from './_types';
-import { getNamedType, GraphQLType } from 'graphql/type/definition';
-import {
-  assertObjectType,
-  getNullableType,
-  GraphQLList,
-  GraphQLNonNull,
-  GraphQLObjectType,
-  GraphQLScalarType,
-  GraphQLSchema,
-  isListType,
-  isNonNullType,
-  isNullableType,
-} from 'graphql/type';
-import { Kind } from 'graphql/language';
-
-export const selectionSetToTsType = (
-  parent: GraphQLObjectType,
-  selections: SelectionNode[] | readonly SelectionNode[],
-  config: Config,
-): TsType => {
-  const type: TsType = {
-    fields: [],
-    unions: [],
-  };
-  for (let selection of selections) {
-    if (selection.kind === Kind.FRAGMENT_SPREAD) {
-      type.unions.push(selection.name.value);
-    }
-
-    if (selection.kind === Kind.FIELD) {
-      const parentField = parent.getFields()[selection.name.value];
-      if (selection.selectionSet && selection.selectionSet.selections.length) {
-        const nestedParent = assertObjectType(getNamedType(parentField.type));
-        type.fields.push({
-          kind: 'object',
-          name: selection.alias?.value || selection.name.value,
-          ...selectionSetToTsType(nestedParent, selection.selectionSet.selections, config),
-          ...getGraphqlTypeWrappers(parentField.type),
-        });
-      } else {
-        type.fields.push({
-          kind: 'inLine',
-          name: selection.alias?.value || selection.name.value,
-          type: graphqlTypeToTypescript(parentField.type, config),
-          ...getGraphqlTypeWrappers(parentField.type),
-        });
-      }
-    }
-  }
-  return type;
-};
-
-export const getGraphqlTypeWrappers = (type: GraphQLType) => {
-  return {
-    isList: isListType(isNonNullType(type) ? getNullableType(type) : type),
-    isNullable: isNullableType(type),
-  };
-};
-
-export const graphqlTypeToTypescript = (type: GraphQLType, config: Config) => {
-  const namedType = getNamedType(type);
-
-  if (namedType instanceof GraphQLScalarType) {
-    return `Scalar["${namedType.name}"]`;
-  }
-
-  switch (namedType.astNode.kind) {
-    case Kind.ENUM_TYPE_DEFINITION:
-      return namedType.name + (config?.suffix?.enum || '');
-    case Kind.INPUT_OBJECT_TYPE_DEFINITION:
-      return namedType.name + (config?.suffix?.input || '');
-    default:
-      throw new Error(`unsupported kind: ${namedType.astNode.kind}`);
-  }
-};
-
-const typeNodeToGraphqlType = (
-  type: TypeNode,
-  schema: GraphQLSchema,
-  isNullable = true,
-  isList = false,
-): GraphQLType => {
-  if (type.kind === Kind.NON_NULL_TYPE) {
-    return typeNodeToGraphqlType(type.type, schema, false, isList);
-  }
-  if (type.kind === Kind.LIST_TYPE) {
-    return typeNodeToGraphqlType(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;
-};

package/src/index.ts

@@ -1,70 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { findUsageInputs } from './input';
-import { CodegenPlugin, Config } from './_types';
-import {
-  printCreateSdkFunction,
-  printEnum,
-  printFragmentGql,
-  printFragmentType,
-  printHelpers,
-  printInput,
-  printOperationTypes,
-  printScalars,
-} from './print';
-import { findUsageEnums } from './enums';
-import { findUsageFragments } from './fragments';
-import { findUsageOperation, pluginDirectives } from './operation';
-import { findScalars } from './scalar';
-import { runPrettierIfExists } from './prettier';
-import { printSchema } from 'graphql/utilities';
-
-const configDefaults: Partial<Config> = {
-  autoSingleResult: true,
-  prettier: true,
-};
-const directives = pluginDirectives.map(d => `directive @${d} on FIELD`).join('\n');
-const plugin: CodegenPlugin = {
-  plugin(schema, documents, config) {
-    try {
-      config = {
-        ...configDefaults,
-        ...config,
-      };
-      if (config.emitDirectives) {
-        const directivesPath = typeof config.emitDirectives === 'string' ? config.emitDirectives : 'directives.graphql';
-        fs.writeFileSync(path.join(directivesPath), directives);
-      }
-      if (config.emitSchema) {
-        const schemaPath = typeof config.emitSchema === 'string' ? config.emitSchema : 'schema.graphql';
-        fs.writeFileSync(path.join(schemaPath), printSchema(schema));
-      }
-
-      const imports = findUsageInputs(documents, schema);
-      const fragments = findUsageFragments(documents);
-      const operations = findUsageOperation(documents, schema, config);
-      const enums = findUsageEnums(imports, fragments, operations, schema);
-      const scalars = findScalars(schema);
-
-      return runPrettierIfExists(
-        config,
-        [
-          printHelpers(),
-          printScalars(scalars, config),
-          ...enums.map(e => printEnum(e, config)),
-          ...imports.map(i => printInput(i, config)),
-          ...fragments.map(f => printFragmentType(f, schema, config)),
-          ...fragments.map(f => printFragmentGql(f)),
-          ...operations.map(o => printOperationTypes(o, config)),
-          printCreateSdkFunction(operations, config),
-        ].join('\n'),
-      );
-    } catch (e) {
-      console.log(e);
-      process.exit(1);
-    }
-  },
-  addToSchema: directives,
-};
-
-module.exports = plugin;

package/src/input.ts

@@ -1,65 +0,0 @@
-import { GraphQLInputObjectType, GraphQLList, GraphQLNonNull, GraphQLSchema } from 'graphql/type';
-import { getNamedType, GraphQLEnumType, GraphQLInputType, GraphQLScalarType } from 'graphql/type/definition';
-import { CodegenDocuments, TsType } from './_types';
-import { NamedTypeNode, TypeNode } from 'graphql/language/ast';
-import { Kind } from 'graphql/language';
-
-export const findUsageInputs = (documents: CodegenDocuments, schema: GraphQLSchema) => {
-  const inputs = new Set<GraphQLInputObjectType>();
-  for (let { document } of documents) {
-    for (let definition of document.definitions) {
-      if (definition.kind === Kind.OPERATION_DEFINITION) {
-        for (const variableDefinition of definition.variableDefinitions) {
-          const type = unpackVariableType(variableDefinition.type);
-          const name = type.name.value;
-          const input = findInputInSchema(name, schema);
-          if (input) {
-            inputs.add(input);
-            findDeepInputs(input, inputs);
-          }
-        }
-      }
-    }
-  }
-
-  return [...inputs];
-};
-
-const findDeepInputs = (parent: GraphQLInputObjectType, imports = new Set<GraphQLInputObjectType>()) => {
-  for (let field of Object.values(parent.getFields())) {
-    const fieldType = getNamedType(field.type);
-    if (fieldType instanceof GraphQLInputObjectType) {
-      imports.add(fieldType);
-      findDeepInputs(fieldType, imports);
-    }
-  }
-  return imports;
-};
-
-export const findInputInSchema = (name: string, schema: GraphQLSchema) => {
-  const type = schema.getType(name);
-  if (type instanceof GraphQLInputObjectType) {
-    return type;
-  }
-};
-
-const unpackInputType = (type: GraphQLInputType): GraphQLScalarType | GraphQLEnumType | GraphQLInputObjectType => {
-  if (type instanceof GraphQLNonNull) {
-    return unpackInputType(type.ofType);
-  }
-  if (type instanceof GraphQLList) {
-    return unpackInputType(type.ofType);
-  }
-  return type;
-};
-
-const unpackVariableType = (type: TypeNode): NamedTypeNode => {
-  if (type.kind === Kind.NON_NULL_TYPE) {
-    return unpackVariableType(type.type);
-  }
-  if (type.kind === Kind.LIST_TYPE) {
-    return unpackVariableType(type.type);
-  }
-
-  return type;
-};