@baeta/plugin-graphql 0.0.2 → 0.0.4

package/dist/modules/builder.mjs

@@ -1,429 +0,0 @@
-import {
-  visit,
-  Kind,
-  isScalarType
-} from "graphql";
-import { pascalCase } from "change-case-all";
-import {
-  unique,
-  withQuotes,
-  buildBlock,
-  pushUnique,
-  concatByKey,
-  uniqueByKey,
-  createObject,
-  collectUsedTypes,
-  indent
-} from "./utils";
-const registryKeys = [
-  "objects",
-  "inputs",
-  "interfaces",
-  "scalars",
-  "unions",
-  "enums"
-];
-const resolverKeys = ["scalars", "objects", "enums"];
-function buildModule(name, doc, {
-  importNamespace,
-  importPath,
-  encapsulate,
-  requireRootResolvers,
-  shouldDeclare,
-  rootTypes,
-  schema,
-  baseVisitor
-}) {
-  const picks = createObject(
-    registryKeys,
-    () => ({})
-  );
-  const defined = createObject(registryKeys, () => []);
-  const extended = createObject(registryKeys, () => []);
-  const usedTypes = collectUsedTypes(doc);
-  visit(doc, {
-    ObjectTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    ObjectTypeExtension(node) {
-      collectTypeExtension(node);
-    },
-    InputObjectTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    InputObjectTypeExtension(node) {
-      collectTypeExtension(node);
-    },
-    InterfaceTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    InterfaceTypeExtension(node) {
-      collectTypeExtension(node);
-    },
-    ScalarTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    UnionTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    UnionTypeExtension(node) {
-      collectTypeExtension(node);
-    },
-    EnumTypeDefinition(node) {
-      collectTypeDefinition(node);
-    },
-    EnumTypeExtension(node) {
-      collectTypeExtension(node);
-    }
-  });
-  const visited = createObject(
-    registryKeys,
-    (key) => concatByKey(defined, extended, key)
-  );
-  const external = createObject(
-    registryKeys,
-    (key) => uniqueByKey(extended, defined, key)
-  );
-  const imports = [
-    `import * as ${importNamespace} from "${importPath}";`,
-    'import { DocumentNode } from "graphql";',
-    'import * as Baeta from "@baeta/core/sdk";'
-  ];
-  let content = [
-    printDefinedFields(),
-    printDefinedEnumValues(),
-    printDefinedInputFields(),
-    printSchemaTypes(usedTypes),
-    printScalars(visited),
-    printResolveSignaturesPerType(visited),
-    printResolversType(visited),
-    printMetadata()
-  ].filter(Boolean).join("\n\n");
-  const moduleNamespace = baseVisitor.convertName(name, {
-    suffix: "Module",
-    useTypesPrefix: false,
-    useTypesSuffix: false
-  });
-  if (encapsulate === "namespace") {
-    content = `${shouldDeclare ? "declare" : "export"} namespace ${baseVisitor.convertName(name, {
-      suffix: "Module",
-      useTypesPrefix: false,
-      useTypesSuffix: false
-    })} {
-` + (shouldDeclare ? `${indent(2)(imports.join("\n"))}
-` : "") + indent(2)(content) + "\n}";
-  }
-  return [...!shouldDeclare ? imports : [], content, printFactoryMethod()].filter(Boolean).join("\n");
-  function printMetadata() {
-    return `export namespace ModuleMetadata {
-  export const id = '${name}';
-  export const dirname = __dirname;
-  export const typedef = ${JSON.stringify(doc)} as unknown as DocumentNode;
-  ${printBaetaManager()}
-}`;
-  }
-  function printDefinedFields() {
-    return buildBlock({
-      name: `interface DefinedFields`,
-      lines: [...visited.objects, ...visited.interfaces].map(
-        (typeName) => `${typeName}: ${printPicks(typeName, {
-          ...picks.objects,
-          ...picks.interfaces
-        })};`
-      )
-    });
-  }
-  function printFactoryMethod() {
-    const name2 = moduleNamespace.slice(0, moduleNamespace.length - 6);
-    const createModuleFn = `create${name2}Module`;
-    const getModuleFn = `get${name2}Module`;
-    return `
-export const ${createModuleFn} = () => Baeta.createModule(ModuleMetadata);
-export const ${getModuleFn} = Baeta.createSingletonModule(${createModuleFn});
-`;
-  }
-  function printObjectFieldResolverBuilder(typeName, field) {
-    const resolverType = `${typeName}Resolvers["${field}"]`;
-    return `${field}: Baeta.createResolverBuilder<NonNullable<${resolverType}>>("${typeName}", "${field}", options),`;
-  }
-  function printObjectResolverBuilder(typeName, objects) {
-    var _a;
-    const fields = ((_a = objects[typeName]) == null ? void 0 : _a.filter(unique).map((field) => printObjectFieldResolverBuilder(typeName, field))) ?? [];
-    if (fields.length === 0) {
-      return "";
-    }
-    const resolversType = `${typeName}Resolvers`;
-    const content2 = `{
-${fields.map(indent(2)).join("\n")}
-}`;
-    return `${typeName}: Baeta.createResolversBuilder("${typeName}", options, {} as ${resolversType}, ${content2}),`;
-  }
-  function printSubscriptionFieldBuilder(field) {
-    const resolverType = `SubscriptionResolvers["${field}"]`;
-    return `${field}: Baeta.createSubscriptionBuilder<${resolverType}>("${field}", options),`;
-  }
-  function printSubscriptionObjectBuilder() {
-    var _a;
-    const subscriptions = ((_a = picks.objects["Subscription"]) == null ? void 0 : _a.filter(unique)) ?? [];
-    if (subscriptions.length === 0) {
-      return "";
-    }
-    const fields = subscriptions.map(
-      (subscription) => printSubscriptionFieldBuilder(subscription)
-    );
-    const resolversType = `SubscriptionResolvers`;
-    const content2 = `{
-${fields.map(indent(2)).join("\n")}
-}`;
-    return `Subscription: Baeta.createSubscriptionsBuilder(options, {} as ${resolversType}, ${content2}),`;
-  }
-  function printScalarBuilder() {
-    const scalars = visited.scalars;
-    if (scalars.length === 0) {
-      return "";
-    }
-    const fields = scalars.map(
-      (scalar) => `${scalar}: Baeta.createScalarBuilder("${scalar}", options),`
-    );
-    const content2 = fields.map(indent(2)).join("\n");
-    return `Scalar: {
-${content2}
-},`;
-  }
-  function printBaetaManager() {
-    const objects = visited.objects.filter((type) => type !== "Subscription").map((typeName) => printObjectResolverBuilder(typeName, picks.objects)).filter(Boolean);
-    const bodyFields = [
-      ...objects,
-      printScalarBuilder(),
-      printSubscriptionObjectBuilder()
-    ];
-    const body = bodyFields.filter(Boolean).map(indent(6)).join("\n");
-    const content2 = `{
-${body}
-    }`;
-    return `
-  export function createManager(options: Baeta.ManagerOptions) {
-    return Baeta.createManager(options, {}, ${content2});
-  }`;
-  }
-  function printDefinedEnumValues() {
-    return buildBlock({
-      name: `interface DefinedEnumValues`,
-      lines: visited.enums.map(
-        (typeName) => `${typeName}: ${printPicks(typeName, picks.enums)};`
-      )
-    });
-  }
-  function encapsulateTypeName(typeName) {
-    if (encapsulate === "prefix") {
-      return `${pascalCase(name)}_${typeName}`;
-    }
-    return typeName;
-  }
-  function printDefinedInputFields() {
-    return buildBlock({
-      name: `interface DefinedInputFields`,
-      lines: visited.inputs.map(
-        (typeName) => `${typeName}: ${printPicks(typeName, picks.inputs)};`
-      )
-    });
-  }
-  function printSchemaTypes(types) {
-    return types.filter((type) => !visited.scalars.includes(type)).map(printExportType).join("\n");
-  }
-  function printResolveSignaturesPerType(registry) {
-    return [
-      [...registry.objects, ...registry.interfaces].map(
-        (name2) => printResolverType(
-          name2,
-          "DefinedFields",
-          requireRootResolvers && rootTypes.includes(name2),
-          !rootTypes.includes(name2) && defined.objects.includes(name2) ? ` | '__isTypeOf'` : ""
-        )
-      ).join("\n")
-    ].join("\n");
-  }
-  function printScalars(registry) {
-    if (!registry.scalars.length) {
-      return "";
-    }
-    return [
-      `export type ${encapsulateTypeName(
-        "Scalars"
-      )} = Pick<${importNamespace}.Scalars, ${registry.scalars.map(withQuotes).join(" | ")}>;`,
-      ...registry.scalars.map((scalar) => {
-        const convertedName = baseVisitor.convertName(scalar, {
-          suffix: "ScalarConfig"
-        });
-        return `export type ${encapsulateTypeName(
-          convertedName
-        )} = ${importNamespace}.${convertedName};`;
-      })
-    ].join("\n");
-  }
-  function printResolversType(registry) {
-    const lines = [];
-    for (const kind in registry) {
-      const k = kind;
-      if (registry.hasOwnProperty(k) && resolverKeys.includes(k)) {
-        const types = registry[k];
-        types.forEach((typeName) => {
-          if (k === "enums") {
-            return;
-          }
-          if (k === "scalars") {
-            lines.push(
-              `${typeName}?: ${encapsulateTypeName(
-                importNamespace
-              )}.Resolvers['${typeName}'];`
-            );
-          } else {
-            const fieldModifier = requireRootResolvers && rootTypes.includes(typeName) ? "" : "?";
-            lines.push(
-              `${typeName}${fieldModifier}: ${encapsulateTypeName(
-                typeName
-              )}Resolvers;`
-            );
-          }
-        });
-      }
-    }
-    return buildBlock({
-      name: `export interface ${encapsulateTypeName("Resolvers")}`,
-      lines
-    });
-  }
-  function printResolverType(typeName, picksTypeName, requireFieldsResolvers = false, extraKeys = "") {
-    const typeSignature = `Pick<${importNamespace}.${baseVisitor.convertName(
-      typeName,
-      {
-        suffix: "Resolvers"
-      }
-    )}, ${picksTypeName}['${typeName}']${extraKeys}>`;
-    return `export type ${encapsulateTypeName(`${typeName}Resolvers`)} = ${requireFieldsResolvers ? `Required<${typeSignature}>` : typeSignature};`;
-  }
-  function printPicks(typeName, records) {
-    return records[typeName].filter(unique).map(withQuotes).join(" | ");
-  }
-  function printTypeBody(typeName) {
-    const coreType = `${importNamespace}.${baseVisitor.convertName(typeName, {
-      useTypesSuffix: true,
-      useTypesPrefix: true
-    })}`;
-    if (external.enums.includes(typeName) || external.objects.includes(typeName)) {
-      if (schema && isScalarType(schema.getType(typeName))) {
-        return `${importNamespace}.Scalars['${typeName}']`;
-      }
-      return coreType;
-    }
-    if (defined.enums.includes(typeName) && picks.enums[typeName]) {
-      return `DefinedEnumValues['${typeName}']`;
-    }
-    if (defined.objects.includes(typeName) && picks.objects[typeName]) {
-      return `Pick<${coreType}, DefinedFields['${typeName}']>`;
-    }
-    if (defined.interfaces.includes(typeName) && picks.interfaces[typeName]) {
-      return `Pick<${coreType}, DefinedFields['${typeName}']>`;
-    }
-    if (defined.inputs.includes(typeName) && picks.inputs[typeName]) {
-      return `Pick<${coreType}, DefinedInputFields['${typeName}']>`;
-    }
-    return coreType;
-  }
-  function printExportType(typeName) {
-    return `export type ${encapsulateTypeName(typeName)} = ${printTypeBody(
-      typeName
-    )};`;
-  }
-  function collectFields(node, picksObj) {
-    const name2 = node.name.value;
-    if (node.fields) {
-      if (!picksObj[name2]) {
-        picksObj[name2] = [];
-      }
-      node.fields.forEach((field) => {
-        picksObj[name2].push(field.name.value);
-      });
-    }
-  }
-  function collectValuesFromEnum(node) {
-    const name2 = node.name.value;
-    if (node.values) {
-      if (!picks.enums[name2]) {
-        picks.enums[name2] = [];
-      }
-      node.values.forEach((field) => {
-        picks.enums[name2].push(field.name.value);
-      });
-    }
-  }
-  function collectTypeDefinition(node) {
-    const name2 = node.name.value;
-    switch (node.kind) {
-      case Kind.OBJECT_TYPE_DEFINITION: {
-        defined.objects.push(name2);
-        collectFields(node, picks.objects);
-        break;
-      }
-      case Kind.ENUM_TYPE_DEFINITION: {
-        defined.enums.push(name2);
-        collectValuesFromEnum(node);
-        break;
-      }
-      case Kind.INPUT_OBJECT_TYPE_DEFINITION: {
-        defined.inputs.push(name2);
-        collectFields(node, picks.inputs);
-        break;
-      }
-      case Kind.SCALAR_TYPE_DEFINITION: {
-        defined.scalars.push(name2);
-        break;
-      }
-      case Kind.INTERFACE_TYPE_DEFINITION: {
-        defined.interfaces.push(name2);
-        collectFields(node, picks.interfaces);
-        break;
-      }
-      case Kind.UNION_TYPE_DEFINITION: {
-        defined.unions.push(name2);
-        break;
-      }
-    }
-  }
-  function collectTypeExtension(node) {
-    const name2 = node.name.value;
-    switch (node.kind) {
-      case Kind.OBJECT_TYPE_EXTENSION: {
-        collectFields(node, picks.objects);
-        if (rootTypes.includes(name2)) {
-          pushUnique(defined.objects, name2);
-          return;
-        }
-        pushUnique(extended.objects, name2);
-        break;
-      }
-      case Kind.ENUM_TYPE_EXTENSION: {
-        collectValuesFromEnum(node);
-        pushUnique(extended.enums, name2);
-        break;
-      }
-      case Kind.INPUT_OBJECT_TYPE_EXTENSION: {
-        collectFields(node, picks.inputs);
-        pushUnique(extended.inputs, name2);
-        break;
-      }
-      case Kind.INTERFACE_TYPE_EXTENSION: {
-        collectFields(node, picks.interfaces);
-        pushUnique(extended.interfaces, name2);
-        break;
-      }
-      case Kind.UNION_TYPE_EXTENSION: {
-        pushUnique(extended.unions, name2);
-        break;
-      }
-    }
-  }
-}
-export {
-  buildModule
-};

