@graphitation/supermassive 0.8.5 → 1.1.0

package/lib/codegen/index.mjs

@@ -0,0 +1,23 @@
+// src/codegen/index.ts
+import { extractContext } from "./context.mjs";
+import { generateResolvers } from "./resolvers.mjs";
+import { generateModels } from "./models.mjs";
+function generateTS(document, contextImport, contextName) {
+  try {
+    let context = extractContext({
+      context: {
+        name: contextName,
+        from: contextImport || null
+      }
+    }, document);
+    let models = generateModels(context, document);
+    let resolvers = generateResolvers(context, document);
+    return { models, resolvers };
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+}
+export {
+  generateTS
+};

package/lib/codegen/models.d.ts

@@ -0,0 +1,5 @@
+import ts from "typescript";
+import { DocumentNode } from "graphql";
+import { TsCodegenContext } from "./context";
+export declare function generateModels(context: TsCodegenContext, document: DocumentNode): ts.SourceFile;
+//# sourceMappingURL=models.d.ts.map

package/lib/codegen/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../src/codegen/models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAQ7C,wBAAgB,cAAc,CAC5B,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,YAAY,GACrB,EAAE,CAAC,UAAU,CAEf"}

package/lib/codegen/models.js

@@ -0,0 +1,157 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var models_exports = {};
+__export(models_exports, {
+  generateModels: () => generateModels
+});
+module.exports = __toCommonJS(models_exports);
+var import_typescript = __toESM(require("typescript"));
+var import_typedVisitor = require("./typedVisitor");
+var import_utilities = require("./utilities");
+function generateModels(context, document) {
+  return (0, import_typedVisitor.visit)(document, createModelsReducer(context));
+}
+function createModelsReducer(context) {
+  return {
+    Document: {
+      leave(node) {
+        const imports = context.getAllModelImportDeclarations();
+        const statements = node.definitions;
+        return import_typescript.factory.createSourceFile(imports.concat(context.getDefaultTypes(), statements.flat()), import_typescript.factory.createToken(import_typescript.default.SyntaxKind.EndOfFileToken), import_typescript.default.NodeFlags.None);
+      }
+    },
+    SchemaExtension: {
+      leave() {
+        return null;
+      }
+    },
+    ObjectTypeExtension: {
+      leave() {
+        return null;
+      }
+    },
+    FieldDefinition: {
+      leave(node) {
+        return import_typescript.factory.createPropertySignature(void 0, import_typescript.factory.createIdentifier(node.name), void 0, node.type);
+      }
+    },
+    ObjectTypeDefinition: {
+      leave(node) {
+        const model = context.getDefinedModelType(node.name);
+        const interfaces = node.interfaces || [];
+        const extendTypes = [context.getBaseModelType()];
+        if (model) {
+          extendTypes.push(model);
+        }
+        if (["Query", "Mutation", "Subscription"].includes(node.name)) {
+          return null;
+        }
+        return import_typescript.factory.createInterfaceDeclaration(void 0, [import_typescript.factory.createModifier(import_typescript.default.SyntaxKind.ExportKeyword)], import_typescript.factory.createIdentifier((0, import_utilities.addModelSuffix)(node.name)), void 0, [
+          import_typescript.factory.createHeritageClause(import_typescript.default.SyntaxKind.ExtendsKeyword, [
+            ...extendTypes.map((type) => import_typescript.factory.createExpressionWithTypeArguments(type.toExpression(), void 0)),
+            ...interfaces.map((interfaceExpression) => import_typescript.factory.createExpressionWithTypeArguments(interfaceExpression, void 0))
+          ])
+        ], [
+          import_typescript.factory.createPropertySignature(void 0, "__typename", void 0, import_typescript.factory.createLiteralTypeNode(import_typescript.factory.createStringLiteral(node.name))),
+          ...!model && node.fields || []
+        ]);
+      }
+    },
+    InputObjectTypeDefinition: {
+      leave(node) {
+        return null;
+      }
+    },
+    InputValueDefinition: {
+      leave(node) {
+        return null;
+      }
+    },
+    EnumTypeDefinition: {
+      leave(node) {
+        return import_typescript.factory.createEnumDeclaration(void 0, [import_typescript.factory.createModifier(import_typescript.default.SyntaxKind.ExportKeyword)], (0, import_utilities.addModelSuffix)(node.name), node.values || []);
+      }
+    },
+    EnumValueDefinition: {
+      leave(node) {
+        return import_typescript.factory.createEnumMember(node.name, import_typescript.factory.createStringLiteral(node.name));
+      }
+    },
+    InterfaceTypeDefinition: {
+      leave(node) {
+        const extendTypes = [context.getBaseModelType()];
+        return import_typescript.factory.createInterfaceDeclaration(void 0, [import_typescript.factory.createModifier(import_typescript.default.SyntaxKind.ExportKeyword)], import_typescript.factory.createIdentifier((0, import_utilities.addModelSuffix)(node.name)), void 0, [
+          import_typescript.factory.createHeritageClause(import_typescript.default.SyntaxKind.ExtendsKeyword, extendTypes.map((type) => import_typescript.factory.createExpressionWithTypeArguments(type.toExpression(), void 0)))
+        ], [
+          import_typescript.factory.createPropertySignature(void 0, "__typename", void 0, import_typescript.factory.createKeywordTypeNode(import_typescript.default.SyntaxKind.StringKeyword))
+        ]);
+      }
+    },
+    UnionTypeDefinition: {
+      leave({ name, types }) {
+        return import_typescript.factory.createTypeAliasDeclaration(void 0, [import_typescript.factory.createModifier(import_typescript.default.SyntaxKind.ExportKeyword)], import_typescript.factory.createIdentifier((0, import_utilities.addModelSuffix)(name)), void 0, import_typescript.factory.createUnionTypeNode((types == null ? void 0 : types.map((type) => {
+          return (0, import_utilities.createNonNullableType)(type);
+        })) || []));
+      }
+    },
+    ScalarTypeDefinition: {
+      leave(node) {
+        context.addScalar(node.name);
+        return null;
+      }
+    },
+    NamedType: {
+      leave(node, _a, _p, path, ancestors) {
+        const isAncestorInput = (0, import_utilities.isDirectAncestorInput)(ancestors);
+        const isImplementedInterface = path[path.length - 2] === "interfaces";
+        if (isImplementedInterface) {
+          return import_typescript.factory.createIdentifier((0, import_utilities.addModelSuffix)(node.name));
+        }
+        return (0, import_utilities.createNullableType)(context.getModelType(node.name, !isAncestorInput).toTypeReference());
+      }
+    },
+    ListType: {
+      leave({ type }) {
+        return (0, import_utilities.createNullableType)(import_typescript.factory.createArrayTypeNode(type));
+      }
+    },
+    NonNullType: {
+      leave({ type }) {
+        return (0, import_utilities.createNonNullableType)(type);
+      }
+    },
+    Name: {
+      leave(node) {
+        return node.value;
+      }
+    },
+    DirectiveDefinition: {
+      leave() {
+        return null;
+      }
+    },
+    Directive: {
+      leave() {
+        return null;
+      }
+    }
+  };
+}

package/lib/codegen/models.mjs

@@ -0,0 +1,141 @@
+// src/codegen/models.ts
+import ts, { factory } from "typescript";
+import { visit } from "./typedVisitor.mjs";
+import {
+  createNullableType,
+  createNonNullableType,
+  isDirectAncestorInput,
+  addModelSuffix
+} from "./utilities.mjs";
+function generateModels(context, document) {
+  return visit(document, createModelsReducer(context));
+}
+function createModelsReducer(context) {
+  return {
+    Document: {
+      leave(node) {
+        const imports = context.getAllModelImportDeclarations();
+        const statements = node.definitions;
+        return factory.createSourceFile(imports.concat(context.getDefaultTypes(), statements.flat()), factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
+      }
+    },
+    SchemaExtension: {
+      leave() {
+        return null;
+      }
+    },
+    ObjectTypeExtension: {
+      leave() {
+        return null;
+      }
+    },
+    FieldDefinition: {
+      leave(node) {
+        return factory.createPropertySignature(void 0, factory.createIdentifier(node.name), void 0, node.type);
+      }
+    },
+    ObjectTypeDefinition: {
+      leave(node) {
+        const model = context.getDefinedModelType(node.name);
+        const interfaces = node.interfaces || [];
+        const extendTypes = [context.getBaseModelType()];
+        if (model) {
+          extendTypes.push(model);
+        }
+        if (["Query", "Mutation", "Subscription"].includes(node.name)) {
+          return null;
+        }
+        return factory.createInterfaceDeclaration(void 0, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(addModelSuffix(node.name)), void 0, [
+          factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
+            ...extendTypes.map((type) => factory.createExpressionWithTypeArguments(type.toExpression(), void 0)),
+            ...interfaces.map((interfaceExpression) => factory.createExpressionWithTypeArguments(interfaceExpression, void 0))
+          ])
+        ], [
+          factory.createPropertySignature(void 0, "__typename", void 0, factory.createLiteralTypeNode(factory.createStringLiteral(node.name))),
+          ...!model && node.fields || []
+        ]);
+      }
+    },
+    InputObjectTypeDefinition: {
+      leave(node) {
+        return null;
+      }
+    },
+    InputValueDefinition: {
+      leave(node) {
+        return null;
+      }
+    },
+    EnumTypeDefinition: {
+      leave(node) {
+        return factory.createEnumDeclaration(void 0, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], addModelSuffix(node.name), node.values || []);
+      }
+    },
+    EnumValueDefinition: {
+      leave(node) {
+        return factory.createEnumMember(node.name, factory.createStringLiteral(node.name));
+      }
+    },
+    InterfaceTypeDefinition: {
+      leave(node) {
+        const extendTypes = [context.getBaseModelType()];
+        return factory.createInterfaceDeclaration(void 0, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(addModelSuffix(node.name)), void 0, [
+          factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, extendTypes.map((type) => factory.createExpressionWithTypeArguments(type.toExpression(), void 0)))
+        ], [
+          factory.createPropertySignature(void 0, "__typename", void 0, factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))
+        ]);
+      }
+    },
+    UnionTypeDefinition: {
+      leave({ name, types }) {
+        return factory.createTypeAliasDeclaration(void 0, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(addModelSuffix(name)), void 0, factory.createUnionTypeNode((types == null ? void 0 : types.map((type) => {
+          return createNonNullableType(type);
+        })) || []));
+      }
+    },
+    ScalarTypeDefinition: {
+      leave(node) {
+        context.addScalar(node.name);
+        return null;
+      }
+    },
+    NamedType: {
+      leave(node, _a, _p, path, ancestors) {
+        const isAncestorInput = isDirectAncestorInput(ancestors);
+        const isImplementedInterface = path[path.length - 2] === "interfaces";
+        if (isImplementedInterface) {
+          return factory.createIdentifier(addModelSuffix(node.name));
+        }
+        return createNullableType(context.getModelType(node.name, !isAncestorInput).toTypeReference());
+      }
+    },
+    ListType: {
+      leave({ type }) {
+        return createNullableType(factory.createArrayTypeNode(type));
+      }
+    },
+    NonNullType: {
+      leave({ type }) {
+        return createNonNullableType(type);
+      }
+    },
+    Name: {
+      leave(node) {
+        return node.value;
+      }
+    },
+    DirectiveDefinition: {
+      leave() {
+        return null;
+      }
+    },
+    Directive: {
+      leave() {
+        return null;
+      }
+    }
+  };
+}
+export {
+  generateModels
+};

