@graphitation/supermassive 1.0.0 → 1.1.1

package/lib/codegen/index.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var codegen_exports = {};
+__export(codegen_exports, {
+  generateTS: () => generateTS
+});
+module.exports = __toCommonJS(codegen_exports);
+var import_context = require("./context");
+var import_resolvers = require("./resolvers");
+var import_models = require("./models");
+function generateTS(document, contextImport, contextName) {
+  try {
+    let context = (0, import_context.extractContext)({
+      context: {
+        name: contextName,
+        from: contextImport || null
+      }
+    }, document);
+    let models = (0, import_models.generateModels)(context, document);
+    let resolvers = (0, import_resolvers.generateResolvers)(context, document);
+    return { models, resolvers };
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+}

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;AAO7C,wBAAgB,cAAc,CAC5B,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,YAAY,GACrB,EAAE,CAAC,UAAU,CAEf"}

package/lib/codegen/models.js

@@ -0,0 +1,159 @@
+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()];
+        const interfaces = node.interfaces || [];
+        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.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) {
+        return context.getScalarDeclaration(node.name) || null;
+      }
+    },
+    NamedType: {
+      leave(node, _a, _p, path) {
+        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).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,142 @@
+// src/codegen/models.ts
+import ts, { factory } from "typescript";
+import { visit } from "./typedVisitor.mjs";
+import {
+  createNullableType,
+  createNonNullableType,
+  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()];
+        const interfaces = node.interfaces || [];
+        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.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) {
+        return context.getScalarDeclaration(node.name) || null;
+      }
+    },
+    NamedType: {
+      leave(node, _a, _p, path) {
+        const isImplementedInterface = path[path.length - 2] === "interfaces";
+        if (isImplementedInterface) {
+          return factory.createIdentifier(addModelSuffix(node.name));
+        }
+        return createNullableType(context.getModelType(node.name).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;AAS7C,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,YAAY,GACrB,EAAE,CAAC,UAAU,CAEf"}

package/lib/codegen/resolvers.js

@@ -0,0 +1,155 @@
+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).toTypeReference();
+        }
+        const resolverParametersDefinitions = {
+          parent: {
+            name: "model",
+            type: modelIdentifier
+          },
+          args: { name: "args", type: node.arguments || [] },
+          context: {
+            name: "context",
+            type: context.getContextType().toTypeReference()
+          },
+          resolveInfo: {
+            name: "info",
+            type: context.getResolveInfoType().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, (0, import_utilities.getResolverParameters)(resolverParametersDefinitions), (0, import_utilities.getResolverReturnType)(node.type, parentName, resolverParametersDefinitions)));
+      }
+    },
+    NamedType: {
+      leave(node, _a, _p, _path) {
+        return (0, import_utilities.createNullableType)(context.getModelType(node.name, 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,143 @@
+// src/codegen/resolvers.ts
+import ts, { factory } from "typescript";
+import {
+  isTypeDefinitionNode,
+  isTypeExtensionNode,
+  Kind
+} from "graphql";
+import { visit } from "./typedVisitor.mjs";
+import {
+  createNullableType,
+  createNonNullableType,
+  getResolverReturnType,
+  getResolverParameters
+} 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).toTypeReference();
+        }
+        const resolverParametersDefinitions = {
+          parent: {
+            name: "model",
+            type: modelIdentifier
+          },
+          args: { name: "args", type: node.arguments || [] },
+          context: {
+            name: "context",
+            type: context.getContextType().toTypeReference()
+          },
+          resolveInfo: {
+            name: "info",
+            type: context.getResolveInfoType().toTypeReference()
+          }
+        };
+        return factory.createTypeAliasDeclaration(void 0, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(node.name), void 0, factory.createFunctionTypeNode(void 0, getResolverParameters(resolverParametersDefinitions), getResolverReturnType(node.type, parentName, resolverParametersDefinitions)));
+      }
+    },
+    NamedType: {
+      leave(node, _a, _p, _path) {
+        return createNullableType(context.getModelType(node.name, 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
+};