@baeta/plugin-graphql 0.0.2 → 0.0.3

package/dist/index.js

@@ -1,29 +1,1267 @@
-"use strict";
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+
+// index.ts
+import { createPluginFactoryV1 } from "@baeta/plugin";
+
+// codegen.ts
+import { codegen as gqlCodegen } from "@graphql-codegen/core";
+import {
+  normalizeConfig,
+  normalizeInstanceOrArray
+} from "@graphql-codegen/plugin-helpers";
+
+// modules/index.ts
+import { concatAST, isScalarType as isScalarType2 } from "graphql";
+import { resolve, relative, join } from "path";
+
+// modules/utils.ts
+import {
+  Kind
+} from "graphql";
+import parse from "parse-filepath";
+var sep = "/";
+function collectUsedTypes(doc) {
+  const used = [];
+  doc.definitions.forEach(findRelated);
+  function markAsUsed(type) {
+    pushUnique(used, type);
+  }
+  function findRelated(node) {
+    if (node.kind === Kind.OBJECT_TYPE_DEFINITION || node.kind === 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 === Kind.INPUT_OBJECT_TYPE_DEFINITION || node.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION) {
+      markAsUsed(node.name.value);
+      if (node.fields) {
+        node.fields.forEach(findRelated);
+      }
+    } else if (node.kind === Kind.INTERFACE_TYPE_DEFINITION || node.kind === 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 === Kind.UNION_TYPE_DEFINITION || node.kind === Kind.UNION_TYPE_EXTENSION) {
+      markAsUsed(node.name.value);
+      if (node.types) {
+        node.types.forEach(findRelated);
+      }
+    } else if (node.kind === Kind.ENUM_TYPE_DEFINITION || node.kind === Kind.ENUM_TYPE_EXTENSION) {
+      markAsUsed(node.name.value);
+    } else if (node.kind === Kind.SCALAR_TYPE_DEFINITION || node.kind === Kind.SCALAR_TYPE_EXTENSION) {
+      if (!isGraphQLPrimitive(node.name.value)) {
+        markAsUsed(node.name.value);
+      }
+    } else if (node.kind === Kind.INPUT_VALUE_DEFINITION) {
+      findRelated(resolveTypeNode(node.type));
+    } else if (node.kind === Kind.FIELD_DEFINITION) {
+      findRelated(resolveTypeNode(node.type));
+      if (node.arguments) {
+        node.arguments.forEach(findRelated);
+      }
+    } else if (node.kind === Kind.NAMED_TYPE && !isGraphQLPrimitive(node.name.value)) {
+      markAsUsed(node.name.value);
+    }
+  }
+  return used;
+}
+function resolveTypeNode(node) {
+  if (node.kind === Kind.LIST_TYPE) {
+    return resolveTypeNode(node.type);
+  }
+  if (node.kind === 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 = parse(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
+import {
+  visit,
+  Kind as Kind2,
+  isScalarType
+} from "graphql";
+import { pascalCase } from "change-case-all";
+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);
+  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) + "\n}";
+  }
+  return [...!shouldDeclare ? imports : [], content, printFactoryMethod()].filter(Boolean).join("\n");
+  function printMetadata() {
+    return `export namespace ModuleMetadata {
+  export const id = '${name}';
+  export const dirname = __dirname;
+  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.createModule(ModuleMetadata);
+export const ${getModuleFn} = Baeta.createSingletonModule(${createModuleFn});
+`;
+  }
+  function printObjectFieldResolverBuilder(typeName, field) {
+    const resolverType = `${typeName}Resolvers["${field}"]`;
+    return `${field}: Baeta.createResolverBuilder<NonNullable<${resolverType}>>("${typeName}", "${field}", options),`;
+  }
+  function printObjectResolverBuilder(typeName, objects) {
+    var _a;
+    const fields = ((_a = objects[typeName]) == null ? void 0 : _a.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.createResolversBuilder("${typeName}", options, {} as ${resolversType}, ${content2}),`;
+  }
+  function printSubscriptionFieldBuilder(field) {
+    const resolverType = `SubscriptionResolvers["${field}"]`;
+    return `${field}: Baeta.createSubscriptionBuilder<${resolverType}>("${field}", options),`;
+  }
+  function printSubscriptionObjectBuilder() {
+    var _a;
+    const subscriptions = ((_a = picks.objects["Subscription"]) == null ? void 0 : _a.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.createSubscriptionsBuilder(options, {} as ${resolversType}, ${content2}),`;
+  }
+  function printScalarBuilder() {
+    const scalars = visited.scalars;
+    if (scalars.length === 0) {
+      return "";
+    }
+    const fields = scalars.map(
+      (scalar) => `${scalar}: Baeta.createScalarBuilder("${scalar}", options),`
+    );
+    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(options: Baeta.ManagerOptions) {
+    return Baeta.createManager(options, {}, ${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 `${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) {
+      const k = kind;
+      if (registry.hasOwnProperty(k) && resolverKeys.includes(k)) {
+        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 && 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 Kind2.OBJECT_TYPE_DEFINITION: {
+        defined.objects.push(name2);
+        collectFields(node, picks.objects);
+        break;
+      }
+      case Kind2.ENUM_TYPE_DEFINITION: {
+        defined.enums.push(name2);
+        collectValuesFromEnum(node);
+        break;
+      }
+      case Kind2.INPUT_OBJECT_TYPE_DEFINITION: {
+        defined.inputs.push(name2);
+        collectFields(node, picks.inputs);
+        break;
+      }
+      case Kind2.SCALAR_TYPE_DEFINITION: {
+        defined.scalars.push(name2);
+        break;
+      }
+      case Kind2.INTERFACE_TYPE_DEFINITION: {
+        defined.interfaces.push(name2);
+        collectFields(node, picks.interfaces);
+        break;
+      }
+      case Kind2.UNION_TYPE_DEFINITION: {
+        defined.unions.push(name2);
+        break;
+      }
+    }
+  }
+  function collectTypeExtension(node) {
+    const name2 = node.name.value;
+    switch (node.kind) {
+      case Kind2.OBJECT_TYPE_EXTENSION: {
+        collectFields(node, picks.objects);
+        if (rootTypes.includes(name2)) {
+          pushUnique(defined.objects, name2);
+          return;
+        }
+        pushUnique(extended.objects, name2);
+        break;
+      }
+      case Kind2.ENUM_TYPE_EXTENSION: {
+        collectValuesFromEnum(node);
+        pushUnique(extended.enums, name2);
+        break;
+      }
+      case Kind2.INPUT_OBJECT_TYPE_EXTENSION: {
+        collectFields(node, picks.inputs);
+        pushUnique(extended.inputs, name2);
+        break;
+      }
+      case Kind2.INTERFACE_TYPE_EXTENSION: {
+        collectFields(node, picks.interfaces);
+        pushUnique(extended.interfaces, name2);
+        break;
+      }
+      case Kind2.UNION_TYPE_EXTENSION: {
+        pushUnique(extended.unions, name2);
+        break;
+      }
+    }
+  }
+}
+
+// modules/index.ts
+import {
+  BaseVisitor,
+  getConfigValue
+} from "@graphql-codegen/visitor-plugin-common";
+var preset = {
+  buildGeneratesSection: (options) => {
+    const { baseOutputDir } = options;
+    const { baseTypesPath, encapsulateModuleTypes } = options.presetConfig;
+    const requireRootResolvers = getConfigValue(
+      options == null ? void 0 : options.presetConfig.requireRootResolvers,
+      false
+    );
+    const cwd = 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 || !options.schemaAst.extensions.sources) {
+      throw new Error(`Preset "graphql-modules" requires to use GraphQL SDL`);
+    }
+    const extensions = options.schemaAst.extensions;
+    const sourcesByModuleMap = groupSourcesByModule(
+      extensions.extendedSources,
+      baseOutputDir
+    );
+    const modules = Object.keys(sourcesByModuleMap);
+    const baseVisitor = new BaseVisitor(options.config, {});
+    const baseOutput = {
+      filename: 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] && isScalarType2(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 = resolve(
+        cwd,
+        baseOutputDir,
+        moduleName,
+        options.presetConfig.filename
+      );
+      const dirpath = stripFilename(filename);
+      const relativePath = relative(dirpath, baseTypesDir);
+      const importPath = options.presetConfig.importBaseTypesFrom || normalize(join(relativePath, baseTypesFilename));
+      const sources = sourcesByModuleMap[moduleName];
+      const documents = sources.map(
+        (source) => source.document
+      );
+      const moduleDocument = 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) => {
+              var _a, _b, _c;
+              return buildModule(moduleName, moduleDocument, {
+                importNamespace: importTypesNamespace,
+                importPath,
+                encapsulate: encapsulateModuleTypes || "namespace",
+                requireRootResolvers,
+                shouldDeclare,
+                schema,
+                baseVisitor,
+                useGraphQLModules: false,
+                rootTypes: [
+                  ((_a = schema.getQueryType()) == null ? void 0 : _a.name) || "",
+                  ((_b = schema.getMutationType()) == null ? void 0 : _b.name) || "",
+                  ((_c = schema.getSubscriptionType()) == null ? void 0 : _c.name) || ""
+                ].filter(Boolean)
+              });
+            }
+          }
+        },
+        config: options.config,
+        schemaAst: options.schemaAst
+      };
+    });
+    return [baseOutput].concat(outputs);
   }
-  return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var graphql_exports = {};
-__export(graphql_exports, {
-  default: () => graphql_default
+
+// codegen.ts
+import * as typescriptPlugin from "@graphql-codegen/typescript";
+
+// resolvers/index.ts
+var resolvers_exports = {};
+__export(resolvers_exports, {
+  plugin: () => plugin
 });
-module.exports = __toCommonJS(graphql_exports);
-var import_plugin = require("@baeta/plugin");
-var import_codegen = require("./codegen");
-var graphql_default = (0, import_plugin.createPluginFactoryV1)({
+import { parseMapper } from "@graphql-codegen/visitor-plugin-common";
+import {
+  addFederationReferencesToSchema,
+  getCachedDocumentNodeFromSchema,
+  oldVisit
+} from "@graphql-codegen/plugin-helpers";
+
+// resolvers/visitor.ts
+import autoBind from "auto-bind";
+import {
+  BaseResolversVisitor,
+  getConfigValue as getConfigValue2
+} from "@graphql-codegen/visitor-plugin-common";
+import { TypeScriptOperationVariablesToObject } from "@graphql-codegen/typescript";
+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) {
+    var _a;
+    const avoidOptionals = ((_a = this.config.avoidOptionals) == null ? void 0 : _a.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")
+  };
+};
+
+// codegen.ts
+import path from "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
+import { getCachedDocumentNodeFromSchema as getCachedDocumentNodeFromSchema3 } from "@graphql-codegen/plugin-helpers";
+import {
+  loadSchema as loadSchemaToolkit
+} from "@graphql-tools/load";
+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 { UrlLoader } from "@graphql-tools/url-loader";
+import { ApolloEngineLoader } from "@graphql-tools/apollo-engine-loader";
+import { PrismaLoader } from "@graphql-tools/prisma-loader";
+
+// utils/hash.ts
+import { getCachedDocumentNodeFromSchema as getCachedDocumentNodeFromSchema2 } from "@graphql-codegen/plugin-helpers";
+import { print } from "graphql";
+import { createHash } from "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)
+  };
+}
+
+// codegen.ts
+import { File } from "@baeta/plugin";
+async function generate(options) {
+  const root = process.cwd();
+  const modulesDir = path.relative(root, options.modulesDir || "modules");
+  const rootConfig = {
+    schemas: normalizeInstanceOrArray(options.schemas),
+    modulesDir,
+    baseTypesPath: path.relative(
+      modulesDir,
+      options.baseTypesPath || "./__generated__/types.ts"
+    ),
+    contextType: options.contextType,
+    moduleDefinitionName: options.moduleDefinitionName || "typedef.ts",
+    scalars: options.scalars,
+    plugins: 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",
+      scalars: {
+        BigInt: "number",
+        Bytes: "Buffer",
+        DateTime: "Date",
+        Decimal: "number",
+        Json: "{}",
+        ...rootConfig.scalars
+      }
+    }
+  });
+  const promises = outputs.map(async (output) => {
+    const result2 = await gqlCodegen({
+      ...output,
+      cache
+    });
+    return new File(output.filename, result2, "graphql");
+  });
+  return Promise.all(promises);
+}
+
+// index.ts
+var graphql_default = createPluginFactoryV1({
   name: "graphql",
   watch: (baetaConfig, pluginConfig) => {
     return {
@@ -32,10 +1270,11 @@ var graphql_default = (0, import_plugin.createPluginFactoryV1)({
     };
   },
   generate: async (params) => {
-    const files = await (0, import_codegen.generate)(params.config);
+    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 = {});
+export {
+  graphql_default as default
+};