package/lib/codegen/resolvers.d.ts

@@ -0,0 +1,5 @@
+import ts from "typescript";
+import { DocumentNode } from "graphql";
+import { TsCodegenContext } from "./context";
+export declare function generateResolvers(context: TsCodegenContext, document: DocumentNode): ts.SourceFile;
+//# sourceMappingURL=resolvers.d.ts.map

package/lib/codegen/resolvers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvers.d.ts","sourceRoot":"","sources":["../../src/codegen/resolvers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,MAAM,YAAY,CAAC;AACzC,OAAO,EACL,YAAY,EAIb,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAO7C,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,YAAY,GACrB,EAAE,CAAC,UAAU,CAEf"}

package/lib/codegen/resolvers.js

@@ -0,0 +1,146 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolvers_exports = {};
+__export(resolvers_exports, {
+  generateResolvers: () => generateResolvers
+});
+module.exports = __toCommonJS(resolvers_exports);
+var import_typescript = __toESM(require("typescript"));
+var import_graphql = require("graphql");
+var import_typedVisitor = require("./typedVisitor");
+var import_utilities = require("./utilities");
+function generateResolvers(context, document) {
+  return (0, import_typedVisitor.visit)(document, createResolversReducer(context));
+}
+function createResolversReducer(context) {
+  return {
+    Document: {
+      leave(node) {
+        const imports = context.getAllResolverImportDeclarations();
+        const statements = node.definitions;
+        return import_typescript.factory.createSourceFile(imports.concat(statements.flat()), import_typescript.factory.createToken(import_typescript.default.SyntaxKind.EndOfFileToken), import_typescript.default.NodeFlags.None);
+      }
+    },
+    SchemaExtension: {
+      leave() {
+        return null;
+      }
+    },
+    ObjectTypeDefinition: {
+      leave(node) {
+        return import_typescript.factory.createModuleDeclaration(void 0, [
+          import_typescript.factory.createModifier(import_typescript.default.SyntaxKind.ExportKeyword),
+          import_typescript.factory.createModifier(import_typescript.default.SyntaxKind.DeclareKeyword)
+        ], import_typescript.factory.createIdentifier(node.name), import_typescript.factory.createModuleBlock(node.fields || []), import_typescript.default.NodeFlags.Namespace);
+      }
+    },
+    ObjectTypeExtension: {
+      leave(node) {
+        return import_typescript.factory.createModuleDeclaration(void 0, [
+          import_typescript.factory.createModifier(import_typescript.default.SyntaxKind.ExportKeyword),
+          import_typescript.factory.createModifier(import_typescript.default.SyntaxKind.DeclareKeyword)
+        ], import_typescript.factory.createIdentifier(node.name), import_typescript.factory.createModuleBlock(node.fields || []), import_typescript.default.NodeFlags.Namespace);
+      }
+    },
+    FieldDefinition: {
+      leave(node, _a, _p, _path, ancestors) {
+        const parentObject = ancestors[ancestors.length - 1];
+        if (!("kind" in parentObject && ((0, import_graphql.isTypeDefinitionNode)(parentObject) || (0, import_graphql.isTypeExtensionNode)(parentObject)))) {
+          throw new Error("Invalid parent for field");
+        }
+        const parentName = parentObject.name.value;
+        let modelIdentifier;
+        if (["Query", "Mutation", "Subscription"].includes(parentName)) {
+          modelIdentifier = import_typescript.factory.createKeywordTypeNode(import_typescript.default.SyntaxKind.UnknownKeyword);
+        } else if (parentObject.kind !== import_graphql.Kind.INTERFACE_TYPE_DEFINITION) {
+          modelIdentifier = context.getModelType(parentName, true, true).toTypeReference();
+        }
+        return import_typescript.factory.createTypeAliasDeclaration(void 0, [import_typescript.factory.createModifier(import_typescript.default.SyntaxKind.ExportKeyword)], import_typescript.factory.createIdentifier(node.name), void 0, import_typescript.factory.createFunctionTypeNode(void 0, [
+          import_typescript.factory.createParameterDeclaration(void 0, void 0, void 0, import_typescript.factory.createIdentifier("model"), void 0, modelIdentifier, void 0),
+          import_typescript.factory.createParameterDeclaration(void 0, void 0, void 0, import_typescript.factory.createIdentifier("args"), void 0, import_typescript.factory.createTypeLiteralNode(node.arguments || []), void 0),
+          import_typescript.factory.createParameterDeclaration(void 0, void 0, void 0, import_typescript.factory.createIdentifier("context"), void 0, context.getContextType().toTypeReference(), void 0),
+          import_typescript.factory.createParameterDeclaration(void 0, void 0, void 0, import_typescript.factory.createIdentifier("info"), void 0, context.getResolveInfoType().toTypeReference(), void 0)
+        ], import_typescript.factory.createTypeReferenceNode(import_typescript.factory.createIdentifier("PromiseOrValue"), [node.type])));
+      }
+    },
+    NamedType: {
+      leave(node, _a, _p, _path, ancestors) {
+        const isAncestorInput = (0, import_utilities.isDirectAncestorInput)(ancestors);
+        return (0, import_utilities.createNullableType)(context.getModelType(node.name, !isAncestorInput, !isAncestorInput, true).toTypeReference());
+      }
+    },
+    ListType: {
+      leave({ type }) {
+        return (0, import_utilities.createNullableType)(import_typescript.factory.createArrayTypeNode(type));
+      }
+    },
+    NonNullType: {
+      leave({ type }) {
+        return (0, import_utilities.createNonNullableType)(type);
+      }
+    },
+    Name: {
+      leave(node) {
+        return node.value;
+      }
+    },
+    Directive: {
+      leave() {
+        return null;
+      }
+    },
+    InputValueDefinition: {
+      leave(node) {
+        return import_typescript.factory.createPropertySignature(void 0, node.name, void 0, node.type);
+      }
+    },
+    InputObjectTypeDefinition: {
+      leave(node) {
+        return import_typescript.factory.createTypeAliasDeclaration(void 0, [import_typescript.factory.createModifier(import_typescript.default.SyntaxKind.ExportKeyword)], node.name, void 0, import_typescript.factory.createTypeLiteralNode(node.fields || []));
+      }
+    },
+    UnionTypeDefinition: {
+      leave() {
+        return null;
+      }
+    },
+    EnumTypeDefinition: {
+      leave() {
+        return null;
+      }
+    },
+    InterfaceTypeDefinition: {
+      leave() {
+        return null;
+      }
+    },
+    DirectiveDefinition: {
+      leave() {
+        return null;
+      }
+    },
+    ScalarTypeDefinition: {
+      leave() {
+        return null;
+      }
+    }
+  };
+}

