@baeta/plugin-graphql 1.0.9 → 2.0.0-next.0

package/dist/index.js

@@ -1,54 +1,24 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
 // index.ts
 import { createPluginV1, isMatch } from "@baeta/generator-sdk";
 
 // lib/codegen.ts
 import { join as join2 } from "@baeta/util-path";
-import { codegen as gqlCodegen } from "@graphql-codegen/core";
-import { normalizeConfig, normalizeInstanceOrArray } from "@graphql-codegen/plugin-helpers";
-import * as typescriptPlugin from "@graphql-codegen/typescript";
-
-// 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;
-  };
-}
+import { concatAST } from "graphql";
 
 // utils/load.ts
-import { getCachedDocumentNodeFromSchema as getCachedDocumentNodeFromSchema2 } from "@graphql-codegen/plugin-helpers";
 import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
 import {
   loadSchema as loadSchemaToolkit
 } from "@graphql-tools/load";
+import {
+  getDocumentNodeFromSchema
+} from "@graphql-tools/utils";
 import { validateSchema } from "graphql";
-
-// utils/hash.ts
-import { createHash } from "node:crypto";
-import { getCachedDocumentNodeFromSchema } from "@graphql-codegen/plugin-helpers";
-import { print } from "graphql";
-function hashContent(content) {
-  return createHash("sha256").update(content).digest("hex");
-}
-function hashSchema(schema) {
-  return hashContent(print(getCachedDocumentNodeFromSchema(schema)));
-}
-
-// utils/load.ts
-async function loadSchema(schemaPointerMap, cwd, extraLoaders = []) {
+async function loadSchema(schemas, cwd, extraLoaders = []) {
+  const schemaPointerMap = {};
+  for (const ptr of Array.isArray(schemas) ? schemas : [schemas]) {
+    schemaPointerMap[ptr] = {};
+  }
   const outputSchemaAst = await loadSchemaToolkit(schemaPointerMap, {
     loaders: [new GraphQLFileLoader(), ...extraLoaders],
     cwd,
@@ -65,1090 +35,750 @@ ${messages}`);
   if (!outputSchemaAst.extensions) {
     outputSchemaAst.extensions = {};
   }
-  outputSchemaAst.extensions.hash = hashSchema(outputSchemaAst);
   return {
     outputSchemaAst,
-    outputSchema: getCachedDocumentNodeFromSchema2(outputSchemaAst)
+    outputSchema: getDocumentNodeFromSchema(outputSchemaAst)
   };
 }
 
-// utils/scalars.ts
-import { dirname, isAbsolute, joinSafe, relative } from "@baeta/util-path";
-import { parseMapper } from "@graphql-codegen/visitor-plugin-common";
-function buildScalarMap(map, cwd, typesPath) {
-  if (!map) {
-    return {};
-  }
-  const fixedMap = {};
-  for (const key in map) {
-    const mapped = parseMapper(map[key]);
-    if (!mapped.isExternal) {
-      fixedMap[key] = map[key];
-      continue;
-    }
-    if (isAbsolute(mapped.source)) {
-      fixedMap[key] = map[key];
+// utils/path.ts
+import path, { normalize } from "@baeta/util-path";
+var sep = "/";
+function getRelativePath(filepath, basePath) {
+  const normalizedFilepath = normalize(filepath);
+  const normalizedBasePath = ensureStartsWithSeparator(
+    ensureEndsWithSeparator(normalize(basePath))
+  );
+  const [, relativePath] = normalizedFilepath.split(normalizedBasePath);
+  return relativePath;
+}
+function extractModuleDirectory(relativePath) {
+  const [moduleDirectory] = relativePath.split(sep);
+  return moduleDirectory;
+}
+function ensureStartsWithSeparator(path2) {
+  return path2.startsWith(sep) ? path2 : sep + path2;
+}
+function ensureEndsWithSeparator(path2) {
+  return path2.endsWith(sep) ? path2 : path2 + sep;
+}
+
+// utils/source.ts
+function groupSourcesByModule(sources, basePath) {
+  const map = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    if (!source.location) {
       continue;
     }
-    const scalarPath = joinSafe(cwd, mapped.source);
-    const relativePath = relative(dirname(typesPath), scalarPath);
-    if (mapped.default) {
-      fixedMap[key] = `${relativePath}#default`;
+    const relativePath = getRelativePath(source.location, basePath);
+    if (!relativePath) {
       continue;
     }
-    fixedMap[key] = `${relativePath}#${mapped.import}`;
+    const mod = extractModuleDirectory(relativePath);
+    const existing = map.get(mod) ?? [];
+    existing.push(source);
+    map.set(mod, existing);
   }
-  return fixedMap;
+  return map;
+}
+function getSourcesFromSchema(schema) {
+  const extensions = schema.extensions;
+  return extensions?.extendedSources ?? [];
 }
 
-// lib/context/index.ts
-var context_exports = {};
-__export(context_exports, {
-  default: () => context_default,
-  plugin: () => plugin
-});
-import { buildMapperImport, parseMapper as parseMapper2 } from "@graphql-codegen/visitor-plugin-common";
-var plugin = async (schema, documents, config) => {
-  const prepend = [];
-  const mapper = parseMapper2(config.contextType || "any");
-  if (mapper.isExternal && mapper.source) {
-    const identifier = mapper.default ? "ContextType" : `${mapper.import} as ContextType`;
-    const result = buildMapperImport(
-      mapper.source,
-      [
-        {
-          identifier,
-          asDefault: mapper.default
-        }
-      ],
-      true
-    );
-    if (result) {
-      prepend.push(result);
-    }
-  } else {
-    prepend.push(`type ContextType = ${mapper.type}`);
-  }
-  prepend.push("export type { ContextType }");
-  return {
-    content: "",
-    prepend
-  };
-};
-var context_default = { plugin };
-
-// lib/modules/index.ts
-import { basename, join, relative as relative2, resolve } from "@baeta/util-path";
-import { BaseVisitor, getConfigValue } from "@graphql-codegen/visitor-plugin-common";
-import {
-  concatAST,
-  isScalarType as isScalarType2
-} from "graphql";
+// lib/printer/printer-autoload.ts
+import { camelCase } from "change-case-all";
+function printAutoload(config, modules) {
+  return [printImports(config, modules), printExport(modules)].join("\n\n");
+}
+function printImports(config, modules) {
+  return modules.map(
+    (module) => `import ${camelCase(module)} from "./${module}/index${config.importExtension}"`
+  ).join("\n");
+}
+function printExport(modules) {
+  return `export default [${modules.map((m) => camelCase(m)).join(", ")}];`;
+}
 
-// lib/modules/builder.ts
+// lib/printer/printer-module.ts
+import { join, relative } from "@baeta/util-path";
 import { pascalCase } from "change-case-all";
-import {
-  Kind as Kind3,
-  isInterfaceType,
-  isScalarType,
-  isUnionType,
-  visit
-} from "graphql";
 
-// lib/modules/hashes.ts
-import {
-  Kind
-} from "graphql";
-import hash from "murmurhash";
-function getObjectTypeHash(node) {
-  const fieldNames = buildFieldsNames(node.fields);
-  const typeFields = fieldNames.map(([fieldName, fieldType]) => `${fieldName}:${fieldType}`).join(",");
-  const fieldMap = {};
-  for (const [fieldName, fieldType] of fieldNames) {
-    fieldMap[fieldName] = hash.v3(fieldType).toString(36);
-  }
-  return {
-    hash: hash.v3(typeFields).toString(36),
-    fieldsHashes: fieldMap
-  };
+// lib/printer/printer-utils.ts
+function buildBlock({ name, lines }) {
+  return [`${name} {`, ...lines.filter(Boolean).map(indent(2)), "};"].join("\n");
 }
-function buildFieldsNames(fields = []) {
-  if (fields.length === 0) {
-    return [];
-  }
-  const fieldsNames = [];
-  for (const field of fields) {
-    const fieldName = field.name.value;
-    const fieldType = buildTypeName(field.type);
-    fieldsNames.push([fieldName, fieldType]);
-  }
-  return fieldsNames.sort(([a], [b]) => a.localeCompare(b));
+function buildCodeBlock({ name, lines }) {
+  const linesWithSep = lines.filter(Boolean).map(indent(2)).join(",\n");
+  return [`${name} {`, linesWithSep, "}"].join("\n");
 }
-function buildTypeName(node) {
-  if (node.kind === Kind.NAMED_TYPE) {
-    return node.name.value;
-  }
-  if (node.kind === Kind.LIST_TYPE) {
-    return `[${buildTypeName(node.type)}]`;
-  }
-  if (node.kind === Kind.NON_NULL_TYPE) {
-    return `${buildTypeName(node.type)}!`;
+function indent(size) {
+  const space = new Array(size).fill(" ").join("");
+  function indentInner(val) {
+    return val.split("\n").map((line) => `${space}${line}`).join("\n");
   }
-  return "";
+  return indentInner;
 }
 
-// lib/modules/utils.ts
-import { platform } from "node:os";
-import { getBaseType } from "@graphql-codegen/plugin-helpers";
-import { DEFAULT_SCALARS, wrapTypeWithModifiers } from "@graphql-codegen/visitor-plugin-common";
-import {
-  Kind as Kind2
-} from "graphql";
-import parse from "parse-filepath";
-var sep = "/";
-function collectUsedTypes(doc) {
-  const used = [];
-  for (const definition of doc.definitions) {
-    findRelated(definition);
+// lib/printer/printer-module.ts
+function printModuleImports(config, moduleName) {
+  const typesDir = relative(join(config.modulesDir, moduleName), config.typesDir);
+  return [
+    'import type { DocumentNode, GraphQLScalarType } from "graphql";',
+    'import * as Baeta from "@baeta/core/sdk";',
+    `import extensions from "../extensions${config.importExtension}";`,
+    `import type {Ctx, Info} from "../types${config.importExtension}";`,
+    `import * as Types from "${typesDir}/types${config.importExtension}";`
+  ].join("\n");
+}
+function printModuleMetadata(name, doc) {
+  return buildCodeBlock({
+    name: "const moduleMetadata =",
+    lines: [
+      `id: '${name}'`,
+      `dirname: './${name}'`,
+      `typedef: ${JSON.stringify(doc)} as unknown as DocumentNode`
+    ]
+  });
+}
+function printBaetaModuleTypes(config) {
+  return buildBlock({
+    name: "interface BaetaModuleTypes",
+    lines: [
+      buildBlock({
+        name: "Builders:",
+        lines: printBaetaModuleTypesForFields(config, false)
+      }),
+      buildBlock({
+        name: "Factories:",
+        lines: [
+          ...printBaetaModuleTypesForFields(config, true),
+          ...printBaetaModuleTypesScalars(config)
+        ]
+      })
+    ]
+  });
+}
+function printBaetaModuleTypesForFields(config, isFactory) {
+  return config.registry.defined.objects.map(
+    (typeName) => printObjectTypeModuleType(typeName, config.registry.picks.objects, isFactory)
+  ).filter(Boolean);
+}
+function printObjectTypeModuleType(typeName, objects, isFactory) {
+  const object = objects[typeName];
+  if (!object) {
+    return "";
   }
-  function markAsUsed(type) {
-    pushUnique(used, type);
+  const parentType = getParentType(typeName);
+  const contextType = getContextType();
+  const infoType = getInfoType();
+  if (isFactory) {
+    return `${typeName}: Baeta.TypeCompilerFactory<${parentType}, ${contextType}, ${infoType}, BaetaModuleObjectTypeFields['${typeName}']['Factory']>`;
   }
-  function findRelated(node) {
-    if (node.kind === Kind2.OBJECT_TYPE_DEFINITION || node.kind === Kind2.OBJECT_TYPE_EXTENSION) {
-      markAsUsed(node.name.value);
-      if (node.fields) {
-        for (const field of node.fields) {
-          findRelated(field);
-        }
-      }
-      if (node.interfaces) {
-        for (const _interface of node.interfaces) {
-          findRelated(_interface);
-        }
-      }
-    } else if (node.kind === Kind2.INPUT_OBJECT_TYPE_DEFINITION || node.kind === Kind2.INPUT_OBJECT_TYPE_EXTENSION) {
-      markAsUsed(node.name.value);
-      if (node.fields) {
-        for (const field of node.fields) {
-          findRelated(field);
-        }
-      }
-    } else if (node.kind === Kind2.INTERFACE_TYPE_DEFINITION || node.kind === Kind2.INTERFACE_TYPE_EXTENSION) {
-      markAsUsed(node.name.value);
-      if (node.fields) {
-        for (const field of node.fields) {
-          findRelated(field);
-        }
-      }
-      if (node.interfaces) {
-        for (const _interface of node.interfaces) {
-          findRelated(_interface);
-        }
-      }
-    } else if (node.kind === Kind2.UNION_TYPE_DEFINITION || node.kind === Kind2.UNION_TYPE_EXTENSION) {
-      markAsUsed(node.name.value);
-      if (node.types) {
-        for (const type of node.types) {
-          findRelated(type);
-        }
-      }
-    } else if (node.kind === Kind2.ENUM_TYPE_DEFINITION || node.kind === Kind2.ENUM_TYPE_EXTENSION) {
-      markAsUsed(node.name.value);
-    } else if (node.kind === Kind2.SCALAR_TYPE_DEFINITION || node.kind === Kind2.SCALAR_TYPE_EXTENSION) {
-      if (!isGraphQLPrimitive(node.name.value)) {
-        markAsUsed(node.name.value);
-      }
-    } else if (node.kind === Kind2.INPUT_VALUE_DEFINITION) {
-      findRelated(resolveTypeNode(node.type));
-    } else if (node.kind === Kind2.FIELD_DEFINITION) {
-      findRelated(resolveTypeNode(node.type));
-      if (node.arguments) {
-        for (const argument of node.arguments) {
-          findRelated(argument);
-        }
-      }
-    } else if (node.kind === Kind2.NAMED_TYPE && // Named type
-    !isGraphQLPrimitive(node.name.value)) {
-      markAsUsed(node.name.value);
-    }
-  }
-  return used;
-}
-function collectObjectFieldType(node, fieldDefinition, fieldsMap, fieldTypes) {
-  const objectName = node.name.value;
-  const fieldName = fieldDefinition.name.value;
-  const field = fieldsMap[fieldDefinition.name.value];
-  const baseName = getBaseType(field.type).name;
-  const isDefaultScalar = DEFAULT_SCALARS[baseName] != null;
-  const name = isDefaultScalar ? `Types.Scalars["${baseName}"]["output"]` : baseName;
-  const type = wrapTypeWithModifiers(name, field.type, {
-    wrapOptional: (str) => {
-      return `Types.Maybe<${str}>`;
-    },
-    wrapArray: (str) => {
-      return `Array<${str}>`;
-    }
+  return `${typeName}: Baeta.TypeMethods<${parentType}, ${contextType}, ${infoType}, BaetaModuleObjectTypeFields['${typeName}']['Builder'], BaetaModuleObjectTypeFields['${typeName}']['Factory']>`;
+}
+function printBaetaModuleTypesScalars(config) {
+  return config.registry.defined.scalars.map((scalar) => `${scalar}: GraphQLScalarType`);
+}
+function printModuleObjectTypeFields(config) {
+  const objects = config.registry.defined.objects.map((typeName) => printObjectTypeFields(config, typeName, config.registry.picks.objects)).filter(Boolean);
+  return buildBlock({
+    name: "interface BaetaModuleObjectTypeFields",
+    lines: objects
   });
-  if (fieldTypes[objectName] == null) {
-    fieldTypes[objectName] = {};
+}
+function printObjectTypeFields(config, typeName, objects) {
+  const fields = objects[typeName];
+  if (!fields || fields.length === 0) {
+    return "";
   }
-  fieldTypes[objectName][fieldName] = type;
-}
-function collectObjectFieldArguments(node, fieldDefinition, fieldArguments) {
-  const objectName = node.name.value;
-  const fieldName = fieldDefinition.name.value;
-  const hasArguments = fieldDefinition.arguments != null && fieldDefinition.arguments.length > 0;
-  if (fieldArguments[objectName] == null) {
-    fieldArguments[objectName] = {};
+  const fieldsBuilders = fields.map(
+    (field) => printObjectTypeFieldBuilders(config, typeName, field)
+  );
+  const fieldsFactories = fields.map(
+    (field) => printObjectTypeFieldFactories(config, typeName, field)
+  );
+  return buildBlock({
+    name: `${typeName}:`,
+    lines: [
+      buildBlock({
+        name: "Builder:",
+        lines: fieldsBuilders
+      }),
+      buildBlock({
+        name: "Factory:",
+        lines: fieldsFactories
+      })
+    ]
+  });
+}
+function printObjectTypeFieldBuilders(config, typeName, field) {
+  const parentType = getParentType(typeName);
+  const resultType = getResultType(config, typeName, field);
+  const argumentsType = getArgsType(config, typeName, field);
+  const contextType = getContextType();
+  const infoType = getInfoType();
+  const namespace = typeName === "Subscription" ? "SubscriptionMethods" : "FieldMethods";
+  return `${field}: Baeta.${namespace}<${resultType}, ${parentType}, ${contextType}, ${argumentsType}, ${infoType}>`;
+}
+function printObjectTypeFieldFactories(config, typeName, field) {
+  const parentType = getParentType(typeName);
+  const resultType = getResultType(config, typeName, field);
+  const argumentsType = getArgsType(config, typeName, field);
+  const contextType = getContextType();
+  const infoType = getInfoType();
+  const namespace = typeName === "Subscription" ? "SubscriptionField" : "Field";
+  return `${field}: Baeta.${namespace}<${resultType}, ${resultType}, ${parentType}, ${contextType}, ${argumentsType}, ${infoType}>`;
+}
+function printModuleBuilder(config, moduleName) {
+  const objectTypes = config.registry.defined.objects.map((typeName) => printObjectTypeBuilder(typeName, config.registry.picks.objects)).filter(Boolean);
+  const builders = buildCodeBlock({
+    name: "",
+    lines: objectTypes
+  });
+  const typeNameResolvers = buildCodeBlock({
+    name: "",
+    lines: [...config.registry.defined.unions, ...config.registry.defined.interfaces].map(
+      (name) => `${name}: ${printTypeNameResolver()}`
+    )
+  });
+  const infoType = getInfoType();
+  const contextType = getContextType();
+  return [
+    `export const ${pascalCase(moduleName)}Module = Baeta.createModuleBuilder<${contextType}, ${infoType}, BaetaModuleTypes['Builders'], BaetaModuleTypes['Factories']>(moduleMetadata.id, moduleMetadata.typedef,`,
+    builders,
+    ",",
+    typeNameResolvers,
+    `, ${getExtensionsVar()});`
+  ].join("");
+}
+function printObjectTypeBuilder(typeName, objects) {
+  const fields = objects[typeName]?.map((field) => printObjectTypeFieldBuilder(typeName, field));
+  if (fields == null || fields.length === 0) {
+    return "";
   }
-  fieldArguments[objectName][fieldName] = hasArguments;
+  const content = buildCodeBlock({
+    name: "",
+    lines: fields
+  });
+  return `${typeName}: Baeta.createTypeBuilder("${typeName}",${content}, ${getExtensionsVar()})`;
 }
-function collectObjectFieldTypesAndArguments(schema) {
-  const fieldTypes = {};
-  const fieldArguments = {};
-  if (!schema) {
-    return { fieldTypes, fieldArguments };
+function printTypeNameResolver() {
+  return "{ __resolveType: (source: {__typename: string}) => { return source.__typename; }}";
+}
+function getParentType(type) {
+  if (["Query", "Mutation", "Subscription"].includes(type)) {
+    return "{}";
   }
-  const schemaTypes = schema.getTypeMap();
-  for (const type of Object.values(schemaTypes)) {
-    if (type.astNode?.kind !== Kind2.OBJECT_TYPE_DEFINITION) {
-      continue;
-    }
-    const schemaType = schemaTypes[type.name];
-    const fieldsMap = schemaType.getFields();
-    for (const field of type.astNode.fields ?? []) {
-      collectObjectFieldArguments(type.astNode, field, fieldArguments);
-      collectObjectFieldType(type.astNode, field, fieldsMap, fieldTypes);
-    }
+  return `Types.${type}`;
+}
+function getResultType(config, type, field) {
+  const fieldType = config.fieldInfo.get(type)?.get(field)?.type;
+  if (fieldType == null) {
+    return "{}";
   }
-  return { fieldTypes, fieldArguments };
+  return fieldType;
 }
-function resolveTypeNode(node) {
-  if (node.kind === Kind2.LIST_TYPE) {
-    return resolveTypeNode(node.type);
+function getArgsType(config, type, field) {
+  const hasArgs = config.fieldInfo.get(type)?.get(field)?.hasArguments ?? false;
+  if (!hasArgs) {
+    return "{}";
   }
-  if (node.kind === Kind2.NON_NULL_TYPE) {
-    return resolveTypeNode(node.type);
+  const fieldUpper = field[0].toUpperCase() + field.slice(1);
+  return `Types.${type}${fieldUpper}Args`;
+}
+function printObjectTypeFieldBuilder(typeName, field) {
+  if (typeName === "Subscription") {
+    return `${field}: Baeta.createSubscriptionBuilder("${field}", ${getExtensionsVar()})`;
   }
-  return node;
+  return `${field}: Baeta.createFieldBuilder("${typeName}", "${field}", ${getExtensionsVar()})`;
 }
-function isGraphQLPrimitive(name) {
-  return ["String", "Boolean", "ID", "Float", "Int"].includes(name);
+function getContextType() {
+  return "Ctx";
 }
-function unique(val, i, all) {
-  return i === all.indexOf(val);
+function getInfoType() {
+  return "Info";
 }
-function withQuotes(val) {
-  return `'${val}'`;
+function getExtensionsVar() {
+  return "extensions";
 }
-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;
+
+// lib/printer/printer-templates.ts
+import { relative as relative2 } from "@baeta/util-path";
+function printTypesTemplate(options) {
+  const importDir = relative2(options.modulesDir, options.typesDir);
+  return `import type { GraphQLResolveInfo } from 'graphql';
+import type { BaseObjectTypes, BaseScalars } from '${importDir}/utility${options.importExtension}';
+
+export interface Scalars extends BaseScalars {}
+
+export interface ObjectTypes extends BaseObjectTypes {}
+
+export type Ctx = {};
+
+export type Info = GraphQLResolveInfo;
+`;
 }
-function buildBlock({ name, lines }) {
-  if (!lines.length) {
-    return "";
-  }
-  return [`${name} {`, ...lines.map(indent(2)), "};"].join("\n");
+function printExtensionsTemplate() {
+  return `import { createExtensions } from '@baeta/core';
+
+export default createExtensions({});
+`;
 }
-var getRelativePath = (filepath, basePath) => {
-  const normalizedFilepath = normalize(filepath);
-  const normalizedBasePath = ensureStartsWithSeparator(
-    normalize(ensureEndsWithSeparator(basePath))
-  );
-  const [, relativePath] = normalizedFilepath.split(normalizedBasePath);
-  return relativePath;
+
+// lib/printer/printer-types.ts
+import { pascalCase as pascalCase2 } from "change-case-all";
+import {
+  Kind
+} from "graphql";
+
+// utils/scalar.ts
+function isScalarType(definitionsMap, defaultScalars, type) {
+  return definitionsMap.scalarTypeMap.has(type.name.value) || defaultScalars.includes(type.name.value);
+}
+
+// lib/printer/printer-types.ts
+function printUtilityTypes() {
+  return [
+    "export type Or<A, B> = void extends A ? B : A;",
+    "export type Maybe<T> = T | null;"
+  ].join("\n\n");
+}
+var defaultScalarTypes = {
+  ID: "string",
+  String: "string",
+  Boolean: "boolean",
+  Int: "number",
+  Float: "number"
 };
-function groupSourcesByModule(sources, basePath) {
-  const grouped = {};
-  for (const source of sources) {
-    if (!source.location) {
-      continue;
-    }
-    const relativePath = getRelativePath(source.location, basePath);
-    if (relativePath) {
-      const mod = extractModuleDirectory(source.location, basePath);
-      if (!grouped[mod]) {
-        grouped[mod] = [];
-      }
-      grouped[mod].push(source);
-    }
+function printBaseScalars(config) {
+  const defaultScalars = config.defaultScalars.map((scalar) => {
+    const type = defaultScalarTypes[scalar];
+    if (type == null) return null;
+    return `${scalar}: ${type};`;
+  }).filter((el) => el != null);
+  const customScalars = [...config.globalDefinitions.scalarTypeMap.values()].map(
+    (scalar) => `${scalar.name.value}: unknown;`
+  );
+  return buildBlock({
+    name: "export type BaseScalars =",
+    lines: [...defaultScalars, ...customScalars]
+  });
+}
+function printBaseObjectTypes(config) {
+  const objectTypes = [...config.globalDefinitions.objectTypeMap.values()].map((t) => t.name.value);
+  return buildBlock({
+    name: "export interface BaseObjectTypes",
+    lines: objectTypes.map((t) => `${t}: unknown;`)
+  });
+}
+function printTypesHeaders() {
+  return [
+    'import * as BaetaUtility from "./utility.ts";',
+    'import * as BaetaOverrides from "../modules/types.ts";',
+    "",
+    "export type Scalars = BaetaOverrides.Scalars;"
+  ].join("\n");
+}
+function printRootTypesFromMap(config, rootTypes, map) {
+  return [...map.values()].filter((type) => rootTypes.includes(type.name.value)).map((type) => printObjectType(config, type)).join("\n\n");
+}
+function printObjectTypeTypesFromMap(config, map) {
+  return [...map.values()].map((type) => printObjectType(config, type));
+}
+function printObjectType(config, type) {
+  const fields = type.fields?.map((field) => printObjectTypeField(config, field));
+  return `export type ${type.name.value} = ${printOrObjectType(type, fields)}`;
+}
+function printObjectTypeField(config, field) {
+  const optionalMarker = printOptionalMarker(config, field.type);
+  return `${field.name.value}${optionalMarker}: ${printType(config, field.type)}`;
+}
+function printEnumTypesFromMap(map) {
+  return [...map.values()].map(printEnumType);
+}
+function printEnumType(type) {
+  const values = type.values?.map((value) => `'${value.name.value}'`);
+  return `export type ${type.name.value} = ${values?.join(" | ") || "never"}`;
+}
+function printInterfaceTypesFromMap(config, map) {
+  return [...map.values()].map((type) => printInterfaceType(config, type));
+}
+function printInterfaceType(config, type) {
+  const objectTypes = Array.from(config.globalDefinitions.objectTypeMap.values());
+  const implementingTypes = objectTypes.filter(
+    (t) => t.interfaces?.some((i) => i.name.value === type.name.value)
+  );
+  const types = implementingTypes.map((t) => printNamedTypeForInterface(t.name.value));
+  return `export type ${type.name.value} = ${types.join(" | ") || "never"}`;
+}
+function printNamedTypeForInterface(name) {
+  return `${name} & {__typename: "${name}"}`;
+}
+function printUnionTypesFromMap(config, map) {
+  return [...map.values()].map((type) => printUnionType(config, type));
+}
+function printUnionType(config, type) {
+  const types = type.types?.map((type2) => printNamedTypeForUnion(config, type2));
+  return `export type ${type.name.value} = ${types?.join(" | ") || "never"}`;
+}
+function printNamedTypeForUnion(config, type) {
+  return `${printNamedType(config, type, false)} & {__typename: "${type.name.value}"}`;
+}
+function printInputObjectTypeTypesFromMap(config, map) {
+  return [...map.values()].map((type) => printInputObjectType(config, type));
+}
+function printInputObjectType(config, type) {
+  const fields = type.fields?.map((field) => printInputObjectTypeField(config, field));
+  return buildBlock({
+    name: `export type ${type.name.value} =`,
+    lines: fields ?? []
+  });
+}
+function printInputObjectTypeField(config, field) {
+  const optionalMarker = printOptionalMarker(config, field.type);
+  return `${field.name.value}${optionalMarker}: ${printType(config, field.type)}`;
+}
+function printObjectTypeFieldsArgsFromMap(config, map) {
+  return [...map.values()].flatMap((type) => printObjectTypeArgs(config, type));
+}
+function printObjectTypeArgs(config, type) {
+  if (type.fields == null) {
+    return [];
   }
-  return grouped;
+  return type.fields.map((field) => printObjectTypeFieldArgs(config, type.name.value, field)).filter(Boolean);
 }
-function extractModuleDirectory(filepath, basePath) {
-  const relativePath = getRelativePath(filepath, basePath);
-  const [moduleDirectory] = relativePath.split(sep);
-  return moduleDirectory;
+function printObjectTypeFieldArgs(config, typeName, field) {
+  const name = `${typeName + pascalCase2(field.name.value)}Args`;
+  return buildBlock({
+    name: `export type ${name} =`,
+    lines: field.arguments?.map((arg) => printObjectTypeFieldArg(config, arg)) ?? []
+  });
 }
-function stripFilename(path) {
-  const parsedPath = parse(path);
-  return normalize(parsedPath.dir);
+function printObjectTypeFieldArg(config, arg) {
+  return `${arg.name.value}: ${printType(config, arg.type)}`;
 }
-function normalize(path) {
-  return path.replace(/\\/g, "/");
+function printType(config, type, nullable = true) {
+  switch (type.kind) {
+    case Kind.NAMED_TYPE:
+      return printNamedType(config, type, nullable);
+    case Kind.LIST_TYPE:
+      return printListType(config, type, nullable);
+    case Kind.NON_NULL_TYPE:
+      return printType(config, type.type, false);
+    default:
+      return type;
+  }
 }
-function ensureEndsWithSeparator(path) {
-  return path.endsWith(sep) ? path : path + sep;
+function printListType(config, type, nullable = true) {
+  return printValue(config, `Array<${printType(config, type.type)}>`, nullable);
 }
-function ensureStartsWithSeparator(path) {
-  if (platform() === "win32") {
-    return path;
+function printNamedType(config, type, nullable = true) {
+  if (isScalarType(config.globalDefinitions, config.defaultScalars, type)) {
+    return printScalarType(config, type, nullable);
   }
-  return path.startsWith(".") ? path.replace(/^(..\/)|(.\/)/, "/") : path.startsWith("/") ? path : `/${path}`;
+  return printValue(config, type.name.value, nullable);
 }
-function pushUnique(list, item) {
-  if (!list.includes(item)) {
-    list.push(item);
+function printScalarType(config, type, nullable = true) {
+  return printValue(config, `Scalars["${type.name.value}"]`, nullable);
+}
+function printValue(config, value, nullable) {
+  if (!nullable) {
+    return value;
   }
+  if (config.withMaybe) {
+    return `BaetaUtility.Maybe<${value}>`;
+  }
+  return `${value} | null`;
 }
-function concatByKey(left, right, key) {
-  return [.../* @__PURE__ */ new Set([...left[key], ...right[key]])];
+function printOptionalMarker(config, type) {
+  return config.withOptional && type.kind !== Kind.NON_NULL_TYPE ? "?" : "";
 }
-function uniqueByKey(left, right, key) {
-  return left[key].filter((item) => !right[key].includes(item));
+function printOrObjectType(type, fields) {
+  return `BaetaUtility.Or<BaetaOverrides.ObjectTypes["${type.name.value}"], {
+${fields?.map(indent(2)).join("\n") ?? ""}
+}>`;
 }
-function createObject(keys, valueFn) {
-  const obj = {};
-  for (const key of keys) {
-    obj[key] = valueFn(key);
+
+// lib/visitors/definitions-map.ts
+import {
+  visit
+} from "graphql";
+function createRegistry() {
+  return {
+    scalarTypeMap: /* @__PURE__ */ new Map(),
+    enumTypeMap: /* @__PURE__ */ new Map(),
+    objectTypeMap: /* @__PURE__ */ new Map(),
+    inputObjectTypeMap: /* @__PURE__ */ new Map(),
+    unionTypeMap: /* @__PURE__ */ new Map(),
+    interfaceTypeMap: /* @__PURE__ */ new Map()
+  };
+}
+function createDefinitionsMapFromSources(sources) {
+  const registry = createRegistry();
+  for (const source of sources) {
+    if (source.document) {
+      collectTypesFromDocument(source.document, registry, ["Query", "Mutation", "Subscription"]);
+    }
   }
-  return obj;
+  return registry;
+}
+function createDefinitionsMapFromDocument(document) {
+  const registry = createRegistry();
+  collectTypesFromDocument(document, registry);
+  return registry;
+}
+function collectTypesFromDocument(document, registry, filterObjectTypes = []) {
+  visit(document, {
+    ScalarTypeDefinition(node) {
+      if (registry.scalarTypeMap.has(node.name.value)) {
+        throw new Error(`Scalar type ${node.name.value} already exists`);
+      }
+      registry.scalarTypeMap.set(node.name.value, node);
+    },
+    EnumTypeDefinition(node) {
+      if (registry.enumTypeMap.has(node.name.value)) {
+        throw new Error(`Enum type ${node.name.value} already exists, use 'extend' instead!`);
+      }
+      registry.enumTypeMap.set(node.name.value, node);
+    },
+    ObjectTypeDefinition(node) {
+      if (filterObjectTypes.includes(node.name.value)) {
+        return;
+      }
+      if (registry.objectTypeMap.has(node.name.value)) {
+        throw new Error(`Object type ${node.name.value} already exists, use 'extend' instead!`);
+      }
+      registry.objectTypeMap.set(node.name.value, node);
+    },
+    InputObjectTypeDefinition(node) {
+      if (registry.inputObjectTypeMap.has(node.name.value)) {
+        throw new Error(`Input type ${node.name.value} already exists. Use 'extend' instead!`);
+      }
+      registry.inputObjectTypeMap.set(node.name.value, node);
+    },
+    UnionTypeDefinition(node) {
+      if (registry.unionTypeMap.has(node.name.value)) {
+        throw new Error(`Union type ${node.name.value} already exists, use 'extend' instead!`);
+      }
+      registry.unionTypeMap.set(node.name.value, node);
+    },
+    InterfaceTypeDefinition(node) {
+      if (registry.interfaceTypeMap.has(node.name.value)) {
+        throw new Error(`Interface type ${node.name.value} already exists. Use 'extend' instead!`);
+      }
+      registry.interfaceTypeMap.set(node.name.value, node);
+    }
+  });
 }
 
-// lib/modules/builder.ts
-var registryKeys = [
-  "objects",
-  "inputs",
-  "interfaces",
-  "scalars",
-  "unions",
-  "enums"
-];
-function buildModule(name, doc, {
-  importNamespace,
-  importPath,
-  encapsulate,
-  requireRootResolvers,
-  shouldDeclare,
-  rootTypes,
-  schema,
-  baseVisitor,
-  fieldTypes,
-  fieldArguments,
-  extensionsPath
-}) {
+// lib/visitors/field-info.ts
+import { Kind as Kind2 } from "graphql";
+function createFieldInfoMap(definitionsMap, defaultScalars) {
+  const map = /* @__PURE__ */ new Map();
+  for (const objectType of definitionsMap.objectTypeMap.values()) {
+    const objectName = objectType.name.value;
+    for (const field of objectType.fields ?? []) {
+      const fieldName = field.name.value;
+      const type = printNamedType2(definitionsMap, defaultScalars, field.type, true);
+      const hasArguments = field.arguments != null && field.arguments.length > 0;
+      const fieldMap = map.get(objectName) ?? /* @__PURE__ */ new Map();
+      fieldMap.set(fieldName, { type, hasArguments });
+      map.set(objectName, fieldMap);
+    }
+  }
+  return map;
+}
+function printNamedType2(definitionsMap, defaultScalars, type, nullable = true) {
+  const withNullable = nullable ? " | null" : "";
+  switch (type.kind) {
+    case Kind2.NAMED_TYPE:
+      if (isScalarType(definitionsMap, defaultScalars, type)) {
+        return `Types.Scalars["${type.name.value}"]${withNullable}`;
+      }
+      return `Types.${type.name.value}${withNullable}`;
+    case Kind2.LIST_TYPE:
+      return `Array<${printNamedType2(definitionsMap, defaultScalars, type.type, nullable)}>${withNullable}`;
+    case Kind2.NON_NULL_TYPE:
+      return printNamedType2(definitionsMap, defaultScalars, type.type, false);
+    default:
+      return type;
+  }
+}
+
+// lib/visitors/module-registry.ts
+import {
+  visit as visit2
+} from "graphql";
+var registryKeys = ["objects", "interfaces", "unions", "scalars"];
+function createModuleRegistry(document) {
   const picks = createObject(
     registryKeys,
     () => ({})
   );
   const defined = createObject(registryKeys, () => []);
-  const extended = createObject(registryKeys, () => []);
-  const hashes = {};
-  const usedTypes = collectUsedTypes(doc);
-  visit(doc, {
+  visit2(document, {
     ObjectTypeDefinition(node) {
-      collectTypeDefinition(node);
+      defined.objects.push(node.name.value);
+      collectFields(node, picks.objects);
     },
     ObjectTypeExtension(node) {
-      collectTypeExtension(node);
-    },
-    InputObjectTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    InputObjectTypeExtension(node) {
-      collectTypeExtension(node);
+      pushUnique(defined.objects, node.name.value);
+      collectFields(node, picks.objects);
     },
     InterfaceTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    InterfaceTypeExtension(node) {
-      collectTypeExtension(node);
-    },
-    ScalarTypeDefinition(node) {
-      collectTypeDefinition(node);
+      defined.interfaces.push(node.name.value);
+      collectFields(node, picks.interfaces);
     },
     UnionTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    UnionTypeExtension(node) {
-      collectTypeExtension(node);
-    },
-    EnumTypeDefinition(node) {
-      collectTypeDefinition(node);
+      defined.unions.push(node.name.value);
+      collectUnionTypes(node, picks);
     },
-    EnumTypeExtension(node) {
-      collectTypeExtension(node);
+    ScalarTypeDefinition(node) {
+      defined.scalars.push(node.name.value);
     }
   });
-  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 type { DocumentNode } from "graphql";',
-    'import * as Baeta from "@baeta/core/sdk";'
-  ];
-  if (extensionsPath) {
-    imports.push(`import baetaExtensions from "${extensionsPath}";`);
-  }
-  imports.push("\n");
-  let content = [
-    printDefinedFields(),
-    printDefinedEnumValues(),
-    printDefinedInputFields(),
-    printSchemaTypes(usedTypes),
-    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 hashes = ${JSON.stringify(hashes)};
-  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`;
-    const extensionsArg = extensionsPath ? ", baetaExtensions" : "";
-    return `
-export const ${createModuleFn} = () => Baeta.createModuleManager(ModuleMetadata${extensionsArg});
-export const ${getModuleFn} = Baeta.createSingletonModule(${createModuleFn});
-`;
-  }
-  function printObjectFieldResolverBuilder(typeName, field) {
-    const parentType = getParentType(typeName);
-    const resultType = getResultType(typeName, field);
-    const argumentsType = getArgsType(typeName, field);
-    const contextType = getContextType();
-    return `${field}: module.createResolverBuilder<${resultType}, ${parentType}, ${contextType}, ${argumentsType}>("${typeName}", "${field}"),`;
-  }
-  function printObjectResolverBuilder(typeName, objects) {
-    const fields = objects[typeName]?.filter(unique).map((field) => printObjectFieldResolverBuilder(typeName, field)) ?? [];
-    if (fields.length === 0) {
-      return "";
-    }
-    const parentType = getParentType(typeName);
-    const contextType = getContextType();
-    const addons = [`...module.createTypeMethods<${parentType}, ${contextType}>("${typeName}"),`];
-    const contentBody = [...addons, ...fields].map(indent(2)).join("\n");
-    const content2 = `{
-${contentBody}
-}`;
-    return `${typeName}: ${content2},`;
-  }
-  function printSubscriptionFieldBuilder(field) {
-    const parentType = getParentType("Subscription");
-    const resultType = getResultType("Subscription", field);
-    const argumentsType = getArgsType("Subscription", field);
-    const contextType = getContextType();
-    return `${field}: module.createSubscriptionBuilder<${resultType}, ${parentType}, ${contextType}, ${argumentsType}>("${field}"),`;
-  }
-  function printSubscriptionObjectBuilder() {
-    const subscriptions = picks.objects.Subscription?.filter(unique) ?? [];
-    if (subscriptions.length === 0) {
-      return "";
-    }
-    const fields = subscriptions.map((subscription) => printSubscriptionFieldBuilder(subscription));
-    const parentType = getParentType("Subscription");
-    const contextType = getContextType();
-    const addons = [`...module.createSubscriptionMethods<${parentType}, ${contextType}>(),`];
-    const contentBody = [...addons, ...fields].map(indent(2)).join("\n");
-    const content2 = `{
-${contentBody}
-}`;
-    return `Subscription: ${content2},`;
-  }
-  function printScalarBuilder() {
-    const scalars = visited.scalars;
-    if (scalars.length === 0) {
-      return "";
-    }
-    const fields = scalars.map((scalar) => `${scalar}: module.createScalarBuilder("${scalar}"),`);
-    const content2 = fields.map(indent(2)).join("\n");
-    return `Scalar: {
-${content2}
-},`;
-  }
-  function printTypenameResolverBuilder(name2, resultNamespace, valueNamespace) {
-    const resultType = `${importNamespace}.${resultNamespace}["${name2}"]`;
-    const valueType = `${importNamespace}.${valueNamespace}["${name2}"]`;
-    const contextType = getContextType();
-    const resolver = `$resolveType: module.createResolveType<${resultType}, ${valueType}, ${contextType}>("${name2}"),`;
-    return `${name2}: {
-${indent(2)(resolver)}
-},`;
-  }
-  function printInterfaceBuilder() {
-    const interfaces = defined.interfaces;
-    if (interfaces.length === 0) {
-      return "";
-    }
-    return interfaces.map(
-      (interfaceName) => printTypenameResolverBuilder(
-        interfaceName,
-        "DefinedInterfacesResults",
-        "DefinedInterfacesWithoutExtensions"
-      )
-    ).join("\n");
-  }
-  function printUnionBuilder() {
-    const unions = defined.unions;
-    if (unions.length === 0) {
-      return "";
-    }
-    return unions.map(
-      (unionName) => printTypenameResolverBuilder(
-        unionName,
-        "DefinedUnionsResults",
-        "DefinedUnionsWithoutExtensions"
-      )
-    ).join("\n");
-  }
-  function printBaetaManager() {
-    const objects = visited.objects.filter((type) => type !== "Subscription").map((typeName) => printObjectResolverBuilder(typeName, picks.objects)).filter(Boolean);
-    const contextType = getContextType();
-    const addons = [`...module.createModuleMethods<${contextType}>(),`];
-    const bodyFields = [
-      ...addons,
-      ...objects,
-      printScalarBuilder(),
-      printSubscriptionObjectBuilder(),
-      printInterfaceBuilder(),
-      printUnionBuilder()
-    ];
-    const body = bodyFields.filter(Boolean).map(indent(6)).join("\n");
-    const content2 = `{
-${body}
-    }`;
-    return `
-  export function createManager(module: Baeta.ModuleBuilder) {
-    return ${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 printPicks(typeName, records) {
-    return records[typeName].filter(unique).map(withQuotes).join(" | ");
-  }
-  function printTypeBody(typeName) {
-    const normalizedTypeName = baseVisitor.convertName(typeName, {
-      useTypesSuffix: true,
-      useTypesPrefix: true
-    });
-    const coreType = `${importNamespace}.${normalizedTypeName}`;
-    if (external.enums.includes(typeName) || external.objects.includes(typeName)) {
-      if (schema && isScalarType(schema.getType(typeName))) {
-        return `${importNamespace}.Scalars['${typeName}']`;
-      }
-      return `Pick<${coreType}, ${importNamespace}.DefinedFieldsWithoutExtensions["${typeName}"]>`;
-    }
-    if (external.unions.includes(typeName)) {
-      return `${importNamespace}.DefinedUnionsWithoutExtensions["${typeName}"]`;
-    }
-    if (external.interfaces.includes(typeName)) {
-      return `Pick<${coreType}, ${importNamespace}.DefinedFieldsWithoutExtensions["${typeName}"]>`;
-    }
-    if (defined.enums.includes(typeName) && picks.enums[typeName]) {
-      return `DefinedEnumValues['${typeName}']`;
-    }
-    if (defined.unions.includes(typeName) && picks.unions[typeName]) {
-      return `${importNamespace}.DefinedUnionsWithoutExtensions["${typeName}"]`;
-    }
-    if (defined.objects.includes(typeName) && picks.objects[typeName]) {
-      return `Pick<${coreType}, DefinedFields['${typeName}']>`;
-    }
-    if (defined.interfaces.includes(typeName) && picks.interfaces[typeName]) {
-      return `${importNamespace}.DefinedInterfacesWithoutExtensions["${typeName}"]`;
-    }
-    if (defined.inputs.includes(typeName) && picks.inputs[typeName]) {
-      return `Pick<${coreType}, DefinedInputFields['${typeName}']>`;
-    }
-    if (isScalarType(schema?.getType(typeName))) {
-      return coreType;
-    }
-    if (isInterfaceType(schema?.getType(typeName))) {
-      return `${importNamespace}.DefinedInterfacesWithoutExtensions["${typeName}"]`;
-    }
-    if (isUnionType(schema?.getType(typeName))) {
-      return `${importNamespace}.DefinedUnionsWithoutExtensions["${typeName}"]`;
-    }
-    return `Pick<${coreType}, ${importNamespace}.DefinedFieldsWithoutExtensions["${typeName}"]>`;
-  }
-  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] = [];
-      }
-      for (const field of node.fields) {
-        picksObj[name2].push(field.name.value);
-      }
-    }
-  }
-  function collectValuesFromEnum(node) {
-    const name2 = node.name.value;
-    if (node.values) {
-      if (!picks.enums[name2]) {
-        picks.enums[name2] = [];
-      }
-      for (const field of node.values) {
-        picks.enums[name2].push(field.name.value);
-      }
-    }
-  }
-  function collectUnionTypes(node) {
-    const name2 = node.name.value;
-    if (node.types) {
-      if (!picks.unions[name2]) {
-        picks.unions[name2] = [];
-      }
-      for (const type of node.types) {
-        picks.unions[name2].push(type.name.value);
-      }
-    }
-  }
-  function collectTypeDefinition(node) {
-    const name2 = node.name.value;
-    switch (node.kind) {
-      case Kind3.OBJECT_TYPE_DEFINITION: {
-        defined.objects.push(name2);
-        collectFields(node, picks.objects);
-        hashes[name2] = getObjectTypeHash(node);
-        break;
-      }
-      case Kind3.ENUM_TYPE_DEFINITION: {
-        defined.enums.push(name2);
-        collectValuesFromEnum(node);
-        break;
-      }
-      case Kind3.INPUT_OBJECT_TYPE_DEFINITION: {
-        defined.inputs.push(name2);
-        collectFields(node, picks.inputs);
-        break;
-      }
-      case Kind3.SCALAR_TYPE_DEFINITION: {
-        defined.scalars.push(name2);
-        break;
-      }
-      case Kind3.INTERFACE_TYPE_DEFINITION: {
-        defined.interfaces.push(name2);
-        collectFields(node, picks.interfaces);
-        break;
-      }
-      case Kind3.UNION_TYPE_DEFINITION: {
-        defined.unions.push(name2);
-        collectUnionTypes(node);
-        break;
-      }
+  return {
+    defined,
+    picks
+  };
+}
+function collectFields(node, picksObj) {
+  const name = node.name.value;
+  if (node.fields) {
+    if (!picksObj[name]) {
+      picksObj[name] = [];
     }
-  }
-  function collectTypeExtension(node) {
-    const name2 = node.name.value;
-    switch (node.kind) {
-      case Kind3.OBJECT_TYPE_EXTENSION: {
-        collectFields(node, picks.objects);
-        hashes[name2] = getObjectTypeHash(node);
-        if (rootTypes.includes(name2)) {
-          pushUnique(defined.objects, name2);
-          return;
-        }
-        pushUnique(extended.objects, name2);
-        break;
-      }
-      case Kind3.ENUM_TYPE_EXTENSION: {
-        collectValuesFromEnum(node);
-        pushUnique(extended.enums, name2);
-        break;
-      }
-      case Kind3.INPUT_OBJECT_TYPE_EXTENSION: {
-        collectFields(node, picks.inputs);
-        pushUnique(extended.inputs, name2);
-        break;
-      }
-      case Kind3.INTERFACE_TYPE_EXTENSION: {
-        collectFields(node, picks.interfaces);
-        pushUnique(extended.interfaces, name2);
-        break;
-      }
-      case Kind3.UNION_TYPE_EXTENSION: {
-        pushUnique(extended.unions, name2);
-        break;
-      }
+    for (const field of node.fields) {
+      picksObj[name].push(field.name.value);
     }
   }
-  function getParentType(type) {
-    if (["Query", "Mutation", "Subscription"].includes(type)) {
-      return "{ }";
+}
+function collectUnionTypes(node, picks) {
+  const name = node.name.value;
+  if (node.types) {
+    if (!picks.unions[name]) {
+      picks.unions[name] = [];
     }
-    return type;
-  }
-  function getResultType(type, field) {
-    return fieldTypes?.[type]?.[field] || "{ }";
-  }
-  function getArgsType(type, field) {
-    const hasArgs = fieldArguments?.[type]?.[field] ?? false;
-    if (!hasArgs) {
-      return "{ }";
+    for (const type of node.types) {
+      picks.unions[name].push(type.name.value);
     }
-    const fieldUpper = field[0].toUpperCase() + field.slice(1);
-    return `Types.${type}${fieldUpper}Args`;
   }
-  function getContextType() {
-    return "Types.ContextType";
+}
+function pushUnique(list, item) {
+  if (!list.includes(item)) {
+    list.push(item);
   }
 }
-
-// lib/modules/index.ts
-var preset = {
-  buildGeneratesSection: (options) => {
-    const { baseOutputDir } = options;
-    const { baseTypesPath, extensionsPath, encapsulateModuleTypes, importExtension } = options.presetConfig;
-    const requireRootResolvers = getConfigValue(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?.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 BaseVisitor(options.config, {});
-    const { fieldTypes, fieldArguments } = collectObjectFieldTypesAndArguments(options.schemaAst);
-    const baseOutput = {
-      filename: resolve(cwd, baseOutputDir, baseTypesPath),
-      schema: options.schema,
-      documents: options.documents,
-      plugins: [
-        ...options.plugins,
-        {
-          "modules-exported-scalars": {}
-        },
-        {
-          "modules-exported-picks": {}
-        }
-      ],
-      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");
-          }
-        },
-        "modules-exported-picks": {
-          plugin: (schema) => {
-            const typePicks = [];
-            const unionPicks = [];
-            const unionResults = [];
-            const interfacePicks = [];
-            const interfaceResults = [];
-            const unionTypesMap = {};
-            const interfacesTypesMap = {};
-            for (const moduleName of modules) {
-              const sources2 = sourcesByModuleMap[moduleName];
-              const documents = sources2.map((source) => source.document);
-              const moduleDocument = concatAST(documents);
-              const types = moduleDocument.definitions.filter(
-                (def) => def.kind === "ObjectTypeDefinition"
-              );
-              const unionsDefinition2 = moduleDocument.definitions.filter(
-                (def) => def.kind === "UnionTypeDefinition"
-              );
-              const unionsExtensions = moduleDocument.definitions.filter(
-                (def) => def.kind === "UnionTypeExtension"
-              );
-              const unions = [...unionsDefinition2, ...unionsExtensions];
-              for (const type of types) {
-                const name = type.name.value;
-                for (const interfaceNode of type.interfaces ?? []) {
-                  const interfaceName = interfaceNode.name.value;
-                  if (interfacesTypesMap[interfaceName] == null) {
-                    interfacesTypesMap[interfaceName] = [];
-                  }
-                  interfacesTypesMap[interfaceName]?.push(name);
-                }
-                if (name === "Query" || name === "Mutation" || name === "Subscription") {
-                  continue;
-                }
-                const fields = type.fields ?? [];
-                if (fields.length === 0) {
-                  continue;
-                }
-                const fieldNames = fields.map((f) => `"${f.name.value}"`).join(" | ");
-                typePicks.push(`  ${name}: ${fieldNames};`);
-              }
-              for (const union of unions) {
-                const types2 = union.types?.map((t) => t.name.value) ?? [];
-                if (unionTypesMap[union.name.value] == null) {
-                  unionTypesMap[union.name.value] = [];
-                }
-                unionTypesMap[union.name.value]?.push(...types2);
-              }
-            }
-            for (const unionName in unionTypesMap) {
-              const types = unionTypesMap[unionName];
-              if (types == null || types.length === 0) {
-                unionPicks.push(`  ${unionName}: never;`);
-                unionResults.push(`  ${unionName}: null;`);
-                continue;
-              }
-              const typePicks2 = types.map((t) => {
-                const normalizedTypeName = baseVisitor.convertName(t, {
-                  useTypesSuffix: true,
-                  useTypesPrefix: true
-                });
-                return `Pick<${normalizedTypeName}, DefinedFieldsWithoutExtensions["${t}"] | "__typename">`;
-              });
-              const resultPicks = types.map((t) => `"${t}"`);
-              unionPicks.push(`  ${unionName}: ${typePicks2.join(" | ")};`);
-              unionResults.push(`  ${unionName}: ${resultPicks.join(" | ")} | null;`);
-            }
-            for (const interfaceName in interfacesTypesMap) {
-              const types = interfacesTypesMap[interfaceName];
-              if (types == null || types.length === 0) {
-                interfacePicks.push(`  ${interfaceName}: never;`);
-                interfaceResults.push(`  ${interfaceName}: null;`);
-                continue;
-              }
-              const typePicks2 = types.map((t) => {
-                const normalizedTypeName = baseVisitor.convertName(t, {
-                  useTypesSuffix: true,
-                  useTypesPrefix: true
-                });
-                return `Pick<${normalizedTypeName}, DefinedFieldsWithoutExtensions["${t}"] | "__typename">`;
-              });
-              const resultPicks = types.map((t) => `"${t}"`);
-              interfacePicks.push(`  ${interfaceName}: ${typePicks2.join(" | ")};`);
-              interfaceResults.push(`  ${interfaceName}: ${resultPicks.join(" | ")} | null;`);
-            }
-            const fieldsDefinition = `export type DefinedFieldsWithoutExtensions = {
-${typePicks.join("\n")}
-};`;
-            const unionsDefinition = `export type DefinedUnionsWithoutExtensions = {
-${unionPicks.join("\n")}
-};`;
-            const unionsResultsDefinition = `export type DefinedUnionsResults = {
-${unionResults.join("\n")}
-};`;
-            const interfacesDefinition = `export type DefinedInterfacesWithoutExtensions = {
-${interfacePicks.join("\n")}
-};`;
-            const interfacesResultsDefinition = `export type DefinedInterfacesResults = {
-${interfaceResults.join(
-              "\n"
-            )}
-};`;
-            const result = [
-              fieldsDefinition,
-              unionsDefinition,
-              unionsResultsDefinition,
-              interfacesDefinition,
-              interfacesResultsDefinition
-            ].join("\n\n");
-            return `
-${result}
-`;
-          }
-        }
-      },
-      config: {
-        ...options.config,
-        enumsAsTypes: true
-      },
-      schemaAst: options.schemaAst
-    };
-    const baseTypesFilename = basename(baseTypesPath).replace(/\.(js|ts|d.ts)$/, "") + (importExtension || "");
-    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 = relative2(dirpath, baseTypesDir);
-      const importPath = options.presetConfig.importBaseTypesFrom || normalize(join(relativePath, baseTypesFilename));
-      const sources2 = sourcesByModuleMap[moduleName];
-      const documents = sources2.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) => buildModule(moduleName, moduleDocument, {
-              importNamespace: importTypesNamespace,
-              importPath,
-              encapsulate: encapsulateModuleTypes || "namespace",
-              requireRootResolvers,
-              shouldDeclare,
-              schema,
-              baseVisitor,
-              useGraphQLModules: false,
-              fieldTypes,
-              fieldArguments,
-              extensionsPath,
-              rootTypes: [
-                schema.getQueryType()?.name || "",
-                schema.getMutationType()?.name || "",
-                schema.getSubscriptionType()?.name || ""
-              ].filter(Boolean)
-            })
-          }
-        },
-        config: options.config,
-        schemaAst: options.schemaAst
-      };
-    });
-    return [baseOutput].concat(outputs);
+function createObject(keys, valueFn) {
+  const obj = {};
+  for (const key of keys) {
+    obj[key] = valueFn(key);
   }
-};
+  return obj;
+}
 
 // lib/codegen.ts
 async function generate(options) {
-  const rootConfig = {
-    schemas: normalizeInstanceOrArray(options.schemas),
-    modulesDir: options.modulesDir,
-    baseTypesPath: options.baseTypesPath,
-    contextType: options.contextType,
-    moduleDefinitionName: options.moduleDefinitionName,
-    scalars: options.scalars,
-    plugins: normalizeConfig(["typescript", "context"]),
-    pluginMap: {
-      typescript: typescriptPlugin,
-      context: context_exports
-    }
+  const { outputSchema, outputSchemaAst } = await loadSchema(
+    options.schemas,
+    options.cwd,
+    options.loaders
+  );
+  const sources = getSourcesFromSchema(outputSchemaAst);
+  const sourcesByModule = groupSourcesByModule(sources, options.modulesDir);
+  const modules = Array.from(sourcesByModule.keys());
+  const globalDefinitions = createDefinitionsMapFromDocument(outputSchema);
+  const modulesDefinitions = createDefinitionsMapFromSources(sources);
+  const defaultScalars = ["ID", "Int", "Float", "String", "Boolean"];
+  const config = {
+    globalDefinitions,
+    withMaybe: false,
+    withOptional: false,
+    defaultScalars
   };
-  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 hash2 = JSON.stringify(schemaPointerMap);
-  const result = await cache("schema", hash2, async () => {
-    return loadSchema(schemaPointerMap, options.cwd, options.loaders);
-  });
-  const outputs = await preset.buildGeneratesSection({
-    baseOutputDir: options.modulesDir,
-    presetConfig: {
-      baseTypesPath: rootConfig.baseTypesPath,
-      filename: rootConfig.moduleDefinitionName,
-      encapsulateModuleTypes: "none",
-      extensionsPath: options.extensions,
-      importExtension: options.importExtension
+  const fieldInfo = createFieldInfoMap(globalDefinitions, defaultScalars);
+  const typesContent = [
+    printTypesHeaders(),
+    printRootTypesFromMap(
+      config,
+      ["Query", "Mutation", "Subscription"],
+      globalDefinitions.objectTypeMap
+    ),
+    ...printEnumTypesFromMap(globalDefinitions.enumTypeMap),
+    ...printObjectTypeTypesFromMap(config, modulesDefinitions.objectTypeMap),
+    ...printObjectTypeFieldsArgsFromMap(config, globalDefinitions.objectTypeMap),
+    ...printInputObjectTypeTypesFromMap(config, globalDefinitions.inputObjectTypeMap),
+    ...printInterfaceTypesFromMap(config, globalDefinitions.interfaceTypeMap),
+    ...printUnionTypesFromMap(config, globalDefinitions.unionTypeMap)
+  ].join("\n\n");
+  const utilityContent = [
+    printUtilityTypes(),
+    printBaseScalars(config),
+    printBaseObjectTypes(config)
+  ].join("\n\n");
+  const files = [
+    {
+      filename: join2(options.typesDir, "types.ts"),
+      content: typesContent
     },
-    schema: result.outputSchema,
-    schemaAst: result.outputSchemaAst,
-    documents: [],
-    pluginMap: rootConfig.pluginMap,
-    plugins: rootConfig.plugins,
-    config: {
-      inputMaybeValue: "T | undefined",
-      contextType: rootConfig.contextType,
-      useTypeImports: true,
-      scalars: buildScalarMap(
-        rootConfig.scalars,
-        options.cwd,
-        join2(options.modulesDir, options.baseTypesPath)
-      )
+    {
+      filename: join2(options.typesDir, "utility.ts"),
+      content: utilityContent
+    },
+    {
+      filename: join2(options.modulesDir, "index.ts"),
+      content: printAutoload({ importExtension: options.importExtension }, modules)
+    },
+    {
+      filename: join2(options.modulesDir, "types.ts"),
+      content: printTypesTemplate({
+        importExtension: options.importExtension,
+        typesDir: options.typesDir,
+        modulesDir: options.modulesDir
+      }),
+      options: {
+        allowOverwrite: false,
+        disableBiomeHeader: true,
+        disableEslintHeader: true,
+        disableGenerationNoticeHeader: true
+      }
+    },
+    {
+      filename: join2(options.modulesDir, "extensions.ts"),
+      content: printExtensionsTemplate(),
+      options: {
+        allowOverwrite: false,
+        disableBiomeHeader: true,
+        disableEslintHeader: true,
+        disableGenerationNoticeHeader: true
+      }
     }
-  });
-  const promises = outputs.map(async (output) => {
-    const result2 = await gqlCodegen({
-      ...output,
-      cache
-    });
-    return {
-      filename: output.filename,
-      content: result2
+  ];
+  for (const module of modules) {
+    const sources2 = sourcesByModule.get(module);
+    const documents = sources2?.map((s) => s.document).filter((el) => el != null) ?? [];
+    if (documents.length === 0) continue;
+    const document = concatAST(documents);
+    const config2 = {
+      typesDir: options.typesDir,
+      fieldInfo,
+      importExtension: options.importExtension,
+      modulesDir: options.modulesDir,
+      registry: createModuleRegistry(document)
     };
-  });
-  return Promise.all(promises);
+    files.push({
+      filename: `src/modules/${module}/${options.moduleDefinitionName}`,
+      content: [
+        printModuleImports(config2, module),
+        printModuleMetadata(module, document),
+        printBaetaModuleTypes(config2),
+        printModuleObjectTypeFields(config2),
+        printModuleBuilder(config2, module)
+      ].join("\n\n")
+    });
+  }
+  return files;
 }
 
 // index.ts
@@ -1168,7 +798,7 @@ function graphqlPlugin() {
     generate: async (ctx, next) => {
       const items = await generate(ctx.generatorOptions);
       for (const item of items) {
-        ctx.fileManager.createAndAdd(item.filename, item.content, "graphql");
+        ctx.fileManager.createAndAdd(item.filename, item.content, "graphql", item.options);
       }
       return next();
     }