@baeta/plugin-graphql 0.0.11 → 0.0.13

package/index.cjs

@@ -1,55 +1,139 @@
-"use strict";
-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;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __defProp = Object.defineProperty;
 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);
 
 // index.ts
-var graphql_exports = {};
-__export(graphql_exports, {
-  default: () => graphql_default
-});
-module.exports = __toCommonJS(graphql_exports);
-var import_plugin2 = require("@baeta/plugin");
+var _plugin = require('@baeta/plugin');
 
 // lib/codegen.ts
-var import_plugin = require("@baeta/plugin");
-var import_core = require("@graphql-codegen/core");
-var import_plugin_helpers4 = require("@graphql-codegen/plugin-helpers");
-var typescriptPlugin = __toESM(require("@graphql-codegen/typescript"), 1);
-var import_path2 = __toESM(require("path"), 1);
 
-// modules/index.ts
-var import_visitor_plugin_common = require("@graphql-codegen/visitor-plugin-common");
-var import_graphql3 = require("graphql");
-var import_path = require("path");
+var _core = require('@graphql-codegen/core');
+var _pluginhelpers = require('@graphql-codegen/plugin-helpers');
+var _typescript = require('@graphql-codegen/typescript'); var typescriptPlugin = _interopRequireWildcard(_typescript);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+
+// utils/cache.ts
+function createCache() {
+  const cache = /* @__PURE__ */ new Map();
+  return function ensure(namespace, key, factory) {
+    const cacheKey = `${namespace}:${key}`;
+    const cachedValue = cache.get(cacheKey);
+    if (cachedValue) {
+      return cachedValue;
+    }
+    const value = factory();
+    cache.set(cacheKey, value);
+    return value;
+  };
+}
+
+// utils/load.ts
+
+var _apolloengineloader = require('@graphql-tools/apollo-engine-loader');
+var _codefileloader = require('@graphql-tools/code-file-loader');
+var _gitloader = require('@graphql-tools/git-loader');
+var _githubloader = require('@graphql-tools/github-loader');
+var _graphqlfileloader = require('@graphql-tools/graphql-file-loader');
+var _jsonfileloader = require('@graphql-tools/json-file-loader');
+var _load = require('@graphql-tools/load');
+var _prismaloader = require('@graphql-tools/prisma-loader');
+var _urlloader = require('@graphql-tools/url-loader');
+
+// utils/hash.ts
+
+var _graphql = require('graphql');
+var _crypto = require('crypto');
+function hashContent(content) {
+  return _crypto.createHash.call(void 0, "sha256").update(content).digest("hex");
+}
+function hashSchema(schema) {
+  return hashContent(_graphql.print.call(void 0, _pluginhelpers.getCachedDocumentNodeFromSchema.call(void 0, schema)));
+}
+
+// utils/load.ts
+async function loadSchema(schemaPointerMap, cwd) {
+  const outputSchemaAst = await _load.loadSchema.call(void 0, schemaPointerMap, {
+    loaders: [
+      new (0, _codefileloader.CodeFileLoader)(),
+      new (0, _gitloader.GitLoader)(),
+      new (0, _githubloader.GithubLoader)(),
+      new (0, _graphqlfileloader.GraphQLFileLoader)(),
+      new (0, _jsonfileloader.JsonFileLoader)(),
+      new (0, _urlloader.UrlLoader)(),
+      new (0, _apolloengineloader.ApolloEngineLoader)(),
+      new (0, _prismaloader.PrismaLoader)()
+    ],
+    cwd,
+    includeSources: true
+  });
+  if (!outputSchemaAst.extensions) {
+    outputSchemaAst.extensions = {};
+  }
+  outputSchemaAst.extensions["hash"] = hashSchema(outputSchemaAst);
+  return {
+    outputSchemaAst,
+    outputSchema: _pluginhelpers.getCachedDocumentNodeFromSchema.call(void 0, outputSchemaAst)
+  };
+}
 
-// modules/builder.ts
-var import_change_case_all = require("change-case-all");
-var import_graphql2 = require("graphql");
+// lib/context/index.ts
+var context_exports = {};
+__export(context_exports, {
+  default: () => context_default,
+  plugin: () => plugin
+});
+var _visitorplugincommon = require('@graphql-codegen/visitor-plugin-common');
+var plugin = async (schema, documents, config) => {
+  const prepend = [];
+  const mapper = _visitorplugincommon.parseMapper.call(void 0, config.contextType || "any");
+  if (mapper.isExternal && mapper.source) {
+    const identifier = mapper.default ? "ContextType" : `${mapper.import} as ContextType`;
+    const result = _visitorplugincommon.buildMapperImport.call(void 0, 
+      mapper.source,
+      [
+        {
+          identifier,
+          asDefault: mapper.default
+        }
+      ],
+      true
+    );
+    if (result) {
+      prepend.push(result);
+    }
+  } else {
+    prepend.push(`type ContextType = ${mapper.type}`);
+  }
+  prepend.push("export type { ContextType }");
+  return {
+    content: "",
+    prepend
+  };
+};
+var context_default = { plugin };
 
