@graphitation/supermassive 1.0.0 → 1.1.1

package/lib/codegen/context/index.js

@@ -0,0 +1,253 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+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 context_exports = {};
+__export(context_exports, {
+  BUILT_IN_SCALARS: () => BUILT_IN_SCALARS,
+  TsCodegenContext: () => TsCodegenContext,
+  TypeLocation: () => TypeLocation,
+  extractContext: () => extractContext
+});
+module.exports = __toCommonJS(context_exports);
+var import_graphql = require("graphql");
+var import_typescript = __toESM(require("typescript"));
+var import_utilities = require("./utilities");
+var import_utilities2 = require("../utilities");
+var import_import = require("./import");
+var import_model = require("./model");
+const DEFAULT_SCALAR_TYPE = "unknown";
+const BUILT_IN_SCALARS = {
+  ID: "string",
+  Int: "number",
+  Float: "number",
+  String: "string",
+  Boolean: "boolean"
+};
+const TsCodegenContextDefault = {
+  moduleRoot: "",
+  moduleModelsPath: "./__generated__/models.interface.ts",
+  moduleResolversPath: "./__generated__/resolvers.interface.ts",
+  baseModel: {
+    name: "BaseModel",
+    from: null
+  },
+  context: {
+    name: "unknown",
+    from: null
+  },
+  resolveInfo: {
+    name: "ResolveInfo",
+    from: "@graphitation/supermassive"
+  }
+};
+class TsCodegenContext {
+  constructor(options) {
+    this.options = options;
+    this.imports = [];
+    this.typeNameToImports = /* @__PURE__ */ new Map();
+    this.typeNameToModels = /* @__PURE__ */ new Map();
+    this.allModelNames = /* @__PURE__ */ new Set();
+    this.allPossibleModels = /* @__PURE__ */ new Set();
+  }
+  addImport(imp, node) {
+    var _a;
+    for (const { typeName } of imp.defs) {
+      const { imp: existingImport } = this.typeNameToImports.get(typeName) || {};
+      if (existingImport) {
+        throw new import_graphql.GraphQLError(`Definition ${typeName} is imported multiple times: ${existingImport.from}`, [
+          (_a = getArgumentValue(existingImport.directive.arguments, "from")) != null ? _a : existingImport.directive,
+          imp.directive,
+          node
+        ]);
+      }
+      this.typeNameToImports.set(typeName, {
+        modelName: (0, import_utilities2.addModelSuffix)(typeName),
+        imp
+      });
+    }
+    this.imports.push(imp);
+  }
+  addPossibleModel(possibleModel) {
+    this.allPossibleModels.add(possibleModel);
+  }
+  addModel(model, node) {
+    const existingModel = this.typeNameToModels.get(model.typeName);
+    if (existingModel) {
+      throw new import_graphql.GraphQLError(`Model for type ${model.typeName} is defined multiple times`, [existingModel.directive, node]);
+    }
+    this.typeNameToModels.set(model.typeName, model);
+  }
+  getAllImportDeclarations() {
+    return this.imports.map(({ defs, from }) => (0, import_utilities.createImportDeclaration)(defs.map(({ typeName }) => (0, import_utilities2.addModelSuffix)(typeName)), from));
+  }
+  getAllModelImportDeclarations() {
+    const imports = this.getAllImportDeclarations();
+    const models = Array.from(this.typeNameToModels.values()).map((model) => {
+      if (!model.from) {
+        return;
+      }
+      return (0, import_utilities.createImportDeclaration)([model.modelName], model.from, model.tsType !== model.modelName ? model.tsType : void 0);
+    }).filter(Boolean);
+    return imports.concat(models);
+  }
+  getScalarDeclaration(scalarName) {
+    if (!scalarName || BUILT_IN_SCALARS.hasOwnProperty(scalarName)) {
+      return;
+    }
+    let model;
+    if (this.typeNameToModels.has(scalarName)) {
+      const { from, modelName, tsType } = this.typeNameToModels.get(scalarName);
+      model = from ? modelName : tsType;
+    } else {
+      model = DEFAULT_SCALAR_TYPE;
+    }
+    return import_typescript.factory.createTypeAliasDeclaration(void 0, [import_typescript.factory.createModifier(import_typescript.default.SyntaxKind.ExportKeyword)], import_typescript.factory.createIdentifier((0, import_utilities2.addModelSuffix)(scalarName)), void 0, import_typescript.factory.createTypeReferenceNode(import_typescript.factory.createIdentifier(model), void 0));
+  }
+  getAllResolverImportDeclarations() {
+    const imports = [];
+    imports.push((0, import_utilities.createImportDeclaration)(["PromiseOrValue"], "@graphitation/supermassive"));
+    if (this.options.resolveInfo.from) {
+      imports.push((0, import_utilities.createImportDeclaration)([this.options.resolveInfo.name], this.options.resolveInfo.from));
+    }
+    if (this.options.context.from && this.options.context.name) {
+      imports.push((0, import_utilities.createImportDeclaration)([this.options.context.name], this.options.context.from));
+    }
+    imports.push((0, import_utilities.createImportDeclaration)(Array.from(this.allModelNames), "./models.interface"));
+    imports.push(...this.getAllImportDeclarations());
+    return imports;
+  }
+  getBaseModelType() {
+    return new TypeLocation(null, this.options.baseModel.name);
+  }
+  getContextType() {
+    return new TypeLocation(null, this.options.context.name || TsCodegenContextDefault.context.name);
+  }
+  getResolveInfoType() {
+    return new TypeLocation(null, this.options.resolveInfo.name);
+  }
+  getDefaultTypes() {
+    return [
+      (0, import_typescript.addSyntheticLeadingComment)(import_typescript.factory.createInterfaceDeclaration(void 0, [import_typescript.factory.createModifier(import_typescript.default.SyntaxKind.ExportKeyword)], import_typescript.factory.createIdentifier("BaseModel"), void 0, void 0, [
+        import_typescript.factory.createPropertySignature(void 0, import_typescript.factory.createIdentifier("__typename"), void 0, import_typescript.factory.createKeywordTypeNode(import_typescript.default.SyntaxKind.StringKeyword))
+      ]), import_typescript.SyntaxKind.SingleLineCommentTrivia, " Base type for all models. Enables automatic resolution of abstract GraphQL types (interfaces, unions)", true)
+    ];
+  }
+  getModelType(typeName, useScalars = false) {
+    if (BUILT_IN_SCALARS.hasOwnProperty(typeName)) {
+      return new TypeLocation(null, BUILT_IN_SCALARS[typeName]);
+    } else if (this.typeNameToImports.has(typeName)) {
+      let { modelName } = this.typeNameToImports.get(typeName);
+      return new TypeLocation(null, modelName);
+    } else {
+      const modelName = this.allPossibleModels.has(typeName) ? (0, import_utilities2.addModelSuffix)(typeName) : typeName;
+      if (this.allPossibleModels.has(typeName)) {
+        this.allModelNames.add(modelName);
+      }
+      return new TypeLocation(null, modelName);
+    }
+  }
+  getDefinedModelType(typeName) {
+    if (this.typeNameToModels.has(typeName)) {
+      let imp = this.typeNameToModels.get(typeName);
+      return new TypeLocation(null, imp.modelName);
+    } else {
+      return null;
+    }
+  }
+}
+function extractContext(options, document) {
+  const fullOptions = __spreadValues(__spreadValues({}, TsCodegenContextDefault), options);
+  let context = new TsCodegenContext(fullOptions);
+  (0, import_graphql.visit)(document, {
+    Directive: {
+      enter(node, _key, _parent, _path, ancestors) {
+        if (node.name.value === import_import.IMPORT_DIRECTIVE_NAME) {
+          context.addImport((0, import_import.processImportDirective)(node), node);
+        } else if (node.name.value === import_model.MODEL_DIRECTIVE_NAME) {
+          context.addModel((0, import_model.processModelDirective)(node, ancestors), node);
+        }
+      }
+    },
+    EnumTypeDefinition: {
+      enter(node) {
+        context.addPossibleModel(node.name.value);
+      }
+    },
+    ObjectTypeDefinition: {
+      enter(node) {
+        context.addPossibleModel(node.name.value);
+      }
+    },
+    UnionTypeDefinition: {
+      enter(node) {
+        context.addPossibleModel(node.name.value);
+      }
+    },
+    ScalarTypeDefinition: {
+      enter(node) {
+        context.addPossibleModel(node.name.value);
+      }
+    },
+    InterfaceTypeDefinition: {
+      enter(node) {
+        context.addPossibleModel(node.name.value);
+      }
+    }
+  });
+  return context;
+}
+class TypeLocation {
+  constructor(from, name) {
+    this.from = from;
+    this.name = name;
+  }
+  toTypeReference() {
+    if (this.from != null) {
+      return import_typescript.factory.createTypeReferenceNode(import_typescript.factory.createQualifiedName(import_typescript.factory.createIdentifier(this.from), import_typescript.factory.createIdentifier(this.name)));
+    } else {
+      return import_typescript.factory.createTypeReferenceNode(this.name);
+    }
+  }
+  toExpression() {
+    if (this.from != null) {
+      return import_typescript.factory.createPropertyAccessExpression(import_typescript.factory.createIdentifier(this.from), import_typescript.factory.createIdentifier(this.name));
+    } else {
+      return import_typescript.factory.createIdentifier(this.name);
+    }
+  }
+}
+const getArgumentValue = (args = [], name) => {
+  var _a;
+  return (_a = args.find((arg) => arg.name.value === name)) == null ? void 0 : _a.value;
+};