package/lib/codegen/resolvers.mjs

@@ -0,0 +1,133 @@
+// src/codegen/resolvers.ts
+import ts, { factory } from "typescript";
+import {
+  isTypeDefinitionNode,
+  isTypeExtensionNode,
+  Kind
+} from "graphql";
+import { visit } from "./typedVisitor.mjs";
+import {
+  createNullableType,
+  createNonNullableType,
+  isDirectAncestorInput
+} from "./utilities.mjs";
+function generateResolvers(context, document) {
+  return visit(document, createResolversReducer(context));
+}
+function createResolversReducer(context) {
+  return {
+    Document: {
+      leave(node) {
+        const imports = context.getAllResolverImportDeclarations();
+        const statements = node.definitions;
+        return factory.createSourceFile(imports.concat(statements.flat()), factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
+      }
+    },
+    SchemaExtension: {
+      leave() {
+        return null;
+      }
+    },
+    ObjectTypeDefinition: {
+      leave(node) {
+        return factory.createModuleDeclaration(void 0, [
+          factory.createModifier(ts.SyntaxKind.ExportKeyword),
+          factory.createModifier(ts.SyntaxKind.DeclareKeyword)
+        ], factory.createIdentifier(node.name), factory.createModuleBlock(node.fields || []), ts.NodeFlags.Namespace);
+      }
+    },
+    ObjectTypeExtension: {
+      leave(node) {
+        return factory.createModuleDeclaration(void 0, [
+          factory.createModifier(ts.SyntaxKind.ExportKeyword),
+          factory.createModifier(ts.SyntaxKind.DeclareKeyword)
+        ], factory.createIdentifier(node.name), factory.createModuleBlock(node.fields || []), ts.NodeFlags.Namespace);
+      }
+    },
+    FieldDefinition: {
+      leave(node, _a, _p, _path, ancestors) {
+        const parentObject = ancestors[ancestors.length - 1];
+        if (!("kind" in parentObject && (isTypeDefinitionNode(parentObject) || isTypeExtensionNode(parentObject)))) {
+          throw new Error("Invalid parent for field");
+        }
+        const parentName = parentObject.name.value;
+        let modelIdentifier;
+        if (["Query", "Mutation", "Subscription"].includes(parentName)) {
+          modelIdentifier = factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+        } else if (parentObject.kind !== Kind.INTERFACE_TYPE_DEFINITION) {
+          modelIdentifier = context.getModelType(parentName, true, true).toTypeReference();
+        }
+        return factory.createTypeAliasDeclaration(void 0, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(node.name), void 0, factory.createFunctionTypeNode(void 0, [
+          factory.createParameterDeclaration(void 0, void 0, void 0, factory.createIdentifier("model"), void 0, modelIdentifier, void 0),
+          factory.createParameterDeclaration(void 0, void 0, void 0, factory.createIdentifier("args"), void 0, factory.createTypeLiteralNode(node.arguments || []), void 0),
+          factory.createParameterDeclaration(void 0, void 0, void 0, factory.createIdentifier("context"), void 0, context.getContextType().toTypeReference(), void 0),
+          factory.createParameterDeclaration(void 0, void 0, void 0, factory.createIdentifier("info"), void 0, context.getResolveInfoType().toTypeReference(), void 0)
+        ], factory.createTypeReferenceNode(factory.createIdentifier("PromiseOrValue"), [node.type])));
+      }
+    },
+    NamedType: {
+      leave(node, _a, _p, _path, ancestors) {
+        const isAncestorInput = isDirectAncestorInput(ancestors);
+        return createNullableType(context.getModelType(node.name, !isAncestorInput, !isAncestorInput, true).toTypeReference());
+      }
+    },
+    ListType: {
+      leave({ type }) {
+        return createNullableType(factory.createArrayTypeNode(type));
+      }
+    },
+    NonNullType: {
+      leave({ type }) {
+        return createNonNullableType(type);
+      }
+    },
+    Name: {
+      leave(node) {
+        return node.value;
+      }
+    },
+    Directive: {
+      leave() {
+        return null;
+      }
+    },
+    InputValueDefinition: {
+      leave(node) {
+        return factory.createPropertySignature(void 0, node.name, void 0, node.type);
+      }
+    },
+    InputObjectTypeDefinition: {
+      leave(node) {
+        return factory.createTypeAliasDeclaration(void 0, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], node.name, void 0, factory.createTypeLiteralNode(node.fields || []));
+      }
+    },
+    UnionTypeDefinition: {
+      leave() {
+        return null;
+      }
+    },
+    EnumTypeDefinition: {
+      leave() {
+        return null;
+      }
+    },
+    InterfaceTypeDefinition: {
+      leave() {
+        return null;
+      }
+    },
+    DirectiveDefinition: {
+      leave() {
+        return null;
+      }
+    },
+    ScalarTypeDefinition: {
+      leave() {
+        return null;
+      }
+    }
+  };
+}
+export {
+  generateResolvers
+};

