@baeta/plugin-graphql 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -1,1180 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// index.ts
-var _generatorsdk = require('@baeta/generator-sdk');
-
-// lib/codegen.ts
-var _utilpath = require('@baeta/util-path');
-var _core = require('@graphql-codegen/core');
-var _pluginhelpers = require('@graphql-codegen/plugin-helpers');
-var _typescript = require('@graphql-codegen/typescript'); var typescriptPlugin = _interopRequireWildcard(_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;
-  };
-}
-
-// utils/load.ts
-
-var _graphqlfileloader = require('@graphql-tools/graphql-file-loader');
-
-
-var _load = require('@graphql-tools/load');
-var _graphql = require('graphql');
-
-// utils/hash.ts
-var _crypto = require('crypto');
-
-
-function hashContent(content) {
-  return _crypto.createHash.call(void 0, "sha256").update(content).digest("hex");
-}
-function hashSchema(schema) {
-  return hashContent(_graphql.print.call(void 0, _pluginhelpers.getCachedDocumentNodeFromSchema.call(void 0, schema)));
-}
-
-// utils/load.ts
-async function loadSchema(schemaPointerMap, cwd, extraLoaders = []) {
-  const outputSchemaAst = await _load.loadSchema.call(void 0, schemaPointerMap, {
-    loaders: [new (0, _graphqlfileloader.GraphQLFileLoader)(), ...extraLoaders],
-    cwd,
-    includeSources: true
-  });
-  const errors = _graphql.validateSchema.call(void 0, outputSchemaAst);
-  if (errors.length > 0) {
-    const messages = errors.map((e) => e.toString()).join("\n\n--------------------\n\n");
-    const subject = errors.length === 1 ? "error" : "errors";
-    throw new Error(`Invalid schema. Found ${errors.length} ${subject}:
-
-${messages}`);
-  }
-  if (!outputSchemaAst.extensions) {
-    outputSchemaAst.extensions = {};
-  }
-  outputSchemaAst.extensions.hash = hashSchema(outputSchemaAst);
-  return {
-    outputSchemaAst,
-    outputSchema: _pluginhelpers.getCachedDocumentNodeFromSchema.call(void 0, outputSchemaAst)
-  };
-}
-
-// utils/scalars.ts
-
-var _visitorplugincommon = require('@graphql-codegen/visitor-plugin-common');
-function buildScalarMap(map, cwd, typesPath) {
-  if (!map) {
-    return {};
-  }
-  const fixedMap = {};
-  for (const key in map) {
-    const mapped = _visitorplugincommon.parseMapper.call(void 0, map[key]);
-    if (!mapped.isExternal) {
-      fixedMap[key] = map[key];
-      continue;
-    }
-    if (_utilpath.isAbsolute.call(void 0, mapped.source)) {
-      fixedMap[key] = map[key];
-      continue;
-    }
-    const scalarPath = _utilpath.joinSafe.call(void 0, cwd, mapped.source);
-    const relativePath = _utilpath.relative.call(void 0, _utilpath.dirname.call(void 0, typesPath), scalarPath);
-    if (mapped.default) {
-      fixedMap[key] = `${relativePath}#default`;
-      continue;
-    }
-    fixedMap[key] = `${relativePath}#${mapped.import}`;
-  }
-  return fixedMap;
-}
-
-// lib/context/index.ts
-var context_exports = {};
-__export(context_exports, {
-  default: () => context_default,
-  plugin: () => plugin
-});
-
-var plugin = async (schema, documents, config) => {
-  const prepend = [];
-  const mapper = _visitorplugincommon.parseMapper.call(void 0, config.contextType || "any");
-  if (mapper.isExternal && mapper.source) {
-    const identifier = mapper.default ? "ContextType" : `${mapper.import} as ContextType`;
-    const result = _visitorplugincommon.buildMapperImport.call(void 0, 
-      mapper.source,
-      [
-        {
-          identifier,
-          asDefault: mapper.default
-        }
-      ],
-      true
-    );
-    if (result) {
-      prepend.push(result);
-    }
-  } else {
-    prepend.push(`type ContextType = ${mapper.type}`);
-  }
-  prepend.push("export type { ContextType }");
-  return {
-    content: "",
-    prepend
-  };
-};
-var context_default = { plugin };
-
-// lib/modules/index.ts
-
-
-
-
-
-
-
-// lib/modules/builder.ts
-var _changecaseall = require('change-case-all');
-
-
-
-
-
-
-
-
-// lib/modules/hashes.ts
-
-
-
-var _murmurhash = require('murmurhash'); var _murmurhash2 = _interopRequireDefault(_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] = _murmurhash2.default.v3(fieldType).toString(36);
-  }
-  return {
-    hash: _murmurhash2.default.v3(typeFields).toString(36),
-    fieldsHashes: fieldMap
-  };
-}
-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 buildTypeName(node) {
-  if (node.kind === _graphql.Kind.NAMED_TYPE) {
-    return node.name.value;
-  }
-  if (node.kind === _graphql.Kind.LIST_TYPE) {
-    return `[${buildTypeName(node.type)}]`;
-  }
-  if (node.kind === _graphql.Kind.NON_NULL_TYPE) {
-    return `${buildTypeName(node.type)}!`;
-  }
-  return "";
-}
-
-// lib/modules/utils.ts
-var _os = require('os');
-
-
-
-
-
-var _parsefilepath = require('parse-filepath'); var _parsefilepath2 = _interopRequireDefault(_parsefilepath);
-var sep = "/";
-function collectUsedTypes(doc) {
-  const used = [];
-  for (const definition of doc.definitions) {
-    findRelated(definition);
-  }
-  function markAsUsed(type) {
-    pushUnique(used, type);
-  }
-  function findRelated(node) {
-    if (node.kind === _graphql.Kind.OBJECT_TYPE_DEFINITION || node.kind === _graphql.Kind.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 === _graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION || node.kind === _graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
-      markAsUsed(node.name.value);
-      if (node.fields) {
-        for (const field of node.fields) {
-          findRelated(field);
-        }
-      }
-    } else if (node.kind === _graphql.Kind.INTERFACE_TYPE_DEFINITION || node.kind === _graphql.Kind.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 === _graphql.Kind.UNION_TYPE_DEFINITION || node.kind === _graphql.Kind.UNION_TYPE_EXTENSION) {
-      markAsUsed(node.name.value);
-      if (node.types) {
-        for (const type of node.types) {
-          findRelated(type);
-        }
-      }
-    } else if (node.kind === _graphql.Kind.ENUM_TYPE_DEFINITION || node.kind === _graphql.Kind.ENUM_TYPE_EXTENSION) {
-      markAsUsed(node.name.value);
-    } else if (node.kind === _graphql.Kind.SCALAR_TYPE_DEFINITION || node.kind === _graphql.Kind.SCALAR_TYPE_EXTENSION) {
-      if (!isGraphQLPrimitive(node.name.value)) {
-        markAsUsed(node.name.value);
-      }
-    } else if (node.kind === _graphql.Kind.INPUT_VALUE_DEFINITION) {
-      findRelated(resolveTypeNode(node.type));
-    } else if (node.kind === _graphql.Kind.FIELD_DEFINITION) {
-      findRelated(resolveTypeNode(node.type));
-      if (node.arguments) {
-        for (const argument of node.arguments) {
-          findRelated(argument);
-        }
-      }
-    } else if (node.kind === _graphql.Kind.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 = _pluginhelpers.getBaseType.call(void 0, field.type).name;
-  const isDefaultScalar = _visitorplugincommon.DEFAULT_SCALARS[baseName] != null;
-  const name = isDefaultScalar ? `Types.Scalars["${baseName}"]["output"]` : baseName;
-  const type = _visitorplugincommon.wrapTypeWithModifiers.call(void 0, name, field.type, {
-    wrapOptional: (str) => {
-      return `Types.Maybe<${str}>`;
-    },
-    wrapArray: (str) => {
-      return `Array<${str}>`;
-    }
-  });
-  if (fieldTypes[objectName] == null) {
-    fieldTypes[objectName] = {};
-  }
-  fieldTypes[objectName][fieldName] = type;
-}
-function collectObjectFieldArguments(node, fieldDefinition, fieldArguments) {
-  const objectName = node.name.value;
-  const fieldName = fieldDefinition.name.value;
-  const hasArguments = fieldDefinition.arguments != null && fieldDefinition.arguments.length > 0;
-  if (fieldArguments[objectName] == null) {
-    fieldArguments[objectName] = {};
-  }
-  fieldArguments[objectName][fieldName] = hasArguments;
-}
-function collectObjectFieldTypesAndArguments(schema) {
-  const fieldTypes = {};
-  const fieldArguments = {};
-  if (!schema) {
-    return { fieldTypes, fieldArguments };
-  }
-  const schemaTypes = schema.getTypeMap();
-  for (const type of Object.values(schemaTypes)) {
-    if (_optionalChain([type, 'access', _ => _.astNode, 'optionalAccess', _2 => _2.kind]) !== _graphql.Kind.OBJECT_TYPE_DEFINITION) {
-      continue;
-    }
-    const schemaType = schemaTypes[type.name];
-    const fieldsMap = schemaType.getFields();
-    for (const field of _nullishCoalesce(type.astNode.fields, () => ( []))) {
-      collectObjectFieldArguments(type.astNode, field, fieldArguments);
-      collectObjectFieldType(type.astNode, field, fieldsMap, fieldTypes);
-    }
-  }
-  return { fieldTypes, fieldArguments };
-}
-function resolveTypeNode(node) {
-  if (node.kind === _graphql.Kind.LIST_TYPE) {
-    return resolveTypeNode(node.type);
-  }
-  if (node.kind === _graphql.Kind.NON_NULL_TYPE) {
-    return resolveTypeNode(node.type);
-  }
-  return node;
-}
-function isGraphQLPrimitive(name) {
-  return ["String", "Boolean", "ID", "Float", "Int"].includes(name);
-}
-function unique(val, i, all) {
-  return i === all.indexOf(val);
-}
-function withQuotes(val) {
-  return `'${val}'`;
-}
-function indent(size) {
-  const space = new Array(size).fill(" ").join("");
-  function indentInner(val) {
-    return val.split("\n").map((line) => `${space}${line}`).join("\n");
-  }
-  return indentInner;
-}
-function buildBlock({ name, lines }) {
-  if (!lines.length) {
-    return "";
-  }
-  return [`${name} {`, ...lines.map(indent(2)), "};"].join("\n");
-}
-var getRelativePath = (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 = {};
-  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);
-    }
-  }
-  return grouped;
-}
-function extractModuleDirectory(filepath, basePath) {
-  const relativePath = getRelativePath(filepath, basePath);
-  const [moduleDirectory] = relativePath.split(sep);
-  return moduleDirectory;
-}
-function stripFilename(path) {
-  const parsedPath = _parsefilepath2.default.call(void 0, path);
-  return normalize(parsedPath.dir);
-}
-function normalize(path) {
-  return path.replace(/\\/g, "/");
-}
-function ensureEndsWithSeparator(path) {
-  return path.endsWith(sep) ? path : path + sep;
-}
-function ensureStartsWithSeparator(path) {
-  if (_os.platform.call(void 0, ) === "win32") {
-    return path;
-  }
-  return path.startsWith(".") ? path.replace(/^(..\/)|(.\/)/, "/") : path.startsWith("/") ? path : `/${path}`;
-}
-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 = {};
-  for (const key of keys) {
-    obj[key] = valueFn(key);
-  }
-  return obj;
-}
-
-// 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
-}) {
-  const picks = createObject(
-    registryKeys,
-    () => ({})
-  );
-  const defined = createObject(registryKeys, () => []);
-  const extended = createObject(registryKeys, () => []);
-  const hashes = {};
-  const usedTypes = collectUsedTypes(doc);
-  _graphql.visit.call(void 0, 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 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 = _nullishCoalesce(_optionalChain([objects, 'access', _3 => _3[typeName], 'optionalAccess', _4 => _4.filter, 'call', _5 => _5(unique), 'access', _6 => _6.map, 'call', _7 => _7((field) => printObjectFieldResolverBuilder(typeName, field))]), () => ( []));
-    if (fields.length === 0) {
-      return "";
-    }
-    const 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 = _nullishCoalesce(_optionalChain([picks, 'access', _8 => _8.objects, 'access', _9 => _9.Subscription, 'optionalAccess', _10 => _10.filter, 'call', _11 => _11(unique)]), () => ( []));
-    if (subscriptions.length === 0) {
-      return "";
-    }
-    const fields = subscriptions.map((subscription) => printSubscriptionFieldBuilder(subscription));
-    const 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 `${_changecaseall.pascalCase.call(void 0, 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 && _graphql.isScalarType.call(void 0, 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 (_graphql.isScalarType.call(void 0, _optionalChain([schema, 'optionalAccess', _12 => _12.getType, 'call', _13 => _13(typeName)]))) {
-      return coreType;
-    }
-    if (_graphql.isInterfaceType.call(void 0, _optionalChain([schema, 'optionalAccess', _14 => _14.getType, 'call', _15 => _15(typeName)]))) {
-      return `${importNamespace}.DefinedInterfacesWithoutExtensions["${typeName}"]`;
-    }
-    if (_graphql.isUnionType.call(void 0, _optionalChain([schema, 'optionalAccess', _16 => _16.getType, 'call', _17 => _17(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 _graphql.Kind.OBJECT_TYPE_DEFINITION: {
-        defined.objects.push(name2);
-        collectFields(node, picks.objects);
-        hashes[name2] = getObjectTypeHash(node);
-        break;
-      }
-      case _graphql.Kind.ENUM_TYPE_DEFINITION: {
-        defined.enums.push(name2);
-        collectValuesFromEnum(node);
-        break;
-      }
-      case _graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION: {
-        defined.inputs.push(name2);
-        collectFields(node, picks.inputs);
-        break;
-      }
-      case _graphql.Kind.SCALAR_TYPE_DEFINITION: {
-        defined.scalars.push(name2);
-        break;
-      }
-      case _graphql.Kind.INTERFACE_TYPE_DEFINITION: {
-        defined.interfaces.push(name2);
-        collectFields(node, picks.interfaces);
-        break;
-      }
-      case _graphql.Kind.UNION_TYPE_DEFINITION: {
-        defined.unions.push(name2);
-        collectUnionTypes(node);
-        break;
-      }
-    }
-  }
-  function collectTypeExtension(node) {
-    const name2 = node.name.value;
-    switch (node.kind) {
-      case _graphql.Kind.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 _graphql.Kind.ENUM_TYPE_EXTENSION: {
-        collectValuesFromEnum(node);
-        pushUnique(extended.enums, name2);
-        break;
-      }
-      case _graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION: {
-        collectFields(node, picks.inputs);
-        pushUnique(extended.inputs, name2);
-        break;
-      }
-      case _graphql.Kind.INTERFACE_TYPE_EXTENSION: {
-        collectFields(node, picks.interfaces);
-        pushUnique(extended.interfaces, name2);
-        break;
-      }
-      case _graphql.Kind.UNION_TYPE_EXTENSION: {
-        pushUnique(extended.unions, name2);
-        break;
-      }
-    }
-  }
-  function getParentType(type) {
-    if (["Query", "Mutation", "Subscription"].includes(type)) {
-      return "{ }";
-    }
-    return type;
-  }
-  function getResultType(type, field) {
-    return _optionalChain([fieldTypes, 'optionalAccess', _18 => _18[type], 'optionalAccess', _19 => _19[field]]) || "{ }";
-  }
-  function getArgsType(type, field) {
-    const hasArgs = _nullishCoalesce(_optionalChain([fieldArguments, 'optionalAccess', _20 => _20[type], 'optionalAccess', _21 => _21[field]]), () => ( false));
-    if (!hasArgs) {
-      return "{ }";
-    }
-    const fieldUpper = field[0].toUpperCase() + field.slice(1);
-    return `Types.${type}${fieldUpper}Args`;
-  }
-  function getContextType() {
-    return "Types.ContextType";
-  }
-}
-
-// lib/modules/index.ts
-var preset = {
-  buildGeneratesSection: (options) => {
-    const { baseOutputDir } = options;
-    const { baseTypesPath, extensionsPath, encapsulateModuleTypes, importExtension } = options.presetConfig;
-    const requireRootResolvers = _visitorplugincommon.getConfigValue.call(void 0, _optionalChain([options, 'optionalAccess', _22 => _22.presetConfig, 'access', _23 => _23.requireRootResolvers]), false);
-    const cwd = _utilpath.resolve.call(void 0, options.presetConfig.cwd || process.cwd());
-    const importTypesNamespace = options.presetConfig.importTypesNamespace || "Types";
-    if (!baseTypesPath) {
-      throw new Error(
-        `Preset "graphql-modules" requires you to specify "baseTypesPath" configuration and point it to your base types file (generated by "typescript" plugin)!`
-      );
-    }
-    if (!_optionalChain([options, 'access', _24 => _24.schemaAst, 'optionalAccess', _25 => _25.extensions, 'access', _26 => _26.sources])) {
-      throw new Error(`Preset "graphql-modules" requires to use GraphQL SDL`);
-    }
-    const extensions = _optionalChain([options, 'access', _27 => _27.schemaAst, 'optionalAccess', _28 => _28.extensions]);
-    const sources = _nullishCoalesce(_optionalChain([extensions, 'optionalAccess', _29 => _29.extendedSources]), () => ( []));
-    const sourcesByModuleMap = groupSourcesByModule(sources, baseOutputDir);
-    const modules = Object.keys(sourcesByModuleMap);
-    const baseVisitor = new (0, _visitorplugincommon.BaseVisitor)(options.config, {});
-    const { fieldTypes, fieldArguments } = collectObjectFieldTypesAndArguments(options.schemaAst);
-    const baseOutput = {
-      filename: _utilpath.resolve.call(void 0, 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] && _graphql.isScalarType.call(void 0, 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 = _graphql.concatAST.call(void 0, 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 _nullishCoalesce(type.interfaces, () => ( []))) {
-                  const interfaceName = interfaceNode.name.value;
-                  if (interfacesTypesMap[interfaceName] == null) {
-                    interfacesTypesMap[interfaceName] = [];
-                  }
-                  _optionalChain([interfacesTypesMap, 'access', _30 => _30[interfaceName], 'optionalAccess', _31 => _31.push, 'call', _32 => _32(name)]);
-                }
-                if (name === "Query" || name === "Mutation" || name === "Subscription") {
-                  continue;
-                }
-                const fields = _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([union, 'access', _33 => _33.types, 'optionalAccess', _34 => _34.map, 'call', _35 => _35((t) => t.name.value)]), () => ( []));
-                if (unionTypesMap[union.name.value] == null) {
-                  unionTypesMap[union.name.value] = [];
-                }
-                _optionalChain([unionTypesMap, 'access', _36 => _36[union.name.value], 'optionalAccess', _37 => _37.push, 'call', _38 => _38(...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 = _utilpath.basename.call(void 0, baseTypesPath).replace(/\.(js|ts|d.ts)$/, "") + (importExtension || "");
-    const baseTypesDir = stripFilename(baseOutput.filename);
-    const outputs = modules.map((moduleName) => {
-      const filename = _utilpath.resolve.call(void 0, cwd, baseOutputDir, moduleName, options.presetConfig.filename);
-      const dirpath = stripFilename(filename);
-      const relativePath = _utilpath.relative.call(void 0, dirpath, baseTypesDir);
-      const importPath = options.presetConfig.importBaseTypesFrom || normalize(_utilpath.join.call(void 0, relativePath, baseTypesFilename));
-      const sources2 = sourcesByModuleMap[moduleName];
-      const documents = sources2.map((source) => source.document);
-      const moduleDocument = _graphql.concatAST.call(void 0, 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: [
-                _optionalChain([schema, 'access', _39 => _39.getQueryType, 'call', _40 => _40(), 'optionalAccess', _41 => _41.name]) || "",
-                _optionalChain([schema, 'access', _42 => _42.getMutationType, 'call', _43 => _43(), 'optionalAccess', _44 => _44.name]) || "",
-                _optionalChain([schema, 'access', _45 => _45.getSubscriptionType, 'call', _46 => _46(), 'optionalAccess', _47 => _47.name]) || ""
-              ].filter(Boolean)
-            })
-          }
-        },
-        config: options.config,
-        schemaAst: options.schemaAst
-      };
-    });
-    return [baseOutput].concat(outputs);
-  }
-};
-
-// lib/codegen.ts
-async function generate(options) {
-  const rootConfig = {
-    schemas: _pluginhelpers.normalizeInstanceOrArray.call(void 0, options.schemas),
-    modulesDir: options.modulesDir,
-    baseTypesPath: options.baseTypesPath,
-    contextType: options.contextType,
-    moduleDefinitionName: options.moduleDefinitionName,
-    scalars: options.scalars,
-    plugins: _pluginhelpers.normalizeConfig.call(void 0, ["typescript", "context"]),
-    pluginMap: {
-      typescript: typescriptPlugin,
-      context: context_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 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
-    },
-    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,
-        _utilpath.join.call(void 0, options.modulesDir, options.baseTypesPath)
-      )
-    }
-  });
-  const promises = outputs.map(async (output) => {
-    const result2 = await _core.codegen.call(void 0, {
-      ...output,
-      cache
-    });
-    return {
-      filename: output.filename,
-      content: result2
-    };
-  });
-  return Promise.all(promises);
-}
-
-// index.ts
-function graphqlPlugin() {
-  return _generatorsdk.createPluginV1.call(void 0, {
-    name: "graphql",
-    actionName: "GraphQL modules",
-    watch: (options, watcher, reload) => {
-      const handleChange = (file) => {
-        if (_generatorsdk.isMatch.call(void 0, file.relativePath, options.schemas)) {
-          reload(file);
-        }
-      };
-      watcher.on("update", handleChange);
-      watcher.on("delete", handleChange);
-    },
-    generate: async (ctx, next) => {
-      const items = await generate(ctx.generatorOptions);
-      for (const item of items) {
-        ctx.fileManager.createAndAdd(item.filename, item.content, "graphql");
-      }
-      return next();
-    }
-  });
-}
-
-
-exports.graphqlPlugin = graphqlPlugin;
-//# sourceMappingURL=index.cjs.map