package/lib/codegen/context/index.mjs

@@ -0,0 +1,242 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/codegen/context/index.ts
+import {
+  GraphQLError,
+  visit
+} from "graphql";
+import ts, {
+  factory,
+  addSyntheticLeadingComment,
+  SyntaxKind
+} from "typescript";
+import { createImportDeclaration } from "./utilities.mjs";
+import { addModelSuffix } from "../utilities.mjs";
+import { IMPORT_DIRECTIVE_NAME, processImportDirective } from "./import.mjs";
+import { MODEL_DIRECTIVE_NAME, processModelDirective } from "./model.mjs";
+var DEFAULT_SCALAR_TYPE = "unknown";
+var BUILT_IN_SCALARS = {
+  ID: "string",
+  Int: "number",
+  Float: "number",
+  String: "string",
+  Boolean: "boolean"
+};
+var TsCodegenContextDefault = {
+  moduleRoot: "",
+  moduleModelsPath: "./__generated__/models.interface.ts",
+  moduleResolversPath: "./__generated__/resolvers.interface.ts",
+  baseModel: {
+    name: "BaseModel",
+    from: null
+  },
+  context: {
+    name: "unknown",
+    from: null
+  },
+  resolveInfo: {
+    name: "ResolveInfo",
+    from: "@graphitation/supermassive"
+  }
+};
+var TsCodegenContext = class {
+  constructor(options) {
+    this.options = options;
+    this.imports = [];
+    this.typeNameToImports = /* @__PURE__ */ new Map();
+    this.typeNameToModels = /* @__PURE__ */ new Map();
+    this.allModelNames = /* @__PURE__ */ new Set();
+    this.allPossibleModels = /* @__PURE__ */ new Set();
+  }
+  addImport(imp, node) {
+    var _a;
+    for (const { typeName } of imp.defs) {
+      const { imp: existingImport } = this.typeNameToImports.get(typeName) || {};
+      if (existingImport) {
+        throw new GraphQLError(`Definition ${typeName} is imported multiple times: ${existingImport.from}`, [
+          (_a = getArgumentValue(existingImport.directive.arguments, "from")) != null ? _a : existingImport.directive,
+          imp.directive,
+          node
+        ]);
+      }
+      this.typeNameToImports.set(typeName, {
+        modelName: addModelSuffix(typeName),
+        imp
+      });
+    }
+    this.imports.push(imp);
+  }
+  addPossibleModel(possibleModel) {
+    this.allPossibleModels.add(possibleModel);
+  }
+  addModel(model, node) {
+    const existingModel = this.typeNameToModels.get(model.typeName);
+    if (existingModel) {
+      throw new GraphQLError(`Model for type ${model.typeName} is defined multiple times`, [existingModel.directive, node]);
+    }
+    this.typeNameToModels.set(model.typeName, model);
+  }
+  getAllImportDeclarations() {
+    return this.imports.map(({ defs, from }) => createImportDeclaration(defs.map(({ typeName }) => addModelSuffix(typeName)), from));
+  }
+  getAllModelImportDeclarations() {
+    const imports = this.getAllImportDeclarations();
+    const models = Array.from(this.typeNameToModels.values()).map((model) => {
+      if (!model.from) {
+        return;
+      }
+      return createImportDeclaration([model.modelName], model.from, model.tsType !== model.modelName ? model.tsType : void 0);
+    }).filter(Boolean);
+    return imports.concat(models);
+  }
+  getScalarDeclaration(scalarName) {
+    if (!scalarName || BUILT_IN_SCALARS.hasOwnProperty(scalarName)) {
+      return;
+    }
+    let model;
+    if (this.typeNameToModels.has(scalarName)) {
+      const { from, modelName, tsType } = this.typeNameToModels.get(scalarName);
+      model = from ? modelName : tsType;
+    } else {
+      model = DEFAULT_SCALAR_TYPE;
+    }
+    return factory.createTypeAliasDeclaration(void 0, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(addModelSuffix(scalarName)), void 0, factory.createTypeReferenceNode(factory.createIdentifier(model), void 0));
+  }
+  getAllResolverImportDeclarations() {
+    const imports = [];
+    imports.push(createImportDeclaration(["PromiseOrValue"], "@graphitation/supermassive"));
+    if (this.options.resolveInfo.from) {
+      imports.push(createImportDeclaration([this.options.resolveInfo.name], this.options.resolveInfo.from));
+    }
+    if (this.options.context.from && this.options.context.name) {
+      imports.push(createImportDeclaration([this.options.context.name], this.options.context.from));
+    }
+    imports.push(createImportDeclaration(Array.from(this.allModelNames), "./models.interface"));
+    imports.push(...this.getAllImportDeclarations());
+    return imports;
+  }
+  getBaseModelType() {
+    return new TypeLocation(null, this.options.baseModel.name);
+  }
+  getContextType() {
+    return new TypeLocation(null, this.options.context.name || TsCodegenContextDefault.context.name);
+  }
+  getResolveInfoType() {
+    return new TypeLocation(null, this.options.resolveInfo.name);
+  }
+  getDefaultTypes() {
+    return [
+      addSyntheticLeadingComment(factory.createInterfaceDeclaration(void 0, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("BaseModel"), void 0, void 0, [
+        factory.createPropertySignature(void 0, factory.createIdentifier("__typename"), void 0, factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))
+      ]), SyntaxKind.SingleLineCommentTrivia, " Base type for all models. Enables automatic resolution of abstract GraphQL types (interfaces, unions)", true)
+    ];
+  }
+  getModelType(typeName, useScalars = false) {
+    if (BUILT_IN_SCALARS.hasOwnProperty(typeName)) {
+      return new TypeLocation(null, BUILT_IN_SCALARS[typeName]);
+    } else if (this.typeNameToImports.has(typeName)) {
+      let { modelName } = this.typeNameToImports.get(typeName);
+      return new TypeLocation(null, modelName);
+    } else {
+      const modelName = this.allPossibleModels.has(typeName) ? addModelSuffix(typeName) : typeName;
+      if (this.allPossibleModels.has(typeName)) {
+        this.allModelNames.add(modelName);
+      }
+      return new TypeLocation(null, modelName);
+    }
+  }
+  getDefinedModelType(typeName) {
+    if (this.typeNameToModels.has(typeName)) {
+      let imp = this.typeNameToModels.get(typeName);
+      return new TypeLocation(null, imp.modelName);
+    } else {
+      return null;
+    }
+  }
+};
+function extractContext(options, document) {
+  const fullOptions = __spreadValues(__spreadValues({}, TsCodegenContextDefault), options);
+  let context = new TsCodegenContext(fullOptions);
+  visit(document, {
+    Directive: {
+      enter(node, _key, _parent, _path, ancestors) {
+        if (node.name.value === IMPORT_DIRECTIVE_NAME) {
+          context.addImport(processImportDirective(node), node);
+        } else if (node.name.value === MODEL_DIRECTIVE_NAME) {
+          context.addModel(processModelDirective(node, ancestors), node);
+        }
+      }
+    },
+    EnumTypeDefinition: {
+      enter(node) {
+        context.addPossibleModel(node.name.value);
+      }
+    },
+    ObjectTypeDefinition: {
+      enter(node) {
+        context.addPossibleModel(node.name.value);
+      }
+    },
+    UnionTypeDefinition: {
+      enter(node) {
+        context.addPossibleModel(node.name.value);
+      }
+    },
+    ScalarTypeDefinition: {
+      enter(node) {
+        context.addPossibleModel(node.name.value);
+      }
+    },
+    InterfaceTypeDefinition: {
+      enter(node) {
+        context.addPossibleModel(node.name.value);
+      }
+    }
+  });
+  return context;
+}
+var TypeLocation = class {
+  constructor(from, name) {
+    this.from = from;
+    this.name = name;
+  }
+  toTypeReference() {
+    if (this.from != null) {
+      return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(this.from), factory.createIdentifier(this.name)));
+    } else {
+      return factory.createTypeReferenceNode(this.name);
+    }
+  }
+  toExpression() {
+    if (this.from != null) {
+      return factory.createPropertyAccessExpression(factory.createIdentifier(this.from), factory.createIdentifier(this.name));
+    } else {
+      return factory.createIdentifier(this.name);
+    }
+  }
+};
+var getArgumentValue = (args = [], name) => {
+  var _a;
+  return (_a = args.find((arg) => arg.name.value === name)) == null ? void 0 : _a.value;
+};
+export {
+  BUILT_IN_SCALARS,
+  TsCodegenContext,
+  TypeLocation,
+  extractContext
+};

