@baeta/plugin-graphql 0.0.0-57-20230619210342-5073d33

package/dist/index.cjs

@@ -0,0 +1,891 @@
+"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 _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 _apolloengineloader = require('@graphql-tools/apollo-engine-loader');
+var _codefileloader = require('@graphql-tools/code-file-loader');
+var _gitloader = require('@graphql-tools/git-loader');
+var _githubloader = require('@graphql-tools/github-loader');
+var _graphqlfileloader = require('@graphql-tools/graphql-file-loader');
+var _jsonfileloader = require('@graphql-tools/json-file-loader');
+var _load = require('@graphql-tools/load');
+var _prismaloader = require('@graphql-tools/prisma-loader');
+var _urlloader = require('@graphql-tools/url-loader');
+
+// utils/hash.ts
+
+var _graphql = require('graphql');
+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) {
+  const outputSchemaAst = await _load.loadSchema.call(void 0, schemaPointerMap, {
+    loaders: [
+      new (0, _codefileloader.CodeFileLoader)(),
+      new (0, _gitloader.GitLoader)(),
+      new (0, _githubloader.GithubLoader)(),
+      new (0, _graphqlfileloader.GraphQLFileLoader)(),
+      new (0, _jsonfileloader.JsonFileLoader)(),
+      new (0, _urlloader.UrlLoader)(),
+      new (0, _apolloengineloader.ApolloEngineLoader)(),
+      new (0, _prismaloader.PrismaLoader)()
+    ],
+    cwd,
+    includeSources: true
+  });
+  if (!outputSchemaAst.extensions) {
+    outputSchemaAst.extensions = {};
+  }
+  outputSchemaAst.extensions["hash"] = hashSchema(outputSchemaAst);
+  return {
+    outputSchemaAst,
+    outputSchema: _pluginhelpers.getCachedDocumentNodeFromSchema.call(void 0, outputSchemaAst)
+  };
+}
+
+// lib/context/index.ts
+var context_exports = {};
+__export(context_exports, {
+  default: () => context_default,
+  plugin: () => plugin
+});
+var _visitorplugincommon = require('@graphql-codegen/visitor-plugin-common');
+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
+
+
+var _path = require('path');
+
+// lib/modules/builder.ts
+var _changecaseall = require('change-case-all');
+
+
+
+
+
+
+// lib/modules/utils.ts
+
+
+
+
+
+var _parsefilepath = require('parse-filepath'); var _parsefilepath2 = _interopRequireDefault(_parsefilepath);
+var sep = "/";
+function collectUsedTypes(doc) {
+  const used = [];
+  doc.definitions.forEach(findRelated);
+  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) {
+        node.fields.forEach(findRelated);
+      }
+      if (node.interfaces) {
+        node.interfaces.forEach(findRelated);
+      }
+    } 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) {
+        node.fields.forEach(findRelated);
+      }
+    } else if (node.kind === _graphql.Kind.INTERFACE_TYPE_DEFINITION || node.kind === _graphql.Kind.INTERFACE_TYPE_EXTENSION) {
+      markAsUsed(node.name.value);
+      if (node.fields) {
+        node.fields.forEach(findRelated);
+      }
+      if (node.interfaces) {
+        node.interfaces.forEach(findRelated);
+      }
+    } else if (node.kind === _graphql.Kind.UNION_TYPE_DEFINITION || node.kind === _graphql.Kind.UNION_TYPE_EXTENSION) {
+      markAsUsed(node.name.value);
+      if (node.types) {
+        node.types.forEach(findRelated);
+      }
+    } 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) {
+        node.arguments.forEach(findRelated);
+      }
+    } 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}"]` : 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 = function(filepath, basePath) {
+  const normalizedFilepath = normalize(filepath);
+  const normalizedBasePath = ensureStartsWithSeparator(
+    normalize(ensureEndsWithSeparator(basePath))
+  );
+  const [, relativePath] = normalizedFilepath.split(normalizedBasePath);
+  return relativePath;
+};
+function groupSourcesByModule(sources, basePath) {
+  const grouped = {};
+  sources.forEach((source) => {
+    if (!source.location) {
+      return;
+    }
+    const relativePath = getRelativePath(source.location, basePath);
+    if (relativePath) {
+      const mod = extractModuleDirectory(source.location, basePath);
+      if (!grouped[mod]) {
+        grouped[mod] = [];
+      }
+      grouped[mod].push(source);
+    }
+  });
+  return grouped;
+}
+function extractModuleDirectory(filepath, basePath) {
+  const relativePath = getRelativePath(filepath, basePath);
+  const [moduleDirectory] = relativePath.split(sep);
+  return moduleDirectory;
+}
+function stripFilename(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) {
+  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 = {};
+  keys.forEach((key) => {
+    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 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 { 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 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 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()
+    ];
+    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 coreType = `${importNamespace}.${baseVisitor.convertName(typeName, {
+      useTypesSuffix: true,
+      useTypesPrefix: true
+    })}`;
+    if (external.enums.includes(typeName) || external.objects.includes(typeName)) {
+      if (schema && _graphql.isScalarType.call(void 0, schema.getType(typeName))) {
+        return `${importNamespace}.Scalars['${typeName}']`;
+      }
+      return coreType;
+    }
+    if (defined.enums.includes(typeName) && picks.enums[typeName]) {
+      return `DefinedEnumValues['${typeName}']`;
+    }
+    if (defined.objects.includes(typeName) && picks.objects[typeName]) {
+      return `Pick<${coreType}, DefinedFields['${typeName}']>`;
+    }
+    if (defined.interfaces.includes(typeName) && picks.interfaces[typeName]) {
+      return `Pick<${coreType}, DefinedFields['${typeName}']>`;
+    }
+    if (defined.inputs.includes(typeName) && picks.inputs[typeName]) {
+      return `Pick<${coreType}, DefinedInputFields['${typeName}']>`;
+    }
+    return coreType;
+  }
+  function printExportType(typeName) {
+    return `export type ${encapsulateTypeName(typeName)} = ${printTypeBody(typeName)};`;
+  }
+  function collectFields(node, picksObj) {
+    const name2 = node.name.value;
+    if (node.fields) {
+      if (!picksObj[name2]) {
+        picksObj[name2] = [];
+      }
+      node.fields.forEach((field) => {
+        picksObj[name2].push(field.name.value);
+      });
+    }
+  }
+  function collectValuesFromEnum(node) {
+    const name2 = node.name.value;
+    if (node.values) {
+      if (!picks.enums[name2]) {
+        picks.enums[name2] = [];
+      }
+      node.values.forEach((field) => {
+        picks.enums[name2].push(field.name.value);
+      });
+    }
+  }
+  function collectTypeDefinition(node) {
+    const name2 = node.name.value;
+    switch (node.kind) {
+      case _graphql.Kind.OBJECT_TYPE_DEFINITION: {
+        defined.objects.push(name2);
+        collectFields(node, picks.objects);
+        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);
+        break;
+      }
+    }
+  }
+  function collectTypeExtension(node) {
+    const name2 = node.name.value;
+    switch (node.kind) {
+      case _graphql.Kind.OBJECT_TYPE_EXTENSION: {
+        collectFields(node, picks.objects);
+        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', _12 => _12[type], 'optionalAccess', _13 => _13[field]]) || "{}";
+  }
+  function getArgsType(type, field) {
+    const hasArgs = _nullishCoalesce(_optionalChain([fieldArguments, 'optionalAccess', _14 => _14[type], 'optionalAccess', _15 => _15[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 } = options.presetConfig;
+    const requireRootResolvers = _visitorplugincommon.getConfigValue.call(void 0, _optionalChain([options, 'optionalAccess', _16 => _16.presetConfig, 'access', _17 => _17.requireRootResolvers]), false);
+    const cwd = _path.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', _18 => _18.schemaAst, 'optionalAccess', _19 => _19.extensions, 'access', _20 => _20.sources])) {
+      throw new Error(`Preset "graphql-modules" requires to use GraphQL SDL`);
+    }
+    const extensions = _optionalChain([options, 'access', _21 => _21.schemaAst, 'optionalAccess', _22 => _22.extensions]);
+    const sources = _nullishCoalesce(_optionalChain([extensions, 'optionalAccess', _23 => _23.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: _path.resolve.call(void 0, cwd, baseOutputDir, baseTypesPath),
+      schema: options.schema,
+      documents: options.documents,
+      plugins: [
+        ...options.plugins,
+        {
+          "modules-exported-scalars": {}
+        }
+      ],
+      pluginMap: {
+        ...options.pluginMap,
+        "modules-exported-scalars": {
+          plugin: (schema) => {
+            const typeMap = schema.getTypeMap();
+            return Object.keys(typeMap).map((t) => {
+              if (t && typeMap[t] && _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");
+          }
+        }
+      },
+      config: {
+        ...options.config,
+        enumsAsTypes: true
+      },
+      schemaAst: options.schemaAst
+    };
+    const baseTypesFilename = baseTypesPath.replace(/\.(js|ts|d.ts)$/, "");
+    const baseTypesDir = stripFilename(baseOutput.filename);
+    const outputs = modules.map((moduleName) => {
+      const filename = _path.resolve.call(void 0, cwd, baseOutputDir, moduleName, options.presetConfig.filename);
+      const dirpath = stripFilename(filename);
+      const relativePath = _path.relative.call(void 0, dirpath, baseTypesDir);
+      const importPath = options.presetConfig.importBaseTypesFrom || normalize(_path.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', _24 => _24.getQueryType, 'call', _25 => _25(), 'optionalAccess', _26 => _26.name]) || "",
+                _optionalChain([schema, 'access', _27 => _27.getMutationType, 'call', _28 => _28(), 'optionalAccess', _29 => _29.name]) || "",
+                _optionalChain([schema, 'access', _30 => _30.getSubscriptionType, 'call', _31 => _31(), 'optionalAccess', _32 => _32.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 hash = JSON.stringify(schemaPointerMap);
+  const result = await cache("schema", hash, async () => {
+    return loadSchema(schemaPointerMap, options.cwd);
+  });
+  const outputs = await preset.buildGeneratesSection({
+    baseOutputDir: options.modulesDir,
+    presetConfig: {
+      baseTypesPath: rootConfig.baseTypesPath,
+      filename: rootConfig.moduleDefinitionName,
+      encapsulateModuleTypes: "none",
+      extensionsPath: options.extensions
+    },
+    schema: result.outputSchema,
+    schemaAst: result.outputSchemaAst,
+    documents: [],
+    pluginMap: rootConfig.pluginMap,
+    plugins: rootConfig.plugins,
+    config: {
+      inputMaybeValue: "T | undefined",
+      contextType: rootConfig.contextType,
+      useTypeImports: true,
+      scalars: {
+        ...rootConfig.scalars
+      }
+    }
+  });
+  const promises = outputs.map(async (output) => {
+    const result2 = await _core.codegen.call(void 0, {
+      ...output,
+      cache
+    });
+    return new (0, _generatorsdk.File)(output.filename, result2, "graphql");
+  });
+  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 files = await generate(ctx.generatorOptions);
+      ctx.fileManager.add(...files);
+      return next();
+    }
+  });
+}
+
+
+exports.graphqlPlugin = graphqlPlugin;
+//# sourceMappingURL=index.cjs.map