package/dist/modules/config.d.ts

@@ -1,11 +0,0 @@
-declare type ModulesConfig = {
-    baseTypesPath: string;
-    importBaseTypesFrom?: string;
-    cwd?: string;
-    importTypesNamespace?: string;
-    filename: string;
-    encapsulateModuleTypes: "prefix" | "namespace" | "none";
-    requireRootResolvers?: boolean;
-};
-
-export { ModulesConfig };

package/dist/modules/config.js

@@ -1,16 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var config_exports = {};
-module.exports = __toCommonJS(config_exports);

package/dist/modules/index.d.ts

@@ -1,6 +0,0 @@
-import { Types } from '@graphql-codegen/plugin-helpers';
-import { ModulesConfig } from './config.js';
-
-declare const preset: Types.OutputPreset<ModulesConfig>;
-
-export { preset as default, preset };

package/dist/modules/index.js

@@ -1,148 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var modules_exports = {};
-__export(modules_exports, {
-  default: () => modules_default,
-  preset: () => preset
-});
-module.exports = __toCommonJS(modules_exports);
-var import_graphql = require("graphql");
-var import_path = require("path");
-var import_utils = require("./utils");
-var import_builder = require("./builder");
-var import_visitor_plugin_common = require("@graphql-codegen/visitor-plugin-common");
-const preset = {
-  buildGeneratesSection: (options) => {
-    const { baseOutputDir } = options;
-    const { baseTypesPath, encapsulateModuleTypes } = options.presetConfig;
-    const requireRootResolvers = (0, import_visitor_plugin_common.getConfigValue)(
-      options == null ? void 0 : options.presetConfig.requireRootResolvers,
-      false
-    );
-    const cwd = (0, import_path.resolve)(options.presetConfig.cwd || process.cwd());
-    const importTypesNamespace = options.presetConfig.importTypesNamespace || "Types";
-    if (!baseTypesPath) {
-      throw new Error(
-        `Preset "graphql-modules" requires you to specify "baseTypesPath" configuration and point it to your base types file (generated by "typescript" plugin)!`
-      );
-    }
-    if (!options.schemaAst || !options.schemaAst.extensions.sources) {
-      throw new Error(`Preset "graphql-modules" requires to use GraphQL SDL`);
-    }
-    const extensions = options.schemaAst.extensions;
-    const sourcesByModuleMap = (0, import_utils.groupSourcesByModule)(
-      extensions.extendedSources,
-      baseOutputDir
-    );
-    const modules = Object.keys(sourcesByModuleMap);
-    const baseVisitor = new import_visitor_plugin_common.BaseVisitor(options.config, {});
-    const baseOutput = {
-      filename: (0, import_path.resolve)(cwd, baseOutputDir, baseTypesPath),
-      schema: options.schema,
-      documents: options.documents,
-      plugins: [
-        ...options.plugins,
-        {
-          "modules-exported-scalars": {}
-        }
-      ],
-      pluginMap: {
-        ...options.pluginMap,
-        "modules-exported-scalars": {
-          plugin: (schema) => {
-            const typeMap = schema.getTypeMap();
-            return Object.keys(typeMap).map((t) => {
-              if (t && typeMap[t] && (0, import_graphql.isScalarType)(typeMap[t]) && !(0, import_utils.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 = (0, import_utils.stripFilename)(baseOutput.filename);
-    const outputs = modules.map((moduleName) => {
-      const filename = (0, import_path.resolve)(
-        cwd,
-        baseOutputDir,
-        moduleName,
-        options.presetConfig.filename
-      );
-      const dirpath = (0, import_utils.stripFilename)(filename);
-      const relativePath = (0, import_path.relative)(dirpath, baseTypesDir);
-      const importPath = options.presetConfig.importBaseTypesFrom || (0, import_utils.normalize)((0, import_path.join)(relativePath, baseTypesFilename));
-      const sources = sourcesByModuleMap[moduleName];
-      const documents = sources.map(
-        (source) => source.document
-      );
-      const moduleDocument = (0, import_graphql.concatAST)(documents);
-      const shouldDeclare = filename.endsWith(".d.ts");
-      return {
-        filename,
-        schema: options.schema,
-        documents: [],
-        plugins: [
-          ...options.plugins.filter((p) => typeof p === "object" && !!p.add),
-          {
-            "graphql-modules-plugin": {}
-          }
-        ],
-        pluginMap: {
-          ...options.pluginMap,
-          "graphql-modules-plugin": {
-            plugin: (schema) => {
-              var _a, _b, _c;
-              return (0, import_builder.buildModule)(moduleName, moduleDocument, {
-                importNamespace: importTypesNamespace,
-                importPath,
-                encapsulate: encapsulateModuleTypes || "namespace",
-                requireRootResolvers,
-                shouldDeclare,
-                schema,
-                baseVisitor,
-                useGraphQLModules: false,
-                rootTypes: [
-                  ((_a = schema.getQueryType()) == null ? void 0 : _a.name) || "",
-                  ((_b = schema.getMutationType()) == null ? void 0 : _b.name) || "",
-                  ((_c = schema.getSubscriptionType()) == null ? void 0 : _c.name) || ""
-                ].filter(Boolean)
-              });
-            }
-          }
-        },
-        config: options.config,
-        schemaAst: options.schemaAst
-      };
-    });
-    return [baseOutput].concat(outputs);
-  }
-};
-var modules_default = preset;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  preset
-});