package/lib/codegen/context/model.d.ts

@@ -0,0 +1,5 @@
+import { ASTNode, DirectiveNode } from "graphql";
+import { DefinitionModel } from "../types";
+export declare const MODEL_DIRECTIVE_NAME = "model";
+export declare function processModelDirective(node: DirectiveNode, ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>>): DefinitionModel;
+//# sourceMappingURL=model.d.ts.map

package/lib/codegen/context/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/codegen/context/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,OAAO,EACP,aAAa,EAGd,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAG3C,eAAO,MAAM,oBAAoB,UAAU,CAAC;AAE5C,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,aAAa,EACnB,SAAS,EAAE,aAAa,CAAC,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC,GACzD,eAAe,CAwCjB"}

package/lib/codegen/context/model.js

@@ -0,0 +1,53 @@
+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 model_exports = {};
+__export(model_exports, {
+  MODEL_DIRECTIVE_NAME: () => MODEL_DIRECTIVE_NAME,
+  processModelDirective: () => processModelDirective
+});
+module.exports = __toCommonJS(model_exports);
+var import_graphql = require("graphql");
+var import_utilities = require("../utilities");
+const MODEL_DIRECTIVE_NAME = "model";
+function processModelDirective(node, ancestors) {
+  const from = getArgumentValue(node.arguments, "from");
+  const tsType = getArgumentValue(node.arguments, "tsType");
+  if (from && from.kind !== "StringValue") {
+    throw new import_graphql.GraphQLError(`Directive @module requires "from" argument to exist and be a path to a typescript file.`, [from != null ? from : node]);
+  }
+  if ((tsType == null ? void 0 : tsType.kind) !== "StringValue") {
+    throw new import_graphql.GraphQLError(`Directive @model requires "tsType" argument to exist and be a name of the exported typescript type`, [tsType != null ? tsType : node]);
+  }
+  const typeDef = ancestors[ancestors.length - 1];
+  if (!typeDef || Array.isArray(typeDef) || typeDef.kind !== "ObjectTypeDefinition" && typeDef.kind !== "ScalarTypeDefinition") {
+    throw new import_graphql.GraphQLError("Directive @model must be defined on Object or Scalar type", [node]);
+  }
+  const typeName = typeDef.name.value;
+  return {
+    typeName,
+    modelName: `_${(0, import_utilities.addModelSuffix)(typeName)}`,
+    tsType: tsType.value,
+    importName: from ? (0, import_utilities.createVariableNameFromImport)(from.value) : null,
+    from: (from == null ? void 0 : from.value) || null,
+    directive: node
+  };
+}
+const getArgumentValue = (args = [], name) => {
+  var _a;
+  return (_a = args.find((arg) => arg.name.value === name)) == null ? void 0 : _a.value;
+};

