@baeta/plugin-graphql 0.0.1

package/dist/codegen.d.ts

@@ -0,0 +1,6 @@
+import { GraphqlPluginConfig } from './config.js';
+import { File } from '@baeta/plugin';
+
+declare function generate(options: GraphqlPluginConfig): Promise<File[]>;
+
+export { generate };

package/dist/codegen.js

@@ -0,0 +1,116 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var codegen_exports = {};
+__export(codegen_exports, {
+  generate: () => generate
+});
+module.exports = __toCommonJS(codegen_exports);
+var import_core = require("@graphql-codegen/core");
+var import_plugin_helpers = require("@graphql-codegen/plugin-helpers");
+var modules = __toESM(require("./modules"));
+var typescriptPlugin = __toESM(require("@graphql-codegen/typescript"));
+var typescriptResolversPlugin = __toESM(require("./resolvers"));
+var import_path = __toESM(require("path"));
+var import_cache = require("./utils/cache");
+var import_load2 = require("./utils/load");
+var import_plugin = require("@baeta/plugin");
+async function generate(options) {
+  const root = process.cwd();
+  const modulesDir = import_path.default.relative(root, options.modulesDir || "modules");
+  const rootConfig = {
+    schemas: (0, import_plugin_helpers.normalizeInstanceOrArray)(options.schemas),
+    modulesDir,
+    baseTypesPath: import_path.default.relative(
+      modulesDir,
+      options.baseTypesPath || "./__generated__/types.ts"
+    ),
+    contextType: options.contextType,
+    moduleDefinitionName: options.moduleDefinitionName || "typedef.ts",
+    scalars: options.scalars,
+    plugins: (0, import_plugin_helpers.normalizeConfig)(["typescript", "typescript-resolvers"]),
+    pluginMap: {
+      typescript: typescriptPlugin,
+      "typescript-resolvers": typescriptResolversPlugin
+    }
+  };
+  const cache = (0, import_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 (0, import_load2.loadSchema)(schemaPointerMap, root);
+  });
+  const outputs = await modules.preset.buildGeneratesSection({
+    baseOutputDir: modulesDir,
+    presetConfig: {
+      baseTypesPath: rootConfig.baseTypesPath,
+      filename: rootConfig.moduleDefinitionName,
+      encapsulateModuleTypes: "none"
+    },
+    schema: result.outputSchema,
+    schemaAst: result.outputSchemaAst,
+    documents: [],
+    pluginMap: rootConfig.pluginMap,
+    plugins: rootConfig.plugins,
+    config: {
+      useIndexSignature: true,
+      inputMaybeValue: "T | undefined",
+      mapperTypeSuffix: "Prisma",
+      contextType: rootConfig.contextType,
+      customResolverFn: "@baeta/core#Resolver",
+      customSubscriptionResolver: "@baeta/core#SubscriptionResolver",
+      useTypeImports: true,
+      makeResolverTypeCallable: true,
+      includeDirectives: true,
+      resolverTypeWrapperSignature: "T",
+      scalars: {
+        BigInt: "number",
+        Bytes: "Buffer",
+        DateTime: "Date",
+        Decimal: "number",
+        Json: "{}",
+        ...rootConfig.scalars
+      }
+    }
+  });
+  const promises = outputs.map(async (output) => {
+    const result2 = await (0, import_core.codegen)({
+      ...output,
+      cache
+    });
+    return new import_plugin.File(output.filename, result2, "graphql");
+  });
+  return Promise.all(promises);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generate
+});

package/dist/codegen.mjs