package/lib/codegen/typedVisitor.d.ts

@@ -0,0 +1,57 @@
+import { ASTNode } from "graphql";
+/**
+ * Hack GraphQL Visitor to have better type safety.
+ *
+ * You can provide type that defines how reducer of visitor converts type (becomes return type
+ * of leave) and how are fields converted (becomes fields on the node).
+ */
+export declare type ReducerResultMap<T> = {
+    [NodeT in ASTNode as NodeT["kind"]]?: T | T[] | null;
+};
+export declare type ReducerFieldMap<T> = {
+    [NodeT in ASTNode as NodeT["kind"]]?: {
+        [K in keyof NodeT]?: T | T[] | null;
+    };
+};
+export declare type ASTReducer<T, TR extends ReducerResultMap<T>, TRF extends ReducerFieldMap<T>> = {
+    readonly [NodeT in ASTNode as NodeT["kind"]]?: {
+        readonly enter?: ASTVisitFn<NodeT>;
+        readonly leave: ASTReducerFn<NodeT, TR[NodeT["kind"]], TRF[NodeT["kind"]]>;
+    };
+};
+declare type ASTReducerFn<TReducedNode extends ASTNode, TResult, TReducerMap> = (
+/** The current node being visiting. */
+node: {
+    [K in keyof TReducedNode]: ReducedField<TReducedNode[K], TReducerMap extends undefined ? undefined : K extends keyof TReducerMap ? TReducerMap[K] extends undefined ? undefined : TReducerMap[K] : undefined>;
+}, 
+/** The index or key to this node from the parent node or Array. */
+key: string | number | undefined, 
+/** The parent immediately above this node, which may be an Array. */
+parent: ASTNode | ReadonlyArray<ASTNode> | undefined, 
+/** The key path to get to this node from the root node. */
+path: ReadonlyArray<string | number>, 
+/**
+ * All nodes and Arrays visited before reaching parent of this node.
+ * These correspond to array indices in `path`.
+ * Note: ancestors includes arrays which contain the parent of visited node.
+ */
+ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>>) => TResult;
+declare type ReducedField<T, R> = R extends undefined ? T : T extends null | undefined ? T : T extends ReadonlyArray<any> ? ReadonlyArray<R> : R;
+export declare type ASTVisitFn<TVisitedNode extends ASTNode> = (
+/** The current node being visiting. */
+node: TVisitedNode, 
+/** The index or key to this node from the parent node or Array. */
+key: string | number | undefined, 
+/** The parent immediately above this node, which may be an Array. */
+parent: ASTNode | ReadonlyArray<ASTNode> | undefined, 
+/** The key path to get to this node from the root node. */
+path: ReadonlyArray<string | number>, 
+/**
+ * All nodes and Arrays visited before reaching parent of this node.
+ * These correspond to array indices in `path`.
+ * Note: ancestors includes arrays which contain the parent of visited node.
+ */
+ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>>) => any;
+export declare function visit<T, TR, TTR>(root: ASTNode, visitor: ASTReducer<T, TR, TTR>): T;
+export {};
+//# sourceMappingURL=typedVisitor.d.ts.map