package/lib/codegen/context/model.mjs

@@ -0,0 +1,37 @@
+// src/codegen/context/model.ts
+import {
+  GraphQLError
+} from "graphql";
+import { createVariableNameFromImport, addModelSuffix } from "../utilities.mjs";
+var MODEL_DIRECTIVE_NAME = "model";
+function processModelDirective(node, ancestors) {
+  const from = getArgumentValue(node.arguments, "from");
+  const tsType = getArgumentValue(node.arguments, "tsType");
+  if (from && from.kind !== "StringValue") {
+    throw new GraphQLError(`Directive @module requires "from" argument to exist and be a path to a typescript file.`, [from != null ? from : node]);
+  }
+  if ((tsType == null ? void 0 : tsType.kind) !== "StringValue") {
+    throw new GraphQLError(`Directive @model requires "tsType" argument to exist and be a name of the exported typescript type`, [tsType != null ? tsType : node]);
+  }
+  const typeDef = ancestors[ancestors.length - 1];
+  if (!typeDef || Array.isArray(typeDef) || typeDef.kind !== "ObjectTypeDefinition" && typeDef.kind !== "ScalarTypeDefinition") {
+    throw new GraphQLError("Directive @model must be defined on Object or Scalar type", [node]);
+  }
+  const typeName = typeDef.name.value;
+  return {
+    typeName,
+    modelName: `_${addModelSuffix(typeName)}`,
+    tsType: tsType.value,
+    importName: from ? createVariableNameFromImport(from.value) : null,
+    from: (from == null ? void 0 : from.value) || null,
+    directive: node
+  };
+}
+var getArgumentValue = (args = [], name) => {
+  var _a;
+  return (_a = args.find((arg) => arg.name.value === name)) == null ? void 0 : _a.value;
+};
+export {
+  MODEL_DIRECTIVE_NAME,
+  processModelDirective
+};

