@baeta/plugin-graphql 0.0.2 → 0.0.3

package/dist/modules/builder.js

@@ -1,439 +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 builder_exports = {};
-__export(builder_exports, {
-  buildModule: () => buildModule
-});
-module.exports = __toCommonJS(builder_exports);
-var import_graphql = require("graphql");
-var import_change_case_all = require("change-case-all");
-var import_utils = require("./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 = (0, import_utils.createObject)(
-    registryKeys,
-    () => ({})
-  );
-  const defined = (0, import_utils.createObject)(registryKeys, () => []);
-  const extended = (0, import_utils.createObject)(registryKeys, () => []);
-  const usedTypes = (0, import_utils.collectUsedTypes)(doc);
-  (0, import_graphql.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 = (0, import_utils.createObject)(
-    registryKeys,
-    (key) => (0, import_utils.concatByKey)(defined, extended, key)
-  );
-  const external = (0, import_utils.createObject)(
-    registryKeys,
-    (key) => (0, import_utils.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 ? `${(0, import_utils.indent)(2)(imports.join("\n"))}
-` : "") + (0, import_utils.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 (0, import_utils.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(import_utils.unique).map((field) => printObjectFieldResolverBuilder(typeName, field))) ?? [];
-    if (fields.length === 0) {
-      return "";
-    }
-    const resolversType = `${typeName}Resolvers`;
-    const content2 = `{
-${fields.map((0, import_utils.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(import_utils.unique)) ?? [];
-    if (subscriptions.length === 0) {
-      return "";
-    }
-    const fields = subscriptions.map(
-      (subscription) => printSubscriptionFieldBuilder(subscription)
-    );
-    const resolversType = `SubscriptionResolvers`;
-    const content2 = `{
-${fields.map((0, import_utils.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((0, import_utils.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((0, import_utils.indent)(6)).join("\n");
-    const content2 = `{
-${body}
-    }`;
-    return `
-  export function createManager(options: Baeta.ManagerOptions) {
-    return Baeta.createManager(options, {}, ${content2});
-  }`;
-  }
-  function printDefinedEnumValues() {
-    return (0, import_utils.buildBlock)({
-      name: `interface DefinedEnumValues`,
-      lines: visited.enums.map(
-        (typeName) => `${typeName}: ${printPicks(typeName, picks.enums)};`
-      )
-    });
-  }
-  function encapsulateTypeName(typeName) {
-    if (encapsulate === "prefix") {
-      return `${(0, import_change_case_all.pascalCase)(name)}_${typeName}`;
-    }
-    return typeName;
-  }
-  function printDefinedInputFields() {
-    return (0, import_utils.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(import_utils.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 (0, import_utils.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(import_utils.unique).map(import_utils.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 && (0, import_graphql.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 import_graphql.Kind.OBJECT_TYPE_DEFINITION: {
-        defined.objects.push(name2);
-        collectFields(node, picks.objects);
-        break;
-      }
-      case import_graphql.Kind.ENUM_TYPE_DEFINITION: {
-        defined.enums.push(name2);
-        collectValuesFromEnum(node);
-        break;
-      }
-      case import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION: {
-        defined.inputs.push(name2);
-        collectFields(node, picks.inputs);
-        break;
-      }
-      case import_graphql.Kind.SCALAR_TYPE_DEFINITION: {
-        defined.scalars.push(name2);
-        break;
-      }
-      case import_graphql.Kind.INTERFACE_TYPE_DEFINITION: {
-        defined.interfaces.push(name2);
-        collectFields(node, picks.interfaces);
-        break;
-      }
-      case import_graphql.Kind.UNION_TYPE_DEFINITION: {
-        defined.unions.push(name2);
-        break;
-      }
-    }
-  }
-  function collectTypeExtension(node) {
-    const name2 = node.name.value;
-    switch (node.kind) {
-      case import_graphql.Kind.OBJECT_TYPE_EXTENSION: {
-        collectFields(node, picks.objects);
-        if (rootTypes.includes(name2)) {
-          (0, import_utils.pushUnique)(defined.objects, name2);
-          return;
-        }
-        (0, import_utils.pushUnique)(extended.objects, name2);
-        break;
-      }
-      case import_graphql.Kind.ENUM_TYPE_EXTENSION: {
-        collectValuesFromEnum(node);
-        (0, import_utils.pushUnique)(extended.enums, name2);
-        break;
-      }
-      case import_graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION: {
-        collectFields(node, picks.inputs);
-        (0, import_utils.pushUnique)(extended.inputs, name2);
-        break;
-      }
-      case import_graphql.Kind.INTERFACE_TYPE_EXTENSION: {
-        collectFields(node, picks.interfaces);
-        (0, import_utils.pushUnique)(extended.interfaces, name2);
-        break;
-      }
-      case import_graphql.Kind.UNION_TYPE_EXTENSION: {
-        (0, import_utils.pushUnique)(extended.unions, name2);
-        break;
-      }
-    }
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  buildModule
-});