-// modules/utils.ts
-var import_graphql = require("graphql");
-var import_parse_filepath = __toESM(require("parse-filepath"), 1);
+// lib/modules/index.ts
+
+
+
+
+// lib/modules/builder.ts
+var _changecaseall = require('change-case-all');
+
+
+
+
+
+
+// lib/modules/utils.ts
+
+
+
+
+
+var _parsefilepath = require('parse-filepath'); var _parsefilepath2 = _interopRequireDefault(_parsefilepath);
 var sep = "/";
 function collectUsedTypes(doc) {
   const used = [];
@@ -58,7 +142,7 @@ function collectUsedTypes(doc) {
     pushUnique(used, type);
   }
   function findRelated(node) {
-    if (node.kind === import_graphql.Kind.OBJECT_TYPE_DEFINITION || node.kind === import_graphql.Kind.OBJECT_TYPE_EXTENSION) {
+    if (node.kind === _graphql.Kind.OBJECT_TYPE_DEFINITION || node.kind === _graphql.Kind.OBJECT_TYPE_EXTENSION) {
       markAsUsed(node.name.value);
       if (node.fields) {
         node.fields.forEach(findRelated);
@@ -66,12 +150,12 @@ function collectUsedTypes(doc) {
       if (node.interfaces) {
         node.interfaces.forEach(findRelated);
       }
-    } else if (node.kind === import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION || node.kind === import_graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
+    } else if (node.kind === _graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION || node.kind === _graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
       markAsUsed(node.name.value);
       if (node.fields) {
         node.fields.forEach(findRelated);
       }
-    } else if (node.kind === import_graphql.Kind.INTERFACE_TYPE_DEFINITION || node.kind === import_graphql.Kind.INTERFACE_TYPE_EXTENSION) {
+    } else if (node.kind === _graphql.Kind.INTERFACE_TYPE_DEFINITION || node.kind === _graphql.Kind.INTERFACE_TYPE_EXTENSION) {
       markAsUsed(node.name.value);
       if (node.fields) {
         node.fields.forEach(findRelated);
@@ -79,35 +163,84 @@ function collectUsedTypes(doc) {
       if (node.interfaces) {
         node.interfaces.forEach(findRelated);
       }
-    } else if (node.kind === import_graphql.Kind.UNION_TYPE_DEFINITION || node.kind === import_graphql.Kind.UNION_TYPE_EXTENSION) {
+    } else if (node.kind === _graphql.Kind.UNION_TYPE_DEFINITION || node.kind === _graphql.Kind.UNION_TYPE_EXTENSION) {
       markAsUsed(node.name.value);
       if (node.types) {
         node.types.forEach(findRelated);
       }
-    } else if (node.kind === import_graphql.Kind.ENUM_TYPE_DEFINITION || node.kind === import_graphql.Kind.ENUM_TYPE_EXTENSION) {
+    } else if (node.kind === _graphql.Kind.ENUM_TYPE_DEFINITION || node.kind === _graphql.Kind.ENUM_TYPE_EXTENSION) {
       markAsUsed(node.name.value);
-    } else if (node.kind === import_graphql.Kind.SCALAR_TYPE_DEFINITION || node.kind === import_graphql.Kind.SCALAR_TYPE_EXTENSION) {
+    } else if (node.kind === _graphql.Kind.SCALAR_TYPE_DEFINITION || node.kind === _graphql.Kind.SCALAR_TYPE_EXTENSION) {
       if (!isGraphQLPrimitive(node.name.value)) {
         markAsUsed(node.name.value);
       }
-    } else if (node.kind === import_graphql.Kind.INPUT_VALUE_DEFINITION) {
+    } else if (node.kind === _graphql.Kind.INPUT_VALUE_DEFINITION) {
       findRelated(resolveTypeNode(node.type));
-    } else if (node.kind === import_graphql.Kind.FIELD_DEFINITION) {
+    } else if (node.kind === _graphql.Kind.FIELD_DEFINITION) {
       findRelated(resolveTypeNode(node.type));
       if (node.arguments) {
         node.arguments.forEach(findRelated);
       }
-    } else if (node.kind === import_graphql.Kind.NAMED_TYPE && !isGraphQLPrimitive(node.name.value)) {
+    } else if (node.kind === _graphql.Kind.NAMED_TYPE && !isGraphQLPrimitive(node.name.value)) {
       markAsUsed(node.name.value);
     }
   }
   return used;
 }
+function collectObjectFieldType(node, fieldDefinition, fieldsMap, fieldTypes) {
+  const objectName = node.name.value;
+  const fieldName = fieldDefinition.name.value;
+  const field = fieldsMap[fieldDefinition.name.value];
+  const baseName = _pluginhelpers.getBaseType.call(void 0, field.type).name;
+  const isDefaultScalar = _visitorplugincommon.DEFAULT_SCALARS[baseName] != null;
+  const name = isDefaultScalar ? `Types.Scalars["${baseName}"]` : baseName;
+  const type = _visitorplugincommon.wrapTypeWithModifiers.call(void 0, name, field.type, {
+    wrapOptional: (str) => {
+      return `Types.Maybe<${str}>`;
+    },
+    wrapArray: (str) => {
+      return `Array<${str}>`;
+    }
+  });
+  if (fieldTypes[objectName] == null) {
+    fieldTypes[objectName] = {};
+  }
+  fieldTypes[objectName][fieldName] = type;
+}
+function collectObjectFieldArguments(node, fieldDefinition, fieldArguments) {
+  const objectName = node.name.value;
+  const fieldName = fieldDefinition.name.value;
+  const hasArguments = fieldDefinition.arguments != null && fieldDefinition.arguments.length > 0;
+  if (fieldArguments[objectName] == null) {
+    fieldArguments[objectName] = {};
+  }
+  fieldArguments[objectName][fieldName] = hasArguments;
+}
+function collectObjectFieldTypesAndArguments(schema) {
+  const fieldTypes = {};
+  const fieldArguments = {};
+  if (!schema) {
+    return { fieldTypes, fieldArguments };
+  }
+  const schemaTypes = schema.getTypeMap();
+  for (const type of Object.values(schemaTypes)) {
+    if (_optionalChain([type, 'access', _ => _.astNode, 'optionalAccess', _2 => _2.kind]) !== _graphql.Kind.OBJECT_TYPE_DEFINITION) {
+      continue;
+    }
+    const schemaType = schemaTypes[type.name];
+    const fieldsMap = schemaType.getFields();
+    for (const field of _nullishCoalesce(type.astNode.fields, () => ( []))) {
+      collectObjectFieldArguments(type.astNode, field, fieldArguments);
+      collectObjectFieldType(type.astNode, field, fieldsMap, fieldTypes);
+    }
+  }
+  return { fieldTypes, fieldArguments };
+}
 function resolveTypeNode(node) {
-  if (node.kind === import_graphql.Kind.LIST_TYPE) {
+  if (node.kind === _graphql.Kind.LIST_TYPE) {
     return resolveTypeNode(node.type);
   }
-  if (node.kind === import_graphql.Kind.NON_NULL_TYPE) {
+  if (node.kind === _graphql.Kind.NON_NULL_TYPE) {
     return resolveTypeNode(node.type);
   }
   return node;
@@ -165,7 +298,7 @@ function extractModuleDirectory(filepath, basePath) {
   return moduleDirectory;
 }
 function stripFilename(path2) {
-  const parsedPath = (0, import_parse_filepath.default)(path2);
+  const parsedPath = _parsefilepath2.default.call(void 0, path2);
   return normalize(parsedPath.dir);
 }
 function normalize(path2) {
@@ -196,7 +329,7 @@ function createObject(keys, valueFn) {
   return obj;
 }
 
-// modules/builder.ts
+// lib/modules/builder.ts
 var registryKeys = [
   "objects",
   "inputs",
@@ -205,11 +338,6 @@ var registryKeys = [
   "unions",
   "enums"
 ];
-var resolverKeys = [
-  "scalars",
-  "objects",
-  "enums"
-];
 function buildModule(name, doc, {
   importNamespace,
   importPath,
@@ -218,7 +346,9 @@ function buildModule(name, doc, {
   shouldDeclare,
   rootTypes,
   schema,
-  baseVisitor
+  baseVisitor,
+  fieldTypes,
+  fieldArguments
 }) {
   const picks = createObject(
     registryKeys,
@@ -227,7 +357,7 @@ function buildModule(name, doc, {
   const defined = createObject(registryKeys, () => []);
   const extended = createObject(registryKeys, () => []);
   const usedTypes = collectUsedTypes(doc);
-  (0, import_graphql2.visit)(doc, {
+  _graphql.visit.call(void 0, doc, {
     ObjectTypeDefinition(node) {
       collectTypeDefinition(node);
     },
@@ -280,9 +410,6 @@ function buildModule(name, doc, {
     printDefinedEnumValues(),
     printDefinedInputFields(),
     printSchemaTypes(usedTypes),
-    printScalars(visited),
-    printResolveSignaturesPerType(visited),
-    printResolversType(visited),
     printMetadata()
   ].filter(Boolean).join("\n\n");
   const moduleNamespace = baseVisitor.convertName(name, {
@@ -330,44 +457,54 @@ export const ${getModuleFn} = Baeta.createSingletonModule(${createModuleFn});
 `;
   }
   function printObjectFieldResolverBuilder(typeName, field) {
-    const resolverType = `${typeName}Resolvers["${field}"]`;
-    return `${field}: Baeta.createResolverBuilder<NonNullable<${resolverType}>>(module, "${typeName}", "${field}"),`;
+    const parentType = getParentType(typeName);
+    const resultType = getResultType(typeName, field);
+    const argumentsType = getArgsType(typeName, field);
+    const contextType = getContextType();
+    return `${field}: module.createResolverBuilder<${resultType}, ${parentType}, ${contextType}, ${argumentsType}>("${typeName}", "${field}"),`;
   }
   function printObjectResolverBuilder(typeName, objects) {
-    const fields = objects[typeName]?.filter(unique).map((field) => printObjectFieldResolverBuilder(typeName, field)) ?? [];
+    const fields = _nullishCoalesce(_optionalChain([objects, 'access', _3 => _3[typeName], 'optionalAccess', _4 => _4.filter, 'call', _5 => _5(unique), 'access', _6 => _6.map, 'call', _7 => _7((field) => printObjectFieldResolverBuilder(typeName, field))]), () => ( []));
     if (fields.length === 0) {
       return "";
     }
-    const resolversType = `${typeName}Resolvers`;
+    const parentType = getParentType(typeName);
+    const contextType = getContextType();
+    const addons = [`...module.createTypeMethods<${parentType}, ${contextType}>("${typeName}"),`];
+    const contentBody = [...addons, ...fields].map(indent(2)).join("\n");
     const content2 = `{
-${fields.map(indent(2)).join("\n")}
+${contentBody}
 }`;
-    return `${typeName}: Baeta.aggregateResolvers(module, "${typeName}", {} as ${resolversType}, ${content2}),`;
+    return `${typeName}: ${content2},`;
   }
   function printSubscriptionFieldBuilder(field) {
-    const resolverType = `SubscriptionResolvers["${field}"]`;
-    return `${field}: Baeta.createSubscriptionBuilder<${resolverType}>(module, "${field}"),`;
+    const parentType = getParentType("Subscription");
+    const resultType = getResultType("Subscription", field);
+    const argumentsType = getArgsType("Subscription", field);
+    const contextType = getContextType();
+    return `${field}: module.createSubscriptionBuilder<${resultType}, ${parentType}, ${contextType}, ${argumentsType}>("${field}"),`;
   }
   function printSubscriptionObjectBuilder() {
-    const subscriptions = picks.objects["Subscription"]?.filter(unique) ?? [];
+    const subscriptions = _nullishCoalesce(_optionalChain([picks, 'access', _8 => _8.objects, 'access', _9 => _9["Subscription"], 'optionalAccess', _10 => _10.filter, 'call', _11 => _11(unique)]), () => ( []));
     if (subscriptions.length === 0) {
       return "";
     }
     const fields = subscriptions.map((subscription) => printSubscriptionFieldBuilder(subscription));
-    const resolversType = "SubscriptionResolvers";
+    const parentType = getParentType("Subscription");
+    const contextType = getContextType();
+    const addons = [`...module.createSubscriptionMethods<${parentType}, ${contextType}>(),`];
+    const contentBody = [...addons, ...fields].map(indent(2)).join("\n");
     const content2 = `{
-${fields.map(indent(2)).join("\n")}
+${contentBody}
 }`;
-    return `Subscription: Baeta.aggregateSubscriptions(module, {} as ${resolversType}, ${content2}),`;
+    return `Subscription: ${content2},`;
   }
   function printScalarBuilder() {
     const scalars = visited.scalars;
     if (scalars.length === 0) {
       return "";
     }
-    const fields = scalars.map(
-      (scalar) => `${scalar}: Baeta.createScalarBuilder(module, "${scalar}"),`
-    );
+    const fields = scalars.map((scalar) => `${scalar}: module.createScalarBuilder("${scalar}"),`);
     const content2 = fields.map(indent(2)).join("\n");
     return `Scalar: {
 ${content2}
@@ -375,14 +512,21 @@ ${content2}
   }
   function printBaetaManager() {
     const objects = visited.objects.filter((type) => type !== "Subscription").map((typeName) => printObjectResolverBuilder(typeName, picks.objects)).filter(Boolean);
-    const bodyFields = [...objects, printScalarBuilder(), printSubscriptionObjectBuilder()];
+    const contextType = getContextType();
+    const addons = [`...module.createModuleMethods<${contextType}>(),`];
+    const bodyFields = [
+      ...addons,
+      ...objects,
+      printScalarBuilder(),
+      printSubscriptionObjectBuilder()
+    ];
     const body = bodyFields.filter(Boolean).map(indent(6)).join("\n");
     const content2 = `{
 ${body}
     }`;
     return `
   export function createManager(module: Baeta.ModuleBuilder) {
-    return Baeta.aggregateBuilders(module, {} as Resolvers, ${content2});
+    return ${content2};
   }`;
   }
   function printDefinedEnumValues() {
@@ -393,7 +537,7 @@ ${body}
   }
   function encapsulateTypeName(typeName) {
     if (encapsulate === "prefix") {
-      return `${(0, import_change_case_all.pascalCase)(name)}_${typeName}`;
+      return `${_changecaseall.pascalCase.call(void 0, name)}_${typeName}`;
     }
     return typeName;
   }
@@ -408,72 +552,6 @@ ${body}
   function printSchemaTypes(types) {
     return types.filter((type) => !visited.scalars.includes(type)).map(printExportType).join("\n");
   }
-  function printResolveSignaturesPerType(registry) {
-    return [
-      [...registry.objects, ...registry.interfaces].map(
-        (name2) => printResolverType(
-          name2,
-          "DefinedFields",
-          requireRootResolvers && rootTypes.includes(name2),
-          !rootTypes.includes(name2) && defined.objects.includes(name2) ? ` | '__isTypeOf'` : ""
-        )
-      ).join("\n")
-    ].join("\n");
-  }
-  function printScalars(registry) {
-    if (!registry.scalars.length) {
-      return "";
-    }
-    return [
-      `export type ${encapsulateTypeName(
-        "Scalars"
-      )} = Pick<${importNamespace}.Scalars, ${registry.scalars.map(withQuotes).join(" | ")}>;`,
-      ...registry.scalars.map((scalar) => {
-        const convertedName = baseVisitor.convertName(scalar, {
-          suffix: "ScalarConfig"
-        });
-        return `export type ${encapsulateTypeName(
-          convertedName
-        )} = ${importNamespace}.${convertedName};`;
-      })
-    ].join("\n");
-  }
-  function printResolversType(registry) {
-    const lines = [];
-    for (const kind in registry) {
-      if (!Object.prototype.hasOwnProperty.call(registry, kind)) {
-        continue;
-      }
-      if (!resolverKeys.includes(kind)) {
-        continue;
-      }
-      const k = kind;
-      const types = registry[k];
-      types.forEach((typeName) => {
-        if (k === "enums") {
-          return;
-        }
-        if (k === "scalars") {
-          lines.push(
-            `${typeName}?: ${encapsulateTypeName(importNamespace)}.Resolvers['${typeName}'];`
-          );
-        } else {
-          const fieldModifier = requireRootResolvers && rootTypes.includes(typeName) ? "" : "?";
-          lines.push(`${typeName}${fieldModifier}: ${encapsulateTypeName(typeName)}Resolvers;`);
-        }
-      });
-    }
-    return buildBlock({
-      name: `export interface ${encapsulateTypeName("Resolvers")}`,
-      lines
-    });
-  }
-  function printResolverType(typeName, picksTypeName, requireFieldsResolvers = false, extraKeys = "") {
-    const typeSignature = `Pick<${importNamespace}.${baseVisitor.convertName(typeName, {
-      suffix: "Resolvers"
-    })}, ${picksTypeName}['${typeName}']${extraKeys}>`;
-    return `export type ${encapsulateTypeName(`${typeName}Resolvers`)} = ${requireFieldsResolvers ? `Required<${typeSignature}>` : typeSignature};`;
-  }
   function printPicks(typeName, records) {
     return records[typeName].filter(unique).map(withQuotes).join(" | ");
   }
@@ -483,7 +561,7 @@ ${body}
       useTypesPrefix: true
     })}`;
     if (external.enums.includes(typeName) || external.objects.includes(typeName)) {
-      if (schema && (0, import_graphql2.isScalarType)(schema.getType(typeName))) {
+      if (schema && _graphql.isScalarType.call(void 0, schema.getType(typeName))) {
         return `${importNamespace}.Scalars['${typeName}']`;
       }
       return coreType;
@@ -530,31 +608,31 @@ ${body}
   function collectTypeDefinition(node) {
     const name2 = node.name.value;
     switch (node.kind) {
-      case import_graphql2.Kind.OBJECT_TYPE_DEFINITION: {
+      case _graphql.Kind.OBJECT_TYPE_DEFINITION: {
         defined.objects.push(name2);
         collectFields(node, picks.objects);
         break;
       }
-      case import_graphql2.Kind.ENUM_TYPE_DEFINITION: {
+      case _graphql.Kind.ENUM_TYPE_DEFINITION: {
         defined.enums.push(name2);
         collectValuesFromEnum(node);
         break;
       }
-      case import_graphql2.Kind.INPUT_OBJECT_TYPE_DEFINITION: {
+      case _graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION: {
         defined.inputs.push(name2);
         collectFields(node, picks.inputs);
         break;
       }
-      case import_graphql2.Kind.SCALAR_TYPE_DEFINITION: {
+      case _graphql.Kind.SCALAR_TYPE_DEFINITION: {
         defined.scalars.push(name2);
         break;
       }
-      case import_graphql2.Kind.INTERFACE_TYPE_DEFINITION: {
+      case _graphql.Kind.INTERFACE_TYPE_DEFINITION: {
         defined.interfaces.push(name2);
         collectFields(node, picks.interfaces);
         break;
       }
-      case import_graphql2.Kind.UNION_TYPE_DEFINITION: {
+      case _graphql.Kind.UNION_TYPE_DEFINITION: {
         defined.unions.push(name2);
         break;
       }
@@ -563,7 +641,7 @@ ${body}
   function collectTypeExtension(node) {
     const name2 = node.name.value;
     switch (node.kind) {
-      case import_graphql2.Kind.OBJECT_TYPE_EXTENSION: {
+      case _graphql.Kind.OBJECT_TYPE_EXTENSION: {
         collectFields(node, picks.objects);
         if (rootTypes.includes(name2)) {
           pushUnique(defined.objects, name2);
@@ -572,52 +650,73 @@ ${body}
         pushUnique(extended.objects, name2);
         break;
       }
-      case import_graphql2.Kind.ENUM_TYPE_EXTENSION: {
+      case _graphql.Kind.ENUM_TYPE_EXTENSION: {
         collectValuesFromEnum(node);
         pushUnique(extended.enums, name2);
         break;
       }
-      case import_graphql2.Kind.INPUT_OBJECT_TYPE_EXTENSION: {
+      case _graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION: {
         collectFields(node, picks.inputs);
         pushUnique(extended.inputs, name2);
         break;
       }
-      case import_graphql2.Kind.INTERFACE_TYPE_EXTENSION: {
+      case _graphql.Kind.INTERFACE_TYPE_EXTENSION: {
         collectFields(node, picks.interfaces);
         pushUnique(extended.interfaces, name2);
         break;
       }
-      case import_graphql2.Kind.UNION_TYPE_EXTENSION: {
+      case _graphql.Kind.UNION_TYPE_EXTENSION: {
         pushUnique(extended.unions, name2);
         break;
       }
     }
   }
+  function getParentType(type) {
+    if (["Query", "Mutation", "Subscription"].includes(type)) {
+      return "{}";
+    }
+    return type;
+  }
+  function getResultType(type, field) {
+    return _optionalChain([fieldTypes, 'optionalAccess', _12 => _12[type], 'optionalAccess', _13 => _13[field]]) || "{}";
+  }
+  function getArgsType(type, field) {
+    const hasArgs = _nullishCoalesce(_optionalChain([fieldArguments, 'optionalAccess', _14 => _14[type], 'optionalAccess', _15 => _15[field]]), () => ( false));
+    if (!hasArgs) {
+      return "{}";
+    }
+    const fieldUpper = field[0].toUpperCase() + field.slice(1);
+    return `Types.${type}${fieldUpper}Args`;
+  }
+  function getContextType() {
+    return "Types.ContextType";
+  }
 }
 
-// modules/index.ts
+// lib/modules/index.ts
 var preset = {
   buildGeneratesSection: (options) => {
     const { baseOutputDir } = options;
     const { baseTypesPath, encapsulateModuleTypes } = options.presetConfig;
-    const requireRootResolvers = (0, import_visitor_plugin_common.getConfigValue)(options?.presetConfig.requireRootResolvers, false);
-    const cwd = (0, import_path.resolve)(options.presetConfig.cwd || process.cwd());
+    const requireRootResolvers = _visitorplugincommon.getConfigValue.call(void 0, _optionalChain([options, 'optionalAccess', _16 => _16.presetConfig, 'access', _17 => _17.requireRootResolvers]), false);
+    const cwd = _path.resolve.call(void 0, options.presetConfig.cwd || process.cwd());
     const importTypesNamespace = options.presetConfig.importTypesNamespace || "Types";
     if (!baseTypesPath) {
       throw new Error(
         `Preset "graphql-modules" requires you to specify "baseTypesPath" configuration and point it to your base types file (generated by "typescript" plugin)!`
       );
     }
-    if (!options.schemaAst?.extensions.sources) {
+    if (!_optionalChain([options, 'access', _18 => _18.schemaAst, 'optionalAccess', _19 => _19.extensions, 'access', _20 => _20.sources])) {
       throw new Error(`Preset "graphql-modules" requires to use GraphQL SDL`);
     }
-    const extensions = options.schemaAst?.extensions;
-    const sources = extensions?.extendedSources ?? [];
+    const extensions = _optionalChain([options, 'access', _21 => _21.schemaAst, 'optionalAccess', _22 => _22.extensions]);
+    const sources = _nullishCoalesce(_optionalChain([extensions, 'optionalAccess', _23 => _23.extendedSources]), () => ( []));
     const sourcesByModuleMap = groupSourcesByModule(sources, baseOutputDir);
     const modules = Object.keys(sourcesByModuleMap);
-    const baseVisitor = new import_visitor_plugin_common.BaseVisitor(options.config, {});
+    const baseVisitor = new (0, _visitorplugincommon.BaseVisitor)(options.config, {});
+    const { fieldTypes, fieldArguments } = collectObjectFieldTypesAndArguments(options.schemaAst);
     const baseOutput = {
-      filename: (0, import_path.resolve)(cwd, baseOutputDir, baseTypesPath),
+      filename: _path.resolve.call(void 0, cwd, baseOutputDir, baseTypesPath),
       schema: options.schema,
       documents: options.documents,
       plugins: [
@@ -632,7 +731,7 @@ var preset = {
           plugin: (schema) => {
             const typeMap = schema.getTypeMap();
             return Object.keys(typeMap).map((t) => {
-              if (t && typeMap[t] && (0, import_graphql3.isScalarType)(typeMap[t]) && !isGraphQLPrimitive(t)) {
+              if (t && typeMap[t] && _graphql.isScalarType.call(void 0, typeMap[t]) && !isGraphQLPrimitive(t)) {
                 const convertedName = baseVisitor.convertName(t);
                 return `export type ${convertedName} = Scalars["${t}"];`;
               }
@@ -650,13 +749,13 @@ var preset = {
     const baseTypesFilename = baseTypesPath.replace(/\.(js|ts|d.ts)$/, "");
     const baseTypesDir = stripFilename(baseOutput.filename);
     const outputs = modules.map((moduleName) => {
-      const filename = (0, import_path.resolve)(cwd, baseOutputDir, moduleName, options.presetConfig.filename);
+      const filename = _path.resolve.call(void 0, cwd, baseOutputDir, moduleName, options.presetConfig.filename);
       const dirpath = stripFilename(filename);
-      const relativePath = (0, import_path.relative)(dirpath, baseTypesDir);
-      const importPath = options.presetConfig.importBaseTypesFrom || normalize((0, import_path.join)(relativePath, baseTypesFilename));
+      const relativePath = _path.relative.call(void 0, dirpath, baseTypesDir);
+      const importPath = options.presetConfig.importBaseTypesFrom || normalize(_path.join.call(void 0, relativePath, baseTypesFilename));
       const sources2 = sourcesByModuleMap[moduleName];
       const documents = sources2.map((source) => source.document);
-      const moduleDocument = (0, import_graphql3.concatAST)(documents);
+      const moduleDocument = _graphql.concatAST.call(void 0, documents);
       const shouldDeclare = filename.endsWith(".d.ts");
       return {
         filename,
@@ -680,10 +779,12 @@ var preset = {
               schema,
               baseVisitor,
               useGraphQLModules: false,
+              fieldTypes,
+              fieldArguments,
               rootTypes: [
-                schema.getQueryType()?.name || "",
-                schema.getMutationType()?.name || "",
-                schema.getSubscriptionType()?.name || ""
+                _optionalChain([schema, 'access', _24 => _24.getQueryType, 'call', _25 => _25(), 'optionalAccess', _26 => _26.name]) || "",
+                _optionalChain([schema, 'access', _27 => _27.getMutationType, 'call', _28 => _28(), 'optionalAccess', _29 => _29.name]) || "",
+                _optionalChain([schema, 'access', _30 => _30.getSubscriptionType, 'call', _31 => _31(), 'optionalAccess', _32 => _32.name]) || ""
               ].filter(Boolean)
             })
           }
@@ -696,447 +797,21 @@ var preset = {
   }
 };
 
-// resolvers/index.ts
-var resolvers_exports = {};
-__export(resolvers_exports, {
-  plugin: () => plugin
-});
-var import_plugin_helpers = require("@graphql-codegen/plugin-helpers");
-var import_visitor_plugin_common3 = require("@graphql-codegen/visitor-plugin-common");
-
-// resolvers/visitor.ts
-var import_typescript = require("@graphql-codegen/typescript");
-var import_visitor_plugin_common2 = require("@graphql-codegen/visitor-plugin-common");
-var import_auto_bind = __toESM(require("auto-bind"), 1);
-var ENUM_RESOLVERS_SIGNATURE = "export type EnumResolverSignature<T, AllowedValues = any> = { [key in keyof T]?: AllowedValues };";
-var TypeScriptResolversVisitor = class extends import_visitor_plugin_common2.BaseResolversVisitor {
-  constructor(pluginConfig, schema) {
-    super(
-      pluginConfig,
-      {
-        avoidOptionals: (0, import_visitor_plugin_common2.getConfigValue)(pluginConfig.avoidOptionals, false),
-        useIndexSignature: (0, import_visitor_plugin_common2.getConfigValue)(pluginConfig.useIndexSignature, false),
-        wrapFieldDefinitions: (0, import_visitor_plugin_common2.getConfigValue)(pluginConfig.wrapFieldDefinitions, false),
-        allowParentTypeOverride: (0, import_visitor_plugin_common2.getConfigValue)(pluginConfig.allowParentTypeOverride, false),
-        optionalInfoArgument: (0, import_visitor_plugin_common2.getConfigValue)(pluginConfig.optionalInfoArgument, false)
-      },
-      schema
-    );
-    (0, import_auto_bind.default)(this);
-    this.setVariablesTransformer(
-      new import_typescript.TypeScriptOperationVariablesToObject(
-        this.scalars,
-        this.convertName,
-        this.config.avoidOptionals,
-        this.config.immutableTypes,
-        this.config.namespacedImportName,
-        [],
-        this.config.enumPrefix,
-        this.config.enumValues
-      )
-    );
-    if (this.config.useIndexSignature) {
-      this._declarationBlockConfig = {
-        blockTransformer(block) {
-          return `ResolversObject<${block}>`;
-        }
-      };
-    }
-  }
-  transformParentGenericType(parentType) {
-    if (this.config.allowParentTypeOverride) {
-      return `ParentType = ${parentType}`;
-    }
-    return `ParentType extends ${parentType} = ${parentType}`;
-  }
-  formatRootResolver(schemaTypeName, resolverType, declarationKind) {
-    const avoidOptionals = this.config.avoidOptionals?.resolvers ?? this.config.avoidOptionals === true;
-    return `${schemaTypeName}${avoidOptionals ? "" : "?"}: ${resolverType}${this.getPunctuation(
-      declarationKind
-    )}`;
-  }
-  clearOptional(str) {
-    if (str.startsWith("Maybe")) {
-      return str.replace(/Maybe<(.*?)>$/, "$1");
-    }
-    return str;
-  }
-  ListType(node) {
-    return `Maybe<${super.ListType(node)}>`;
-  }
-  wrapWithListType(str) {
-    return `${this.config.immutableTypes ? "ReadonlyArray" : "Array"}<${str}>`;
-  }
-  getParentTypeForSignature(node) {
-    if (this._federation.isResolveReferenceField(node) && this.config.wrapFieldDefinitions) {
-      return "UnwrappedObject<ParentType>";
-    }
-    return "ParentType";
-  }
-  NamedType(node) {
-    return `Maybe<${super.NamedType(node)}>`;
-  }
-  NonNullType(node) {
-    const baseValue = super.NonNullType(node);
-    return this.clearOptional(baseValue);
-  }
-  getPunctuation(_declarationKind) {
-    return ";";
-  }
-  buildEnumResolverContentBlock(node, mappedEnumType) {
-    const valuesMap = `{ ${(node.values || []).map((v) => `${v.name}${this.config.avoidOptionals ? "" : "?"}: any`).join(", ")} }`;
-    this._globalDeclarations.add(ENUM_RESOLVERS_SIGNATURE);
-    return `EnumResolverSignature<${valuesMap}, ${mappedEnumType}>`;
-  }
-  buildEnumResolversExplicitMappedValues(node, valuesMapping) {
-    return `{ ${(node.values || []).map((v) => {
-      const valueName = v.name;
-      const mappedValue = valuesMapping[valueName];
-      return `${valueName}: ${typeof mappedValue === "number" ? mappedValue : `'${mappedValue}'`}`;
-    }).join(", ")} }`;
-  }
-};
-
-// resolvers/index.ts
-var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-var plugin = (schema, documents, config) => {
-  const imports = [];
-  if (!config.customResolveInfo) {
-    imports.push("GraphQLResolveInfo");
-  }
-  const showUnusedMappers = typeof config.showUnusedMappers === "boolean" ? config.showUnusedMappers : true;
-  const noSchemaStitching = typeof config.noSchemaStitching === "boolean" ? config.noSchemaStitching : true;
-  const indexSignature = config.useIndexSignature ? [
-    "export type WithIndex<TObject> = TObject & Record<string, any>;",
-    "export type ResolversObject<TObject> = WithIndex<TObject>;"
-  ].join("\n") : "";
-  const importType = config.useTypeImports ? "import type" : "import";
-  const prepend = [];
-  const defsToInclude = [];
-  const directiveResolverMappings = {};
-  if (config.directiveResolverMappings) {
-    for (const [directiveName, mapper] of Object.entries(config.directiveResolverMappings)) {
-      const parsedMapper = (0, import_visitor_plugin_common3.parseMapper)(mapper);
-      const capitalizedDirectiveName = capitalize(directiveName);
-      const resolverFnName = `ResolverFn${capitalizedDirectiveName}`;
-      const resolverFnUsage2 = `${resolverFnName}<TResult, TParent, TContext, TArgs>`;
-      const resolverWithResolveUsage2 = `Resolver${capitalizedDirectiveName}WithResolve<TResult, TParent, TContext, TArgs>`;
-      const resolverWithResolve2 = `
-export type Resolver${capitalizedDirectiveName}WithResolve<TResult, TParent, TContext, TArgs> = {
-  resolve: ${resolverFnName}<TResult, TParent, TContext, TArgs>;
-};`;
-      const resolverTypeName = `Resolver${capitalizedDirectiveName}`;
-      const resolverType2 = `export type ${resolverTypeName}<TResult, TParent = {}, TContext = {}, TArgs = {}> =`;
-      if (parsedMapper.isExternal) {
-        if (parsedMapper.default) {
-          prepend.push(`${importType} ${resolverFnName} from '${parsedMapper.source}';`);
-        } else {
-          prepend.push(
-            `${importType} { ${parsedMapper.import} ${parsedMapper.import !== resolverFnName ? `as ${resolverFnName} ` : ""}} from '${parsedMapper.source}';`
-          );
-        }
-        prepend.push(`export${config.useTypeImports ? " type" : ""} { ${resolverFnName} };`);
-      } else {
-        defsToInclude.push(
-          `export type ${resolverFnName}<TResult, TParent, TContext, TArgs> = ${parsedMapper.type}`
-        );
-      }
-      if (config.makeResolverTypeCallable) {
-        defsToInclude.push(`${resolverType2} ${resolverFnUsage2};`);
-      } else {
-        defsToInclude.push(resolverWithResolve2);
-        defsToInclude.push(`${resolverType2} ${resolverFnUsage2} | ${resolverWithResolveUsage2};`);
-      }
-      directiveResolverMappings[directiveName] = resolverTypeName;
-    }
-  }
-  const transformedSchema = config.federation ? (0, import_plugin_helpers.addFederationReferencesToSchema)(schema) : schema;
-  const visitor = new TypeScriptResolversVisitor(
-    { ...config, directiveResolverMappings },
-    transformedSchema
-  );
-  const namespacedImportPrefix = visitor.config.namespacedImportName ? `${visitor.config.namespacedImportName}.` : "";
-  const astNode = (0, import_plugin_helpers.getCachedDocumentNodeFromSchema)(transformedSchema);
-  const visitorResult = (0, import_plugin_helpers.oldVisit)(astNode, { leave: visitor });
-  const optionalSignForInfoArg = visitor.config.optionalInfoArgument ? "?" : "";
-  const legacyStitchingResolverType = `
-export type LegacyStitchingResolver<TResult, TParent, TContext, TArgs> = {
-  fragment: string;
-  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
-};`;
-  const newStitchingResolverType = `
-export type NewStitchingResolver<TResult, TParent, TContext, TArgs> = {
-  selectionSet: string | ((fieldNode: FieldNode) => SelectionSetNode);
-  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
-};`;
-  const stitchingResolverType = "export type StitchingResolver<TResult, TParent, TContext, TArgs> = LegacyStitchingResolver<TResult, TParent, TContext, TArgs> | NewStitchingResolver<TResult, TParent, TContext, TArgs>;";
-  const resolverWithResolve = `
-export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
-  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
-};`;
-  const resolverType = "export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =";
-  const resolverFnUsage = "ResolverFn<TResult, TParent, TContext, TArgs>";
-  const resolverWithResolveUsage = "ResolverWithResolve<TResult, TParent, TContext, TArgs>";
-  const stitchingResolverUsage = "StitchingResolver<TResult, TParent, TContext, TArgs>";
-  if (visitor.hasFederation()) {
-    if (visitor.config.wrapFieldDefinitions) {
-      defsToInclude.push(`export type UnwrappedObject<T> = {
-        [P in keyof T]: T[P] extends infer R | Promise<infer R> | (() => infer R2 | Promise<infer R2>)
-          ? R & R2 : T[P]
-      };`);
-    }
-    defsToInclude.push(`export type ReferenceResolver<TResult, TReference, TContext> = (
-      reference: TReference,
-      context: TContext,
-      info${optionalSignForInfoArg}: GraphQLResolveInfo
-    ) => Promise<TResult> | TResult;`);
-    defsToInclude.push(`
-      type ScalarCheck<T, S> = S extends true ? T : NullableCheck<T, S>;
-      type NullableCheck<T, S> = ${namespacedImportPrefix}Maybe<T> extends T ? ${namespacedImportPrefix}Maybe<ListCheck<NonNullable<T>, S>> : ListCheck<T, S>;
-      type ListCheck<T, S> = T extends (infer U)[] ? NullableCheck<U, S>[] : GraphQLRecursivePick<T, S>;
-      export type GraphQLRecursivePick<T, S> = { [K in keyof T & keyof S]: ScalarCheck<T[K], S[K]> };
-    `);
-  }
-  if (!config.makeResolverTypeCallable) {
-    defsToInclude.push(resolverWithResolve);
-  }
-  if (noSchemaStitching) {
-    const defs = config.makeResolverTypeCallable ? `${resolverType} ${resolverFnUsage};` : `${resolverType} ${resolverFnUsage} | ${resolverWithResolveUsage};`;
-    defsToInclude.push(defs);
-  } else {
-    defsToInclude.push(
-      [
-        legacyStitchingResolverType,
-        newStitchingResolverType,
-        stitchingResolverType,
-        resolverType,
-        `  | ${resolverFnUsage}`,
-        config.makeResolverTypeCallable ? "" : `  | ${resolverWithResolveUsage}`,
-        `  | ${stitchingResolverUsage};`
-      ].join("\n")
-    );
-    imports.push("SelectionSetNode", "FieldNode");
-  }
-  if (config.customResolverFn) {
-    const parsedMapper = (0, import_visitor_plugin_common3.parseMapper)(config.customResolverFn);
-    if (parsedMapper.isExternal) {
-      if (parsedMapper.default) {
-        prepend.push(`${importType} ResolverFn from '${parsedMapper.source}';`);
-      } else {
-        prepend.push(
-          `${importType} { ${parsedMapper.import} ${parsedMapper.import !== "ResolverFn" ? "as ResolverFn " : ""}} from '${parsedMapper.source}';`
-        );
-      }
-      prepend.push(`export${config.useTypeImports ? " type" : ""} { ResolverFn };`);
-    } else {
-      prepend.push(
-        `export type ResolverFn<TResult, TParent, TContext, TArgs> = ${parsedMapper.type}`
-      );
-    }
-  } else {
-    const defaultResolverFn = `
-export type ResolverFn<TResult, TParent, TContext, TArgs> = (
-  parent: TParent,
-  args: TArgs,
-  context: TContext,
-  info${optionalSignForInfoArg}: GraphQLResolveInfo
-) => Promise<TResult> | TResult;`;
-    defsToInclude.push(defaultResolverFn);
-  }
-  if (config.customSubscriptionResolver) {
-    const parsedMapper = (0, import_visitor_plugin_common3.parseMapper)(config.customSubscriptionResolver);
-    if (parsedMapper.isExternal) {
-      if (parsedMapper.default) {
-        prepend.push(`${importType} SubscriptionResolver from '${parsedMapper.source}';`);
-      } else {
-        prepend.push(
-          `${importType} { ${parsedMapper.import} ${parsedMapper.import !== "SubscriptionResolver" ? "as SubscriptionResolver " : ""}} from '${parsedMapper.source}';`
-        );
-      }
-      prepend.push(`export${config.useTypeImports ? " type" : ""} { SubscriptionResolver };`);
-    } else {
-      prepend.push(
-        `export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> = ${parsedMapper.type}`
-      );
-    }
-  } else {
-    const defaultSubscriptionDef = `
-export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
-  parent: TParent,
-  args: TArgs,
-  context: TContext,
-  info${optionalSignForInfoArg}: GraphQLResolveInfo
-) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
-
-export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
-  parent: TParent,
-  args: TArgs,
-  context: TContext,
-  info${optionalSignForInfoArg}: GraphQLResolveInfo
-) => TResult | Promise<TResult>;
-
-export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
-  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
-  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
-}
-
-export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
-  subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
-  resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
-}
-
-export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
-  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
-  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
-
-export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
-  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
-  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
-`;
-    defsToInclude.push(defaultSubscriptionDef);
-  }
-  const header = `${indexSignature}
-
-${visitor.getResolverTypeWrapperSignature()}
-
-${defsToInclude.join("\n")}
-
-export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
-  parent: TParent,
-  context: TContext,
-  info${optionalSignForInfoArg}: GraphQLResolveInfo
-) => ${namespacedImportPrefix}Maybe<TTypes> | Promise<${namespacedImportPrefix}Maybe<TTypes>>;
-
-export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info${optionalSignForInfoArg}: GraphQLResolveInfo) => boolean | Promise<boolean>;
-
-export type NextResolverFn<T> = () => Promise<T>;
-
-export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
-  next: NextResolverFn<TResult>,
-  parent: TParent,
-  args: TArgs,
-  context: TContext,
-  info${optionalSignForInfoArg}: GraphQLResolveInfo
-) => TResult | Promise<TResult>;
-`;
-  const resolversTypeMapping = visitor.buildResolversTypes();
-  const resolversParentTypeMapping = visitor.buildResolversParentTypes();
-  const { getRootResolver, getAllDirectiveResolvers, mappersImports, unusedMappers, hasScalars } = visitor;
-  if (hasScalars()) {
-    imports.push("GraphQLScalarType", "GraphQLScalarTypeConfig");
-  }
-  if (showUnusedMappers && unusedMappers.length) {
-    console.warn(`Unused mappers: ${unusedMappers.join(",")}`);
-  }
-  if (imports.length) {
-    prepend.push(`${importType} { ${imports.join(", ")} } from 'graphql';`);
-  }
-  if (config.customResolveInfo) {
-    const parsedMapper = (0, import_visitor_plugin_common3.parseMapper)(config.customResolveInfo);
-    if (parsedMapper.isExternal) {
-      if (parsedMapper.default) {
-        prepend.push(`import GraphQLResolveInfo from '${parsedMapper.source}'`);
-      }
-      prepend.push(
-        `import { ${parsedMapper.import} ${parsedMapper.import !== "GraphQLResolveInfo" ? "as GraphQLResolveInfo" : ""} } from '${parsedMapper.source}';`
-      );
-    } else {
-      prepend.push(`type GraphQLResolveInfo = ${parsedMapper.type}`);
-    }
-  }
-  prepend.push(...mappersImports, ...visitor.globalDeclarations);
-  return {
-    prepend,
-    content: [
-      header,
-      resolversTypeMapping,
-      resolversParentTypeMapping,
-      ...visitorResult.definitions.filter((d) => typeof d === "string"),
-      getRootResolver(),
-      getAllDirectiveResolvers()
-    ].join("\n")
-  };
-};
-
-// utils/cache.ts
-function createCache() {
-  const cache = /* @__PURE__ */ new Map();
-  return function ensure(namespace, key, factory) {
-    const cacheKey = `${namespace}:${key}`;
-    const cachedValue = cache.get(cacheKey);
-    if (cachedValue) {
-      return cachedValue;
-    }
-    const value = factory();
-    cache.set(cacheKey, value);
-    return value;
-  };
-}
-
-// utils/load.ts
-var import_plugin_helpers3 = require("@graphql-codegen/plugin-helpers");
-var import_apollo_engine_loader = require("@graphql-tools/apollo-engine-loader");
-var import_code_file_loader = require("@graphql-tools/code-file-loader");
-var import_git_loader = require("@graphql-tools/git-loader");
-var import_github_loader = require("@graphql-tools/github-loader");
-var import_graphql_file_loader = require("@graphql-tools/graphql-file-loader");
-var import_json_file_loader = require("@graphql-tools/json-file-loader");
-var import_load = require("@graphql-tools/load");
-var import_prisma_loader = require("@graphql-tools/prisma-loader");
-var import_url_loader = require("@graphql-tools/url-loader");
-
-// utils/hash.ts
-var import_plugin_helpers2 = require("@graphql-codegen/plugin-helpers");
-var import_graphql4 = require("graphql");
-var import_node_crypto = require("crypto");
-function hashContent(content) {
-  return (0, import_node_crypto.createHash)("sha256").update(content).digest("hex");
-}
-function hashSchema(schema) {
-  return hashContent((0, import_graphql4.print)((0, import_plugin_helpers2.getCachedDocumentNodeFromSchema)(schema)));
-}
-
-// utils/load.ts
-async function loadSchema(schemaPointerMap, cwd) {
-  const outputSchemaAst = await (0, import_load.loadSchema)(schemaPointerMap, {
-    loaders: [
-      new import_code_file_loader.CodeFileLoader(),
-      new import_git_loader.GitLoader(),
-      new import_github_loader.GithubLoader(),
-      new import_graphql_file_loader.GraphQLFileLoader(),
-      new import_json_file_loader.JsonFileLoader(),
-      new import_url_loader.UrlLoader(),
-      new import_apollo_engine_loader.ApolloEngineLoader(),
-      new import_prisma_loader.PrismaLoader()
-    ],
-    cwd,
-    includeSources: true
-  });
-  if (!outputSchemaAst.extensions) {
-    outputSchemaAst.extensions = {};
-  }
-  outputSchemaAst.extensions["hash"] = hashSchema(outputSchemaAst);
-  return {
-    outputSchemaAst,
-    outputSchema: (0, import_plugin_helpers3.getCachedDocumentNodeFromSchema)(outputSchemaAst)
-  };
-}
-
 // lib/codegen.ts
 async function generate(options) {
   const root = process.cwd();
-  const modulesDir = import_path2.default.relative(root, options.modulesDir || "modules");
+  const modulesDir = _path2.default.relative(root, options.modulesDir || "modules");
   const rootConfig = {
-    schemas: (0, import_plugin_helpers4.normalizeInstanceOrArray)(options.schemas),
+    schemas: _pluginhelpers.normalizeInstanceOrArray.call(void 0, options.schemas),
     modulesDir,
-    baseTypesPath: import_path2.default.relative(modulesDir, options.baseTypesPath || "./__generated__/types.ts"),
+    baseTypesPath: _path2.default.relative(modulesDir, options.baseTypesPath || "./__generated__/types.ts"),
     contextType: options.contextType,
     moduleDefinitionName: options.moduleDefinitionName || "typedef.ts",
     scalars: options.scalars,
-    plugins: (0, import_plugin_helpers4.normalizeConfig)(["typescript", "typescript-resolvers"]),
+    plugins: _pluginhelpers.normalizeConfig.call(void 0, ["typescript", "context"]),
     pluginMap: {
       typescript: typescriptPlugin,
-      "typescript-resolvers": resolvers_exports
+      context: context_exports
     }
   };
   const cache = createCache();
@@ -1165,17 +840,9 @@ async function generate(options) {
     pluginMap: rootConfig.pluginMap,
     plugins: rootConfig.plugins,
     config: {
-      useIndexSignature: true,
       inputMaybeValue: "T | undefined",
-      mapperTypeSuffix: "Prisma",
       contextType: rootConfig.contextType,
-      customResolverFn: "@baeta/core#Resolver",
-      customSubscriptionResolver: "@baeta/core#SubscriptionResolver",
       useTypeImports: true,
-      makeResolverTypeCallable: true,
-      includeDirectives: true,
-      resolverTypeWrapperSignature: "T",
-      emitLegacyCommonJSImports: false,
       scalars: {
         BigInt: "number",
         Bytes: "Buffer",
@@ -1187,17 +854,17 @@ async function generate(options) {
     }
   });
   const promises = outputs.map(async (output) => {
-    const result2 = await (0, import_core.codegen)({
+    const result2 = await _core.codegen.call(void 0, {
       ...output,
       cache
     });
-    return new import_plugin.File(output.filename, result2, "graphql");
+    return new (0, _plugin.File)(output.filename, result2, "graphql");
   });
   return Promise.all(promises);
 }
 
 // index.ts
-var graphql_default = (0, import_plugin2.createPluginFactoryV1)({
+var graphql_default = _plugin.createPluginFactoryV1.call(void 0, {
   name: "graphql",
   watch: (baetaConfig, pluginConfig) => {
     return {
@@ -1211,5 +878,6 @@ var graphql_default = (0, import_plugin2.createPluginFactoryV1)({
     return params.next();
   }
 });
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+
+
+exports.default = graphql_default;