@baeta/plugin-graphql 0.0.10 → 0.0.12

package/index.cjs

@@ -1,1215 +0,0 @@
-"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;
-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");
-
-// 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");
-
-// modules/builder.ts
-var import_change_case_all = require("change-case-all");
-var import_graphql2 = require("graphql");
-
-// modules/utils.ts
-var import_graphql = require("graphql");
-var import_parse_filepath = __toESM(require("parse-filepath"), 1);
-var sep = "/";
-function collectUsedTypes(doc) {
-  const used = [];
-  doc.definitions.forEach(findRelated);
-  function markAsUsed(type) {
-    pushUnique(used, type);
-  }
-  function findRelated(node) {
-    if (node.kind === import_graphql.Kind.OBJECT_TYPE_DEFINITION || node.kind === import_graphql.Kind.OBJECT_TYPE_EXTENSION) {
-      markAsUsed(node.name.value);
-      if (node.fields) {
-        node.fields.forEach(findRelated);
-      }
-      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) {
-      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) {
-      markAsUsed(node.name.value);
-      if (node.fields) {
-        node.fields.forEach(findRelated);
-      }
-      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) {
-      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) {
-      markAsUsed(node.name.value);
-    } else if (node.kind === import_graphql.Kind.SCALAR_TYPE_DEFINITION || node.kind === import_graphql.Kind.SCALAR_TYPE_EXTENSION) {
-      if (!isGraphQLPrimitive(node.name.value)) {
-        markAsUsed(node.name.value);
-      }
-    } else if (node.kind === import_graphql.Kind.INPUT_VALUE_DEFINITION) {
-      findRelated(resolveTypeNode(node.type));
-    } else if (node.kind === import_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)) {
-      markAsUsed(node.name.value);
-    }
-  }
-  return used;
-}
-function resolveTypeNode(node) {
-  if (node.kind === import_graphql.Kind.LIST_TYPE) {
-    return resolveTypeNode(node.type);
-  }
-  if (node.kind === import_graphql.Kind.NON_NULL_TYPE) {
-    return resolveTypeNode(node.type);
-  }
-  return node;
-}
-function isGraphQLPrimitive(name) {
-  return ["String", "Boolean", "ID", "Float", "Int"].includes(name);
-}
-function unique(val, i, all) {
-  return i === all.indexOf(val);
-}
-function withQuotes(val) {
-  return `'${val}'`;
-}
-function indent(size) {
-  const space = new Array(size).fill(" ").join("");
-  function indentInner(val) {
-    return val.split("\n").map((line) => `${space}${line}`).join("\n");
-  }
-  return indentInner;
-}
-function buildBlock({ name, lines }) {
-  if (!lines.length) {
-    return "";
-  }
-  return [`${name} {`, ...lines.map(indent(2)), "};"].join("\n");
-}
-var getRelativePath = function(filepath, basePath) {
-  const normalizedFilepath = normalize(filepath);
-  const normalizedBasePath = ensureStartsWithSeparator(
-    normalize(ensureEndsWithSeparator(basePath))
-  );
-  const [, relativePath] = normalizedFilepath.split(normalizedBasePath);
-  return relativePath;
-};
-function groupSourcesByModule(sources, basePath) {
-  const grouped = {};
-  sources.forEach((source) => {
-    if (!source.location) {
-      return;
-    }
-    const relativePath = getRelativePath(source.location, basePath);
-    if (relativePath) {
-      const mod = extractModuleDirectory(source.location, basePath);
-      if (!grouped[mod]) {
-        grouped[mod] = [];
-      }
-      grouped[mod].push(source);
-    }
-  });
-  return grouped;
-}
-function extractModuleDirectory(filepath, basePath) {
-  const relativePath = getRelativePath(filepath, basePath);
-  const [moduleDirectory] = relativePath.split(sep);
-  return moduleDirectory;
-}
-function stripFilename(path2) {
-  const parsedPath = (0, import_parse_filepath.default)(path2);
-  return normalize(parsedPath.dir);
-}
-function normalize(path2) {
-  return path2.replace(/\\/g, "/");
-}
-function ensureEndsWithSeparator(path2) {
-  return path2.endsWith(sep) ? path2 : path2 + sep;
-}
-function ensureStartsWithSeparator(path2) {
-  return path2.startsWith(".") ? path2.replace(/^(..\/)|(.\/)/, "/") : path2.startsWith("/") ? path2 : `/${path2}`;
-}
-function pushUnique(list, item) {
-  if (!list.includes(item)) {
-    list.push(item);
-  }
-}
-function concatByKey(left, right, key) {
-  return [.../* @__PURE__ */ new Set([...left[key], ...right[key]])];
-}
-function uniqueByKey(left, right, key) {
-  return left[key].filter((item) => !right[key].includes(item));
-}
-function createObject(keys, valueFn) {
-  const obj = {};
-  keys.forEach((key) => {
-    obj[key] = valueFn(key);
-  });
-  return obj;
-}
-
-// modules/builder.ts
-var registryKeys = [
-  "objects",
-  "inputs",
-  "interfaces",
-  "scalars",
-  "unions",
-  "enums"
-];
-var resolverKeys = [
-  "scalars",
-  "objects",
-  "enums"
-];
-function buildModule(name, doc, {
-  importNamespace,
-  importPath,
-  encapsulate,
-  requireRootResolvers,
-  shouldDeclare,
-  rootTypes,
-  schema,
-  baseVisitor
-}) {
-  const picks = createObject(
-    registryKeys,
-    () => ({})
-  );
-  const defined = createObject(registryKeys, () => []);
-  const extended = createObject(registryKeys, () => []);
-  const usedTypes = collectUsedTypes(doc);
-  (0, import_graphql2.visit)(doc, {
-    ObjectTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    ObjectTypeExtension(node) {
-      collectTypeExtension(node);
-    },
-    InputObjectTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    InputObjectTypeExtension(node) {
-      collectTypeExtension(node);
-    },
-    InterfaceTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    InterfaceTypeExtension(node) {
-      collectTypeExtension(node);
-    },
-    ScalarTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    UnionTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    UnionTypeExtension(node) {
-      collectTypeExtension(node);
-    },
-    EnumTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    EnumTypeExtension(node) {
-      collectTypeExtension(node);
-    }
-  });
-  const visited = createObject(
-    registryKeys,
-    (key) => concatByKey(defined, extended, key)
-  );
-  const external = createObject(
-    registryKeys,
-    (key) => uniqueByKey(extended, defined, key)
-  );
-  const imports = [
-    `import * as ${importNamespace} from "${importPath}";`,
-    'import { DocumentNode } from "graphql";',
-    'import * as Baeta from "@baeta/core/sdk";'
-  ];
-  let content = [
-    printDefinedFields(),
-    printDefinedEnumValues(),
-    printDefinedInputFields(),
-    printSchemaTypes(usedTypes),
-    printScalars(visited),
-    printResolveSignaturesPerType(visited),
-    printResolversType(visited),
-    printMetadata()
-  ].filter(Boolean).join("\n\n");
-  const moduleNamespace = baseVisitor.convertName(name, {
-    suffix: "Module",
-    useTypesPrefix: false,
-    useTypesSuffix: false
-  });
-  if (encapsulate === "namespace") {
-    content = `${shouldDeclare ? "declare" : "export"} namespace ${baseVisitor.convertName(name, {
-      suffix: "Module",
-      useTypesPrefix: false,
-      useTypesSuffix: false
-    })} {
-${shouldDeclare ? `${indent(2)(imports.join("\n"))}
-` : ""}${indent(2)(content)}
-}`;
-  }
-  return [...shouldDeclare ? [] : imports, content, printFactoryMethod()].filter(Boolean).join("\n");
-  function printMetadata() {
-    return `export namespace ModuleMetadata {
-  export const id = '${name}';
-  export const dirname = './${name}';
-  export const typedef = ${JSON.stringify(doc)} as unknown as DocumentNode;
-  ${printBaetaManager()}
-}`;
-  }
-  function printDefinedFields() {
-    return buildBlock({
-      name: "interface DefinedFields",
-      lines: [...visited.objects, ...visited.interfaces].map(
-        (typeName) => `${typeName}: ${printPicks(typeName, {
-          ...picks.objects,
-          ...picks.interfaces
-        })};`
-      )
-    });
-  }
-  function printFactoryMethod() {
-    const name2 = moduleNamespace.slice(0, moduleNamespace.length - 6);
-    const createModuleFn = `create${name2}Module`;
-    const getModuleFn = `get${name2}Module`;
-    return `
-export const ${createModuleFn} = () => Baeta.createModuleManager(ModuleMetadata);
-export const ${getModuleFn} = Baeta.createSingletonModule(${createModuleFn});
-`;
-  }
-  function printObjectFieldResolverBuilder(typeName, field) {
-    const resolverType = `${typeName}Resolvers["${field}"]`;
-    return `${field}: Baeta.createResolverBuilder<NonNullable<${resolverType}>>(module, "${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 content2 = `{
-${fields.map(indent(2)).join("\n")}
-}`;
-    return `${typeName}: Baeta.aggregateResolvers(module, "${typeName}", {} as ${resolversType}, ${content2}),`;
-  }
-  function printSubscriptionFieldBuilder(field) {
-    const resolverType = `SubscriptionResolvers["${field}"]`;
-    return `${field}: Baeta.createSubscriptionBuilder<${resolverType}>(module, "${field}"),`;
-  }
-  function printSubscriptionObjectBuilder() {
-    const subscriptions = picks.objects["Subscription"]?.filter(unique) ?? [];
-    if (subscriptions.length === 0) {
-      return "";
-    }
-    const fields = subscriptions.map((subscription) => printSubscriptionFieldBuilder(subscription));
-    const resolversType = "SubscriptionResolvers";
-    const content2 = `{
-${fields.map(indent(2)).join("\n")}
-}`;
-    return `Subscription: Baeta.aggregateSubscriptions(module, {} as ${resolversType}, ${content2}),`;
-  }
-  function printScalarBuilder() {
-    const scalars = visited.scalars;
-    if (scalars.length === 0) {
-      return "";
-    }
-    const fields = scalars.map(
-      (scalar) => `${scalar}: Baeta.createScalarBuilder(module, "${scalar}"),`
-    );
-    const content2 = fields.map(indent(2)).join("\n");
-    return `Scalar: {
-${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 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});
-  }`;
-  }
-  function printDefinedEnumValues() {
-    return buildBlock({
-      name: "interface DefinedEnumValues",
-      lines: visited.enums.map((typeName) => `${typeName}: ${printPicks(typeName, picks.enums)};`)
-    });
-  }
-  function encapsulateTypeName(typeName) {
-    if (encapsulate === "prefix") {
-      return `${(0, import_change_case_all.pascalCase)(name)}_${typeName}`;
-    }
-    return typeName;
-  }
-  function printDefinedInputFields() {
-    return buildBlock({
-      name: "interface DefinedInputFields",
-      lines: visited.inputs.map(
-        (typeName) => `${typeName}: ${printPicks(typeName, picks.inputs)};`
-      )
-    });
-  }
-  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(" | ");
-  }
-  function printTypeBody(typeName) {
-    const coreType = `${importNamespace}.${baseVisitor.convertName(typeName, {
-      useTypesSuffix: true,
-      useTypesPrefix: true
-    })}`;
-    if (external.enums.includes(typeName) || external.objects.includes(typeName)) {
-      if (schema && (0, import_graphql2.isScalarType)(schema.getType(typeName))) {
-        return `${importNamespace}.Scalars['${typeName}']`;
-      }
-      return coreType;
-    }
-    if (defined.enums.includes(typeName) && picks.enums[typeName]) {
-      return `DefinedEnumValues['${typeName}']`;
-    }
-    if (defined.objects.includes(typeName) && picks.objects[typeName]) {
-      return `Pick<${coreType}, DefinedFields['${typeName}']>`;
-    }
-    if (defined.interfaces.includes(typeName) && picks.interfaces[typeName]) {
-      return `Pick<${coreType}, DefinedFields['${typeName}']>`;
-    }
-    if (defined.inputs.includes(typeName) && picks.inputs[typeName]) {
-      return `Pick<${coreType}, DefinedInputFields['${typeName}']>`;
-    }
-    return coreType;
-  }
-  function printExportType(typeName) {
-    return `export type ${encapsulateTypeName(typeName)} = ${printTypeBody(typeName)};`;
-  }
-  function collectFields(node, picksObj) {
-    const name2 = node.name.value;
-    if (node.fields) {
-      if (!picksObj[name2]) {
-        picksObj[name2] = [];
-      }
-      node.fields.forEach((field) => {
-        picksObj[name2].push(field.name.value);
-      });
-    }
-  }
-  function collectValuesFromEnum(node) {
-    const name2 = node.name.value;
-    if (node.values) {
-      if (!picks.enums[name2]) {
-        picks.enums[name2] = [];
-      }
-      node.values.forEach((field) => {
-        picks.enums[name2].push(field.name.value);
-      });
-    }
-  }
-  function collectTypeDefinition(node) {
-    const name2 = node.name.value;
-    switch (node.kind) {
-      case import_graphql2.Kind.OBJECT_TYPE_DEFINITION: {
-        defined.objects.push(name2);
-        collectFields(node, picks.objects);
-        break;
-      }
-      case import_graphql2.Kind.ENUM_TYPE_DEFINITION: {
-        defined.enums.push(name2);
-        collectValuesFromEnum(node);
-        break;
-      }
-      case import_graphql2.Kind.INPUT_OBJECT_TYPE_DEFINITION: {
-        defined.inputs.push(name2);
-        collectFields(node, picks.inputs);
-        break;
-      }
-      case import_graphql2.Kind.SCALAR_TYPE_DEFINITION: {
-        defined.scalars.push(name2);
-        break;
-      }
-      case import_graphql2.Kind.INTERFACE_TYPE_DEFINITION: {
-        defined.interfaces.push(name2);
-        collectFields(node, picks.interfaces);
-        break;
-      }
-      case import_graphql2.Kind.UNION_TYPE_DEFINITION: {
-        defined.unions.push(name2);
-        break;
-      }
-    }
-  }
-  function collectTypeExtension(node) {
-    const name2 = node.name.value;
-    switch (node.kind) {
-      case import_graphql2.Kind.OBJECT_TYPE_EXTENSION: {
-        collectFields(node, picks.objects);
-        if (rootTypes.includes(name2)) {
-          pushUnique(defined.objects, name2);
-          return;
-        }
-        pushUnique(extended.objects, name2);
-        break;
-      }
-      case import_graphql2.Kind.ENUM_TYPE_EXTENSION: {
-        collectValuesFromEnum(node);
-        pushUnique(extended.enums, name2);
-        break;
-      }
-      case import_graphql2.Kind.INPUT_OBJECT_TYPE_EXTENSION: {
-        collectFields(node, picks.inputs);
-        pushUnique(extended.inputs, name2);
-        break;
-      }
-      case import_graphql2.Kind.INTERFACE_TYPE_EXTENSION: {
-        collectFields(node, picks.interfaces);
-        pushUnique(extended.interfaces, name2);
-        break;
-      }
-      case import_graphql2.Kind.UNION_TYPE_EXTENSION: {
-        pushUnique(extended.unions, name2);
-        break;
-      }
-    }
-  }
-}
-
-// 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 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) {
-      throw new Error(`Preset "graphql-modules" requires to use GraphQL SDL`);
-    }
-    const extensions = options.schemaAst?.extensions;
-    const sources = extensions?.extendedSources ?? [];
-    const sourcesByModuleMap = groupSourcesByModule(sources, baseOutputDir);
-    const modules = Object.keys(sourcesByModuleMap);
-    const baseVisitor = new import_visitor_plugin_common.BaseVisitor(options.config, {});
-    const baseOutput = {
-      filename: (0, import_path.resolve)(cwd, baseOutputDir, baseTypesPath),
-      schema: options.schema,
-      documents: options.documents,
-      plugins: [
-        ...options.plugins,
-        {
-          "modules-exported-scalars": {}
-        }
-      ],
-      pluginMap: {
-        ...options.pluginMap,
-        "modules-exported-scalars": {
-          plugin: (schema) => {
-            const typeMap = schema.getTypeMap();
-            return Object.keys(typeMap).map((t) => {
-              if (t && typeMap[t] && (0, import_graphql3.isScalarType)(typeMap[t]) && !isGraphQLPrimitive(t)) {
-                const convertedName = baseVisitor.convertName(t);
-                return `export type ${convertedName} = Scalars["${t}"];`;
-              }
-              return null;
-            }).filter(Boolean).join("\n");
-          }
-        }
-      },
-      config: {
-        ...options.config,
-        enumsAsTypes: true
-      },
-      schemaAst: options.schemaAst
-    };
-    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 dirpath = stripFilename(filename);
-      const relativePath = (0, import_path.relative)(dirpath, baseTypesDir);
-      const importPath = options.presetConfig.importBaseTypesFrom || normalize((0, import_path.join)(relativePath, baseTypesFilename));
-      const sources2 = sourcesByModuleMap[moduleName];
-      const documents = sources2.map((source) => source.document);
-      const moduleDocument = (0, import_graphql3.concatAST)(documents);
-      const shouldDeclare = filename.endsWith(".d.ts");
-      return {
-        filename,
-        schema: options.schema,
-        documents: [],
-        plugins: [
-          ...options.plugins.filter((p) => typeof p === "object" && !!p.add),
-          {
-            "graphql-modules-plugin": {}
-          }
-        ],
-        pluginMap: {
-          ...options.pluginMap,
-          "graphql-modules-plugin": {
-            plugin: (schema) => buildModule(moduleName, moduleDocument, {
-              importNamespace: importTypesNamespace,
-              importPath,
-              encapsulate: encapsulateModuleTypes || "namespace",
-              requireRootResolvers,
-              shouldDeclare,
-              schema,
-              baseVisitor,
-              useGraphQLModules: false,
-              rootTypes: [
-                schema.getQueryType()?.name || "",
-                schema.getMutationType()?.name || "",
-                schema.getSubscriptionType()?.name || ""
-              ].filter(Boolean)
-            })
-          }
-        },
-        config: options.config,
-        schemaAst: options.schemaAst
-      };
-    });
-    return [baseOutput].concat(outputs);
-  }
-};
-
-// 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 rootConfig = {
-    schemas: (0, import_plugin_helpers4.normalizeInstanceOrArray)(options.schemas),
-    modulesDir,
-    baseTypesPath: import_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"]),
-    pluginMap: {
-      typescript: typescriptPlugin,
-      "typescript-resolvers": resolvers_exports
-    }
-  };
-  const cache = createCache();
-  const schemaPointerMap = {};
-  for (const ptr of rootConfig.schemas) {
-    if (typeof ptr === "string") {
-      schemaPointerMap[ptr] = {};
-    } else if (typeof ptr === "object") {
-      Object.assign(schemaPointerMap, ptr);
-    }
-  }
-  const hash = JSON.stringify(schemaPointerMap);
-  const result = await cache("schema", hash, async () => {
-    return loadSchema(schemaPointerMap, root);
-  });
-  const outputs = await preset.buildGeneratesSection({
-    baseOutputDir: modulesDir,
-    presetConfig: {
-      baseTypesPath: rootConfig.baseTypesPath,
-      filename: rootConfig.moduleDefinitionName,
-      encapsulateModuleTypes: "none"
-    },
-    schema: result.outputSchema,
-    schemaAst: result.outputSchemaAst,
-    documents: [],
-    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",
-        DateTime: "Date",
-        Decimal: "number",
-        Json: "{}",
-        ...rootConfig.scalars
-      }
-    }
-  });
-  const promises = outputs.map(async (output) => {
-    const result2 = await (0, import_core.codegen)({
-      ...output,
-      cache
-    });
-    return new import_plugin.File(output.filename, result2, "graphql");
-  });
-  return Promise.all(promises);
-}
-
-// index.ts
-var graphql_default = (0, import_plugin2.createPluginFactoryV1)({
-  name: "graphql",
-  watch: (baetaConfig, pluginConfig) => {
-    return {
-      include: pluginConfig.schemas,
-      ignore: []
-    };
-  },
-  generate: async (params) => {
-    const files = await generate(params.config);
-    params.ctx.fileManager.add(...files);
-    return params.next();
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});