@@ -0,0 +1,89 @@
+import { codegen as gqlCodegen } from "@graphql-codegen/core";
+import {
+  normalizeConfig,
+  normalizeInstanceOrArray
+} from "@graphql-codegen/plugin-helpers";
+import * as modules from "./modules";
+import * as typescriptPlugin from "@graphql-codegen/typescript";
+import * as typescriptResolversPlugin from "./resolvers";
+import path from "path";
+import { createCache } from "./utils/cache";
+import { loadSchema } from "./utils/load";
+import { File } from "@baeta/plugin";
+async function generate(options) {
+  const root = process.cwd();
+  const modulesDir = path.relative(root, options.modulesDir || "modules");
+  const rootConfig = {
+    schemas: normalizeInstanceOrArray(options.schemas),
+    modulesDir,
+    baseTypesPath: path.relative(
+      modulesDir,
+      options.baseTypesPath || "./__generated__/types.ts"
+    ),
+    contextType: options.contextType,
+    moduleDefinitionName: options.moduleDefinitionName || "typedef.ts",
+    scalars: options.scalars,
+    plugins: normalizeConfig(["typescript", "typescript-resolvers"]),
+    pluginMap: {
+      typescript: typescriptPlugin,
+      "typescript-resolvers": typescriptResolversPlugin
+    }
+  };
+  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, root);
+  });
+  const outputs = await modules.preset.buildGeneratesSection({
+    baseOutputDir: modulesDir,
+    presetConfig: {
+      baseTypesPath: rootConfig.baseTypesPath,
+      filename: rootConfig.moduleDefinitionName,
+      encapsulateModuleTypes: "none"
+    },
+    schema: result.outputSchema,
+    schemaAst: result.outputSchemaAst,
+    documents: [],
+    pluginMap: rootConfig.pluginMap,
+    plugins: rootConfig.plugins,
+    config: {
+      useIndexSignature: true,
+      inputMaybeValue: "T | undefined",
+      mapperTypeSuffix: "Prisma",
+      contextType: rootConfig.contextType,
+      customResolverFn: "@baeta/core#Resolver",
+      customSubscriptionResolver: "@baeta/core#SubscriptionResolver",
+      useTypeImports: true,
+      makeResolverTypeCallable: true,
+      includeDirectives: true,
+      resolverTypeWrapperSignature: "T",
+      scalars: {
+        BigInt: "number",
+        Bytes: "Buffer",
+        DateTime: "Date",
+        Decimal: "number",
+        Json: "{}",
+        ...rootConfig.scalars
+      }
+    }
+  });
+  const promises = outputs.map(async (output) => {
+    const result2 = await gqlCodegen({
+      ...output,
+      cache
+    });
+    return new File(output.filename, result2, "graphql");
+  });
+  return Promise.all(promises);
+}
+export {
+  generate
+};

package/dist/config.d.ts

@@ -0,0 +1,10 @@
+interface GraphqlPluginConfig {
+    schemas: string[];
+    modulesDir?: string;
+    moduleDefinitionName?: string;
+    baseTypesPath?: string;
+    contextType?: string;
+    scalars?: Record<string, string>;
+}
+
+export { GraphqlPluginConfig };

package/dist/config.js

@@ -0,0 +1,16 @@
+"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/index.d.ts

@@ -0,0 +1,7 @@
+import * as _baeta_plugin from '@baeta/plugin';
+import { GraphqlPluginConfig } from './config.js';
+export { GraphqlPluginConfig } from './config.js';
+
+declare const _default: (config: GraphqlPluginConfig) => _baeta_plugin.GeneratorPluginV1WithConfig<unknown, {}>;
+
+export { _default as default };

package/dist/index.js

@@ -0,0 +1,41 @@
+"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 graphql_exports = {};
+__export(graphql_exports, {
+  default: () => graphql_default
+});
+module.exports = __toCommonJS(graphql_exports);
+var import_plugin = require("@baeta/plugin");
+var import_codegen = require("./codegen");
+var graphql_default = (0, import_plugin.createPluginFactoryV1)({
+  name: "graphql",
+  watch: (baetaConfig, pluginConfig) => {
+    return {
+      include: pluginConfig.schemas,
+      ignore: []
+    };
+  },
+  generate: async (params) => {
+    const files = await (0, import_codegen.generate)(params.config);
+    params.ctx.fileManager.add(...files);
+    return params.next();
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/index.mjs

@@ -0,0 +1,19 @@
+import { createPluginFactoryV1 } from "@baeta/plugin";
+import { generate } from "./codegen";
+var graphql_default = createPluginFactoryV1({
+  name: "graphql",
+  watch: (baetaConfig, pluginConfig) => {
+    return {
+      include: pluginConfig.schemas,
+      ignore: []
+    };
+  },
+  generate: async (params) => {
+    const files = await generate(params.config);
+    params.ctx.fileManager.add(...files);
+    return params.next();
+  }
+});
+export {
+  graphql_default as default
+};

package/dist/modules/builder.d.ts

@@ -0,0 +1,17 @@
+import { DocumentNode, GraphQLSchema } from 'graphql';
+import { ModulesConfig } from './config.js';
+import { BaseVisitor } from '@graphql-codegen/visitor-plugin-common';
+
+declare function buildModule(name: string, doc: DocumentNode, { importNamespace, importPath, encapsulate, requireRootResolvers, shouldDeclare, rootTypes, schema, baseVisitor, }: {
+    importNamespace: string;
+    importPath: string;
+    encapsulate: ModulesConfig["encapsulateModuleTypes"];
+    requireRootResolvers: ModulesConfig["requireRootResolvers"];
+    shouldDeclare: boolean;
+    rootTypes: string[];
+    baseVisitor: BaseVisitor;
+    schema?: GraphQLSchema;
+    useGraphQLModules: boolean;
+}): string;
+
+export { buildModule };