package/lib/codegen/context/utilities.d.ts

@@ -0,0 +1,2 @@
+export declare function createImportDeclaration(importNames: string[], from: string, importAlias?: string): import("typescript").ImportDeclaration;
+//# sourceMappingURL=utilities.d.ts.map

package/lib/codegen/context/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../../src/codegen/context/utilities.ts"],"names":[],"mappings":"AAEA,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,MAAM,EAAE,EACrB,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,MAAM,0CAmBrB"}

package/lib/codegen/context/utilities.js

@@ -0,0 +1,26 @@
+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 utilities_exports = {};
+__export(utilities_exports, {
+  createImportDeclaration: () => createImportDeclaration
+});
+module.exports = __toCommonJS(utilities_exports);
+var import_typescript = require("typescript");
+function createImportDeclaration(importNames, from, importAlias) {
+  return import_typescript.factory.createImportDeclaration(void 0, void 0, import_typescript.factory.createImportClause(true, void 0, import_typescript.factory.createNamedImports(importNames.map((importName) => import_typescript.factory.createImportSpecifier(importAlias ? import_typescript.factory.createIdentifier(importAlias) : void 0, import_typescript.factory.createIdentifier(importName))))), import_typescript.factory.createStringLiteral(from));
+}

package/lib/codegen/context/utilities.mjs

@@ -0,0 +1,8 @@
+// src/codegen/context/utilities.ts
+import { factory } from "typescript";
+function createImportDeclaration(importNames, from, importAlias) {
+  return factory.createImportDeclaration(void 0, void 0, factory.createImportClause(true, void 0, factory.createNamedImports(importNames.map((importName) => factory.createImportSpecifier(importAlias ? factory.createIdentifier(importAlias) : void 0, factory.createIdentifier(importName))))), factory.createStringLiteral(from));
+}
+export {
+  createImportDeclaration
+};

package/lib/codegen/index.d.ts

@@ -0,0 +1,7 @@
+import ts from "typescript";
+import { DocumentNode } from "graphql";
+export declare function generateTS(document: DocumentNode, contextImport?: string, contextName?: string): {
+    models: ts.SourceFile;
+    resolvers: ts.SourceFile;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/codegen/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAKvC,wBAAgB,UAAU,CACxB,QAAQ,EAAE,YAAY,EACtB,aAAa,CAAC,EAAE,MAAM,EACtB,WAAW,CAAC,EAAE,MAAM,GACnB;IAAE,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC;IAAC,SAAS,EAAE,EAAE,CAAC,UAAU,CAAA;CAAE,CAkBrD"}