@baeta/plugin-graphql 0.0.11 → 0.0.12

package/{index.js → dist/index.js}

@@ -14,12 +14,112 @@ import { normalizeConfig, normalizeInstanceOrArray } from "@graphql-codegen/plug
 import * as typescriptPlugin from "@graphql-codegen/typescript";
 import path from "path";
 
-// modules/index.ts
+// 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
+import { getCachedDocumentNodeFromSchema as getCachedDocumentNodeFromSchema2 } from "@graphql-codegen/plugin-helpers";
+import { ApolloEngineLoader } from "@graphql-tools/apollo-engine-loader";
+import { CodeFileLoader } from "@graphql-tools/code-file-loader";
+import { GitLoader } from "@graphql-tools/git-loader";
+import { GithubLoader } from "@graphql-tools/github-loader";
+import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
+import { JsonFileLoader } from "@graphql-tools/json-file-loader";
+import { loadSchema as loadSchemaToolkit } from "@graphql-tools/load";
+import { PrismaLoader } from "@graphql-tools/prisma-loader";
+import { UrlLoader } from "@graphql-tools/url-loader";
+
+// utils/hash.ts
+import { getCachedDocumentNodeFromSchema } from "@graphql-codegen/plugin-helpers";
+import { print } from "graphql";
+import { createHash } from "node:crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function hashSchema(schema) {
+  return hashContent(print(getCachedDocumentNodeFromSchema(schema)));
+}
+
+// utils/load.ts
+async function loadSchema(schemaPointerMap, cwd) {
+  const outputSchemaAst = await loadSchemaToolkit(schemaPointerMap, {
+    loaders: [
+      new CodeFileLoader(),
+      new GitLoader(),
+      new GithubLoader(),
+      new GraphQLFileLoader(),
+      new JsonFileLoader(),
+      new UrlLoader(),
+      new ApolloEngineLoader(),
+      new PrismaLoader()
+    ],
+    cwd,
+    includeSources: true
+  });
+  if (!outputSchemaAst.extensions) {
+    outputSchemaAst.extensions = {};
+  }
+  outputSchemaAst.extensions["hash"] = hashSchema(outputSchemaAst);
+  return {
+    outputSchemaAst,
+    outputSchema: getCachedDocumentNodeFromSchema2(outputSchemaAst)
+  };
+}
+
+// lib/context/index.ts
+var context_exports = {};
+__export(context_exports, {
+  default: () => context_default,
+  plugin: () => plugin
+});
+import { buildMapperImport, parseMapper } from "@graphql-codegen/visitor-plugin-common";
+var plugin = async (schema, documents, config) => {
+  const prepend = [];
+  const mapper = parseMapper(config.contextType || "any");
+  if (mapper.isExternal && mapper.source) {
+    const identifier = mapper.default ? "ContextType" : `${mapper.import} as ContextType`;
+    const result = buildMapperImport(
+      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 };
+
+// lib/modules/index.ts
 import { BaseVisitor, getConfigValue } from "@graphql-codegen/visitor-plugin-common";
 import { concatAST, isScalarType as isScalarType2 } from "graphql";
 import { join, relative, resolve } from "path";
 
-// modules/builder.ts
+// lib/modules/builder.ts
 import { pascalCase } from "change-case-all";
 import {
   isScalarType,
@@ -27,7 +127,9 @@ import {
   visit
 } from "graphql";
 
-// modules/utils.ts
+// lib/modules/utils.ts
+import { getBaseType } from "@graphql-codegen/plugin-helpers";
+import { DEFAULT_SCALARS, wrapTypeWithModifiers } from "@graphql-codegen/visitor-plugin-common";
 import {
   Kind
 } from "graphql";
@@ -85,6 +187,55 @@ function collectUsedTypes(doc) {
   }
   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 = getBaseType(field.type).name;
+  const isDefaultScalar = DEFAULT_SCALARS[baseName] != null;
+  const name = isDefaultScalar ? `Types.Scalars["${baseName}"]` : baseName;
+  const type = wrapTypeWithModifiers(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 (type.astNode?.kind !== Kind.OBJECT_TYPE_DEFINITION) {
+      continue;
+    }
+    const schemaType = schemaTypes[type.name];
+    const fieldsMap = schemaType.getFields();
+    for (const field of type.astNode.fields ?? []) {
+      collectObjectFieldArguments(type.astNode, field, fieldArguments);
+      collectObjectFieldType(type.astNode, field, fieldsMap, fieldTypes);
+    }
+  }
+  return { fieldTypes, fieldArguments };
+}
 function resolveTypeNode(node) {
   if (node.kind === Kind.LIST_TYPE) {
     return resolveTypeNode(node.type);
@@ -178,7 +329,7 @@ function createObject(keys, valueFn) {
   return obj;
 }
 
-// modules/builder.ts
+// lib/modules/builder.ts
 var registryKeys = [
   "objects",
   "inputs",
@@ -187,11 +338,6 @@ var registryKeys = [
   "unions",
   "enums"
 ];
-var resolverKeys = [
-  "scalars",
-  "objects",
-  "enums"
-];
 function buildModule(name, doc, {
   importNamespace,
   importPath,
@@ -200,7 +346,9 @@ function buildModule(name, doc, {
   shouldDeclare,
   rootTypes,
   schema,
-  baseVisitor
+  baseVisitor,
+  fieldTypes,
+  fieldArguments
 }) {
   const picks = createObject(
     registryKeys,
@@ -262,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, {
@@ -312,23 +457,32 @@ 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)) ?? [];
     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) ?? [];
@@ -336,20 +490,21 @@ ${fields.map(indent(2)).join("\n")}
       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}
@@ -357,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() {
@@ -390,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(" | ");
   }
@@ -575,9 +671,29 @@ ${body}
       }
     }
   }
+  function getParentType(type) {
+    if (["Query", "Mutation", "Subscription"].includes(type)) {
+      return "{}";
+    }
+    return type;
+  }
+  function getResultType(type, field) {
+    return fieldTypes?.[type]?.[field] || "{}";
+  }
+  function getArgsType(type, field) {
+    const hasArgs = fieldArguments?.[type]?.[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;
@@ -598,6 +714,7 @@ var preset = {
     const sourcesByModuleMap = groupSourcesByModule(sources, baseOutputDir);
     const modules = Object.keys(sourcesByModuleMap);
     const baseVisitor = new BaseVisitor(options.config, {});
+    const { fieldTypes, fieldArguments } = collectObjectFieldTypesAndArguments(options.schemaAst);
     const baseOutput = {
       filename: resolve(cwd, baseOutputDir, baseTypesPath),
       schema: options.schema,
@@ -662,6 +779,8 @@ var preset = {
               schema,
               baseVisitor,
               useGraphQLModules: false,
+              fieldTypes,
+              fieldArguments,
               rootTypes: [
                 schema.getQueryType()?.name || "",
                 schema.getMutationType()?.name || "",
@@ -678,439 +797,6 @@ var preset = {
   }
 };
 
-// resolvers/index.ts
-var resolvers_exports = {};
-__export(resolvers_exports, {
-  plugin: () => plugin
-});
-import {
-  addFederationReferencesToSchema,
-  getCachedDocumentNodeFromSchema,
-  oldVisit
-} from "@graphql-codegen/plugin-helpers";
-import { parseMapper } from "@graphql-codegen/visitor-plugin-common";
-
-// resolvers/visitor.ts
-import { TypeScriptOperationVariablesToObject } from "@graphql-codegen/typescript";
-import {
-  BaseResolversVisitor,
-  getConfigValue as getConfigValue2
-} from "@graphql-codegen/visitor-plugin-common";
-import autoBind from "auto-bind";
-var ENUM_RESOLVERS_SIGNATURE = "export type EnumResolverSignature<T, AllowedValues = any> = { [key in keyof T]?: AllowedValues };";
-var TypeScriptResolversVisitor = class extends BaseResolversVisitor {
-  constructor(pluginConfig, schema) {
-    super(
-      pluginConfig,
-      {
-        avoidOptionals: getConfigValue2(pluginConfig.avoidOptionals, false),
-        useIndexSignature: getConfigValue2(pluginConfig.useIndexSignature, false),
-        wrapFieldDefinitions: getConfigValue2(pluginConfig.wrapFieldDefinitions, false),
-        allowParentTypeOverride: getConfigValue2(pluginConfig.allowParentTypeOverride, false),
-        optionalInfoArgument: getConfigValue2(pluginConfig.optionalInfoArgument, false)
-      },
-      schema
-    );
-    autoBind(this);
-    this.setVariablesTransformer(
-      new 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 = 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 ? addFederationReferencesToSchema(schema) : schema;
-  const visitor = new TypeScriptResolversVisitor(
-    { ...config, directiveResolverMappings },
-    transformedSchema
-  );
-  const namespacedImportPrefix = visitor.config.namespacedImportName ? `${visitor.config.namespacedImportName}.` : "";
-  const astNode = getCachedDocumentNodeFromSchema(transformedSchema);
-  const visitorResult = 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 = 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 = 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 = 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
-import { getCachedDocumentNodeFromSchema as getCachedDocumentNodeFromSchema3 } from "@graphql-codegen/plugin-helpers";
-import { ApolloEngineLoader } from "@graphql-tools/apollo-engine-loader";
-import { CodeFileLoader } from "@graphql-tools/code-file-loader";
-import { GitLoader } from "@graphql-tools/git-loader";
-import { GithubLoader } from "@graphql-tools/github-loader";
-import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
-import { JsonFileLoader } from "@graphql-tools/json-file-loader";
-import { loadSchema as loadSchemaToolkit } from "@graphql-tools/load";
-import { PrismaLoader } from "@graphql-tools/prisma-loader";
-import { UrlLoader } from "@graphql-tools/url-loader";
-
-// utils/hash.ts
-import { getCachedDocumentNodeFromSchema as getCachedDocumentNodeFromSchema2 } from "@graphql-codegen/plugin-helpers";
-import { print } from "graphql";
-import { createHash } from "node:crypto";
-function hashContent(content) {
-  return createHash("sha256").update(content).digest("hex");
-}
-function hashSchema(schema) {
-  return hashContent(print(getCachedDocumentNodeFromSchema2(schema)));
-}
-
-// utils/load.ts
-async function loadSchema(schemaPointerMap, cwd) {
-  const outputSchemaAst = await loadSchemaToolkit(schemaPointerMap, {
-    loaders: [
-      new CodeFileLoader(),
-      new GitLoader(),
-      new GithubLoader(),
-      new GraphQLFileLoader(),
-      new JsonFileLoader(),
-      new UrlLoader(),
-      new ApolloEngineLoader(),
-      new PrismaLoader()
-    ],
-    cwd,
-    includeSources: true
-  });
-  if (!outputSchemaAst.extensions) {
-    outputSchemaAst.extensions = {};
-  }
-  outputSchemaAst.extensions["hash"] = hashSchema(outputSchemaAst);
-  return {
-    outputSchemaAst,
-    outputSchema: getCachedDocumentNodeFromSchema3(outputSchemaAst)
-  };
-}
-
 // lib/codegen.ts
 async function generate(options) {
   const root = process.cwd();
@@ -1122,10 +808,10 @@ async function generate(options) {
     contextType: options.contextType,
     moduleDefinitionName: options.moduleDefinitionName || "typedef.ts",
     scalars: options.scalars,
-    plugins: normalizeConfig(["typescript", "typescript-resolvers"]),
+    plugins: normalizeConfig(["typescript", "context"]),
     pluginMap: {
       typescript: typescriptPlugin,
-      "typescript-resolvers": resolvers_exports
+      context: context_exports
     }
   };
   const cache = createCache();
@@ -1154,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",