@cedarjs/internal 5.0.4-next.167 → 5.0.4

package/dist/cjs/generate/graphqlCodeGen.d.ts

@@ -0,0 +1,16 @@
+import type { LoadTypedefsOptions } from '@graphql-tools/load';
+type TypeDefResult = {
+    typeDefFiles: string[];
+    errors: {
+        message: string;
+        error: unknown;
+    }[];
+};
+export declare const generateTypeDefGraphQLApi: () => Promise<TypeDefResult>;
+export declare const generateTypeDefGraphQLWeb: () => Promise<TypeDefResult>;
+export declare function getLoadDocumentsOptions(filename: string): LoadTypedefsOptions<{
+    cwd: string;
+}>;
+export declare const getResolverFnType: () => "(\n      args: TArgs,\n      obj?: { root: TParent; context: TContext; info: GraphQLResolveInfo }\n    ) => TResult | Promise<TResult>" | "(\n      args?: TArgs,\n      obj?: { root: TParent; context: TContext; info: GraphQLResolveInfo }\n    ) => TResult | Promise<TResult>";
+export {};
+//# sourceMappingURL=graphqlCodeGen.d.ts.map

package/dist/cjs/generate/graphqlCodeGen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphqlCodeGen.d.ts","sourceRoot":"","sources":["../../../src/generate/graphqlCodeGen.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAmB9D,KAAK,aAAa,GAAG;IACnB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;CAC9C,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAa,OAAO,CAAC,aAAa,CAiFvE,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAa,OAAO,CAAC,aAAa,CAwDvE,CAAA;AAmCD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM;SACD,MAAM;GAQ5D;AAmKD,eAAO,MAAM,iBAAiB,4RAe7B,CAAA"}

package/dist/cjs/generate/graphqlCodeGen.js

@@ -0,0 +1,380 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graphqlCodeGen_exports = {};
+__export(graphqlCodeGen_exports, {
+  generateTypeDefGraphQLApi: () => generateTypeDefGraphQLApi,
+  generateTypeDefGraphQLWeb: () => generateTypeDefGraphQLWeb,
+  getLoadDocumentsOptions: () => getLoadDocumentsOptions,
+  getResolverFnType: () => getResolverFnType
+});
+module.exports = __toCommonJS(graphqlCodeGen_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+var addPlugin = __toESM(require("@graphql-codegen/add"), 1);
+var import_cli = require("@graphql-codegen/cli");
+var import_core = require("@graphql-codegen/core");
+var typescriptPlugin = __toESM(require("@graphql-codegen/typescript"), 1);
+var typescriptOperations = __toESM(require("@graphql-codegen/typescript-operations"), 1);
+var import_code_file_loader = require("@graphql-tools/code-file-loader");
+var import_graphql_file_loader = require("@graphql-tools/graphql-file-loader");
+var import_load = require("@graphql-tools/load");
+var import_execa = __toESM(require("execa"), 1);
+var import_graphql = require("graphql");
+var import_project_config = require("@cedarjs/project-config");
+var import_packageManager = require("@cedarjs/project-config/packageManager");
+var import_project = require("../project.js");
+var rwTypescriptResolvers = __toESM(require("./plugins/rw-typescript-resolvers/index.js"), 1);
+var CodegenSide = /* @__PURE__ */ ((CodegenSide2) => {
+  CodegenSide2[CodegenSide2["API"] = 0] = "API";
+  CodegenSide2[CodegenSide2["WEB"] = 1] = "WEB";
+  return CodegenSide2;
+})(CodegenSide || {});
+const generateTypeDefGraphQLApi = async () => {
+  const config = (0, import_project_config.getConfig)();
+  const errors = [];
+  if (config.experimental.useSDLCodeGenForGraphQLTypes) {
+    const paths = (0, import_project_config.getPaths)();
+    const sdlCodegen = await import("@sdl-codegen/node");
+    const dtsFiles = [];
+    try {
+      const output = await sdlCodegen.runFullCodegen("redwood", { paths });
+      dtsFiles.push(...output.paths);
+    } catch (e) {
+      if (e instanceof Error) {
+        errors.push({ message: e.message, error: e });
+      } else {
+        throw e;
+      }
+    }
+    return {
+      typeDefFiles: dtsFiles,
+      errors
+    };
+  }
+  const filename = import_node_path.default.join((0, import_project_config.getPaths)().api.types, "graphql.d.ts");
+  const prismaModels = await getPrismaModels();
+  const prismaImports = Object.keys(prismaModels).map((key) => {
+    return `${key} as Prisma${key}`;
+  });
+  const prismaImportSource = "src/lib/db";
+  const extraPlugins = [
+    {
+      name: "add",
+      options: {
+        content: [
+          `import { Prisma } from "${prismaImportSource}"`,
+          "import { MergePrismaWithSdlTypes, MakeRelationsOptional } from '@cedarjs/api'",
+          `import { ${prismaImports.join(", ")} } from '${prismaImportSource}'`
+        ],
+        placement: "prepend"
+      },
+      codegenPlugin: addPlugin
+    },
+    {
+      name: "print-mapped-models",
+      options: {},
+      codegenPlugin: printMappedModelsPlugin
+    },
+    {
+      name: "typescript-resolvers",
+      options: {},
+      codegenPlugin: rwTypescriptResolvers
+    }
+  ];
+  try {
+    return {
+      typeDefFiles: await runCodegenGraphQL(
+        [],
+        extraPlugins,
+        filename,
+        0 /* API */
+      ),
+      errors
+    };
+  } catch (e) {
+    errors.push({
+      message: "Error: Could not generate GraphQL type definitions (api)",
+      error: e
+    });
+    return {
+      typeDefFiles: [],
+      errors
+    };
+  }
+};
+const generateTypeDefGraphQLWeb = async () => {
+  const filename = import_node_path.default.join((0, import_project_config.getPaths)().web.types, "graphql.d.ts");
+  const options = getLoadDocumentsOptions(filename);
+  const documentsGlob = "./web/src/**/!(*.d).{ts,tsx,js,jsx}";
+  let documents;
+  try {
+    documents = await (0, import_load.loadDocuments)([documentsGlob], options);
+  } catch {
+    return {
+      typeDefFiles: [],
+      errors: []
+    };
+  }
+  const extraPlugins = [
+    {
+      name: "add",
+      options: {
+        content: `import { Prisma } from "$api/src/lib/db"`,
+        placement: "prepend"
+      },
+      codegenPlugin: addPlugin
+    },
+    {
+      name: "typescript-operations",
+      options: {},
+      codegenPlugin: typescriptOperations
+    }
+  ];
+  const errors = [];
+  try {
+    return {
+      typeDefFiles: await runCodegenGraphQL(
+        documents,
+        extraPlugins,
+        filename,
+        1 /* WEB */
+      ),
+      errors
+    };
+  } catch (e) {
+    errors.push({
+      message: "Error: Could not generate GraphQL type definitions (web)",
+      error: e
+    });
+    return {
+      typeDefFiles: [],
+      errors
+    };
+  }
+};
+async function runCodegenGraphQL(documents, extraPlugins, filename, side) {
+  const userCodegenConfig = await (0, import_cli.loadCodegenConfig)({
+    configFilePath: (0, import_project_config.getPaths)().base
+  });
+  const pluginConfig = await getPluginConfig(side);
+  const mergedConfig = {
+    ...pluginConfig,
+    ...userCodegenConfig?.config?.config
+  };
+  const options = getCodegenOptions(documents, mergedConfig, extraPlugins);
+  const output = await (0, import_core.codegen)(options);
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(filename), { recursive: true });
+  import_node_fs.default.writeFileSync(filename, output);
+  return [filename];
+}
+function getLoadDocumentsOptions(filename) {
+  const loadTypedefsConfig = {
+    cwd: (0, import_project_config.getPaths)().base,
+    ignore: [filename],
+    loaders: [new import_code_file_loader.CodeFileLoader()],
+    sort: true
+  };
+  return loadTypedefsConfig;
+}
+async function importGeneratedPrismaClient() {
+  const cacheBuster = `?t=${Date.now()}`;
+  const { clientPath, error } = await (0, import_project_config.resolveGeneratedPrismaClient)();
+  if (!clientPath) {
+    throw new Error(error);
+  }
+  const fileUrl = (0, import_node_url.pathToFileURL)(clientPath).href + cacheBuster;
+  const freshPrisma = await import(fileUrl);
+  return freshPrisma;
+}
+function isModelNameRecord(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return Object.values(value).every((entry) => typeof entry === "string");
+}
+function getModelName(mod) {
+  if (typeof mod !== "object" || mod === null || !("Prisma" in mod)) {
+    return null;
+  }
+  const prismaModule = mod.Prisma;
+  if (typeof prismaModule !== "object" || prismaModule === null || !("ModelName" in prismaModule)) {
+    return null;
+  }
+  const modelName = prismaModule.ModelName;
+  if (typeof modelName !== "object" || modelName === null) {
+    return null;
+  }
+  if (isModelNameRecord(modelName)) {
+    return modelName;
+  }
+  return null;
+}
+async function getPrismaClient() {
+  try {
+    const localPrisma = await importGeneratedPrismaClient();
+    const modelName = getModelName(localPrisma);
+    if (modelName) {
+      return { ModelName: modelName };
+    }
+  } catch {
+  }
+  const pm = (0, import_packageManager.getPackageManager)();
+  const pmExec = pm === "npm" ? "npx" : pm;
+  import_execa.default.sync(pmExec, ["cedar", "prisma", "generate"]);
+  try {
+    const freshPrisma = await importGeneratedPrismaClient();
+    const modelName = getModelName(freshPrisma);
+    if (modelName) {
+      return { ModelName: modelName };
+    }
+  } catch {
+  }
+  return { ModelName: {} };
+}
+async function getPrismaModels() {
+  const localPrisma = await getPrismaClient();
+  const prismaModels = localPrisma.ModelName;
+  if (prismaModels.RW_DataMigration) {
+    delete prismaModels.RW_DataMigration;
+  }
+  return prismaModels;
+}
+async function getPluginConfig(side) {
+  const prismaModels = await getPrismaModels();
+  Object.keys(prismaModels).forEach((key) => {
+    prismaModels[key] = `MergePrismaWithSdlTypes<Prisma${key}, MakeRelationsOptional<${key}, AllMappedModels>, AllMappedModels>`;
+  });
+  const scalars = {
+    // We need these, otherwise these scalars are mapped to any
+    BigInt: "number",
+    // @Note: DateTime fields can be valid Date-strings, or the Date object in the api side. They're always strings on the web side.
+    DateTime: side === 1 /* WEB */ ? "string" : "Date | string",
+    Date: side === 1 /* WEB */ ? "string" : "Date | string",
+    JSON: "Prisma.JsonValue",
+    JSONObject: "Prisma.JsonObject",
+    Time: side === 1 /* WEB */ ? "string" : "Date | string",
+    Byte: "Uint8Array"
+  };
+  const config = (0, import_project_config.getConfig)();
+  if (config.graphql.includeScalars.File) {
+    scalars.File = "File";
+  }
+  const pluginConfig = {
+    makeResolverTypeCallable: true,
+    namingConvention: "keep",
+    // to allow camelCased query names
+    scalars,
+    // prevent type names being PetQueryQuery, RW generators already append
+    // Query/Mutation/etc
+    omitOperationSuffix: true,
+    showUnusedMappers: false,
+    customResolverFn: getResolverFnType(),
+    mappers: prismaModels,
+    avoidOptionals: {
+      // We do this, so that service tests can call resolvers without doing a null check
+      // see https://github.com/redwoodjs/redwood/pull/6222#issuecomment-1230156868
+      // Look at type or source https://shrtm.nu/2BA0 for possible config, not well documented
+      resolvers: true
+    },
+    contextType: `@cedarjs/graphql-server/dist/types#CedarGraphQLContext`
+  };
+  return pluginConfig;
+}
+const getResolverFnType = () => {
+  const tsConfig = (0, import_project.getTsConfigs)();
+  if (tsConfig.api?.compilerOptions?.strict) {
+    return `(
+      args: TArgs,
+      obj?: { root: TParent; context: TContext; info: GraphQLResolveInfo }
+    ) => TResult | Promise<TResult>`;
+  } else {
+    return `(
+      args?: TArgs,
+      obj?: { root: TParent; context: TContext; info: GraphQLResolveInfo }
+    ) => TResult | Promise<TResult>`;
+  }
+};
+const printMappedModelsPlugin = {
+  plugin: (schema, _documents, config) => {
+    const sdlTypesWhichAreMapped = Object.values(schema.getTypeMap()).filter((type) => {
+      return type.astNode?.kind === import_graphql.Kind.OBJECT_TYPE_DEFINITION;
+    }).filter((objectDefType) => {
+      const modelName = objectDefType.astNode?.name.value;
+      return modelName && modelName in config.mappers;
+    }).map((objectDefType) => objectDefType.astNode?.name.value);
+    return `type MaybeOrArrayOfMaybe<T> = T | Maybe<T> | Maybe<T>[];
+type AllMappedModels = MaybeOrArrayOfMaybe<${sdlTypesWhichAreMapped.join(
+      " | "
+    )}>`;
+  }
+};
+function getCodegenOptions(documents, config, extraPlugins) {
+  const plugins = [
+    { typescript: { enumsAsTypes: true } },
+    ...extraPlugins.map((plugin) => ({ [plugin.name]: plugin.options }))
+  ];
+  const pluginMap = {
+    typescript: typescriptPlugin,
+    ...extraPlugins.reduce(
+      (acc, cur) => ({ ...acc, [cur.name]: cur.codegenPlugin }),
+      {}
+    )
+  };
+  const options = {
+    // The typescript plugin returns a string instead of writing to a file, so
+    // `filename` is not used
+    filename: "",
+    // `schemaAst` is used instead of `schema` if `schemaAst` is defined, and
+    // `schema` isn't. In the source for GenerateOptions they have this
+    // comment:
+    //   Remove schemaAst and change schema to GraphQLSchema in the next major
+    //   version
+    // When that happens we'll have have to remove our `schema` line, and
+    // rename `schemaAst` to `schema`
+    schema: void 0,
+    schemaAst: (0, import_load.loadSchemaSync)((0, import_project_config.getPaths)().generated.schema, {
+      loaders: [new import_graphql_file_loader.GraphQLFileLoader()],
+      sort: true
+    }),
+    documents,
+    config,
+    plugins,
+    pluginMap,
+    pluginContext: {}
+  };
+  return options;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateTypeDefGraphQLApi,
+  generateTypeDefGraphQLWeb,
+  getLoadDocumentsOptions,
+  getResolverFnType
+});

package/dist/cjs/generate/graphqlSchema.d.ts

@@ -0,0 +1,8 @@
+export declare const generateGraphQLSchema: () => Promise<{
+    schemaPath: string;
+    errors: {
+        message: string;
+        error: unknown;
+    }[];
+}>;
+//# sourceMappingURL=graphqlSchema.d.ts.map

package/dist/cjs/generate/graphqlSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphqlSchema.d.ts","sourceRoot":"","sources":["../../../src/generate/graphqlSchema.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,qBAAqB;;;iBA2DP,MAAM;eAAS,OAAO;;EA2EhD,CAAA"}

package/dist/cjs/generate/graphqlSchema.js

@@ -0,0 +1,157 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graphqlSchema_exports = {};
+__export(graphqlSchema_exports, {
+  generateGraphQLSchema: () => generateGraphQLSchema
+});
+module.exports = __toCommonJS(graphqlSchema_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_core = require("@graphql-codegen/core");
+var schemaAstPlugin = __toESM(require("@graphql-codegen/schema-ast"), 1);
+var import_code_file_loader = require("@graphql-tools/code-file-loader");
+var import_load = require("@graphql-tools/load");
+var import_ansis = __toESM(require("ansis"), 1);
+var import_graphql = require("graphql");
+var import_termi_link = require("termi-link");
+var import_graphql_server = require("@cedarjs/graphql-server");
+var import_project_config = require("@cedarjs/project-config");
+const generateGraphQLSchema = async () => {
+  const cedarPaths = (0, import_project_config.getPaths)();
+  const cedarConfig = (0, import_project_config.getConfig)();
+  const schemaPointerMap = {
+    [(0, import_graphql.print)(import_graphql_server.rootSchema.schema)]: {},
+    "graphql/**/*.sdl.{js,ts}": {},
+    "directives/**/*.{js,ts}": {},
+    "!directives/**/*.test.{js,ts}": {},
+    "!directives/**/*.spec.{js,ts}": {},
+    "subscriptions/**/*.{js,ts}": {},
+    "!subscriptions/**/*.test.{js,ts}": {},
+    "!subscriptions/**/*.spec.{js,ts}": {}
+  };
+  for (const [name, schema] of Object.entries(import_graphql_server.rootSchema.scalarSchemas)) {
+    if (cedarConfig.graphql.includeScalars[name]) {
+      schemaPointerMap[(0, import_graphql.print)(schema)] = {};
+    }
+  }
+  if ((0, import_project_config.resolveFile)(`${(0, import_project_config.getPaths)().api.src}/server`)) {
+    try {
+      const { liveDirectiveTypeDefs } = await import("@cedarjs/realtime");
+      schemaPointerMap[liveDirectiveTypeDefs] = {};
+    } catch (error) {
+      if (error.code !== "ERR_MODULE_NOT_FOUND") {
+        throw error;
+      }
+    }
+  }
+  const loadSchemaConfig = {
+    assumeValidSDL: true,
+    sort: true,
+    convertExtensions: true,
+    includeSources: true,
+    cwd: cedarPaths.api.src,
+    schema: Object.keys(schemaPointerMap),
+    generates: {
+      [cedarPaths.generated.schema]: {
+        plugins: ["schema-ast"]
+      }
+    },
+    silent: false,
+    errorsOnly: false,
+    pluginContext: {},
+    loaders: [new import_code_file_loader.CodeFileLoader()]
+  };
+  let loadedSchema;
+  const errors = [];
+  try {
+    loadedSchema = await (0, import_load.loadSchema)(schemaPointerMap, loadSchemaConfig);
+  } catch (e) {
+    if (e instanceof Error) {
+      const match = e.message.match(/Unknown type: "(\w+)"/);
+      const name = match?.[1];
+      const result = await (0, import_project_config.getPrismaSchemas)();
+      const schemaPrisma = result.schemas.map(([, content]) => content).join("\n");
+      const errorObject = {
+        message: `Schema loading failed. ${e.message}`,
+        error: e
+      };
+      errors.push(errorObject);
+      if (name && schemaPrisma.includes(`model ${name}`)) {
+        errorObject.message = [
+          errorObject.message,
+          "",
+          `  ${import_ansis.default.bgYellow(` ${import_ansis.default.black.bold("Heads up")} `)}`,
+          "",
+          import_ansis.default.yellow(
+            `  It looks like you have a ${name} model in your Prisma schema.`
+          ),
+          import_ansis.default.yellow(
+            `  If it's part of a relation, you may have to generate SDL or scaffolding for ${name} too.`
+          ),
+          import_ansis.default.yellow(
+            `  So, if you haven't done that yet, ignore this error message and run the SDL or scaffold generator for ${name} now.`
+          ),
+          "",
+          import_ansis.default.yellow(
+            `  See the ${(0, import_termi_link.terminalLink)(
+              "Troubleshooting Generators",
+              "https://cedarjs.com/docs/schema-relations#troubleshooting-generators"
+            )} section in our docs for more help.`
+          )
+        ].join("\n");
+      }
+    }
+  }
+  const options = {
+    config: {},
+    // no extra config needed for merged schema file generation
+    plugins: [{ "schema-ast": {} }],
+    pluginMap: { "schema-ast": schemaAstPlugin },
+    schema: {},
+    schemaAst: loadedSchema,
+    filename: cedarPaths.generated.schema,
+    documents: []
+  };
+  if (loadedSchema) {
+    try {
+      const schema = await (0, import_core.codegen)(options);
+      import_node_fs.default.writeFileSync(cedarPaths.generated.schema, schema);
+      return { schemaPath: cedarPaths.generated.schema, errors };
+    } catch (e) {
+      errors.push({
+        message: `GraphQL Schema codegen failed`,
+        error: e
+      });
+    }
+  }
+  return { schemaPath: "", errors };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateGraphQLSchema
+});

package/dist/cjs/generate/plugins/rw-typescript-resolvers/index.d.ts

@@ -0,0 +1,7 @@
+import type { Types, PluginFunction } from '@graphql-codegen/plugin-helpers';
+import type { TypeScriptResolversPluginConfig } from '@graphql-codegen/typescript-resolvers';
+import { RwTypeScriptResolversVisitor } from './visitor.js';
+export declare const plugin: PluginFunction<TypeScriptResolversPluginConfig, Types.ComplexPluginOutput>;
+export { RwTypeScriptResolversVisitor };
+export type { TypeScriptResolversPluginConfig };
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/generate/plugins/rw-typescript-resolvers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/generate/plugins/rw-typescript-resolvers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAK5E,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,uCAAuC,CAAA;AAI5F,OAAO,EAAE,4BAA4B,EAAE,MAAM,cAAc,CAAA;AAE3D,eAAO,MAAM,MAAM,EAAE,cAAc,CACjC,+BAA+B,EAC/B,KAAK,CAAC,mBAAmB,CA6E1B,CAAA;AAED,OAAO,EAAE,4BAA4B,EAAE,CAAA;AACvC,YAAY,EAAE,+BAA+B,EAAE,CAAA"}

package/dist/cjs/generate/plugins/rw-typescript-resolvers/index.js

@@ -0,0 +1,65 @@
+"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 rw_typescript_resolvers_exports = {};
+__export(rw_typescript_resolvers_exports, {
+  RwTypeScriptResolversVisitor: () => import_visitor.RwTypeScriptResolversVisitor,
+  plugin: () => plugin
+});
+module.exports = __toCommonJS(rw_typescript_resolvers_exports);
+var import_plugin_helpers = require("@graphql-codegen/plugin-helpers");
+var import_typescript_resolvers = require("@graphql-codegen/typescript-resolvers");
+var import_visitor = require("./visitor.js");
+const plugin = async (schema, _documents, config) => {
+  const visitor = new import_visitor.RwTypeScriptResolversVisitor(config, schema);
+  const visitorResult = (0, import_plugin_helpers.oldVisit)((0, import_plugin_helpers.getCachedDocumentNodeFromSchema)(schema), {
+    leave: visitor
+  });
+  const { prepend = [], content } = await (0, import_typescript_resolvers.plugin)(schema, [], config);
+  prepend.push(`export type OptArgsResolverFn<TResult, TParent = {}, TContext = {}, TArgs = {}> = (
+      args?: TArgs,
+      obj?: { root: TParent; context: TContext; info: GraphQLResolveInfo }
+    ) => TResult | Promise<TResult>
+
+    export type RequiredResolverFn<TResult, TParent = {}, TContext = {}, TArgs = {}> = (
+      args: TArgs,
+      obj: { root: TParent; context: TContext; info: GraphQLResolveInfo }
+    ) => TResult | Promise<TResult>`);
+  const splitContent = content.split("\n");
+  const visitorResultStart = splitContent.indexOf(
+    visitorResult.definitions.filter((d) => typeof d === "string")[0].split("\n")[0]
+  );
+  const splitRootResolver = visitor.getRootResolver().content.split("\n");
+  const visitorResultEnd = splitContent.findIndex(
+    (line, index) => line === splitRootResolver[0] && splitContent[index + 1] === splitRootResolver[1]
+  );
+  const newContent = [
+    ...splitContent.slice(0, visitorResultStart),
+    ...visitorResult.definitions.filter((d) => typeof d === "string"),
+    ...splitContent.slice(visitorResultEnd)
+  ];
+  return {
+    prepend,
+    content: newContent.join("\n")
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RwTypeScriptResolversVisitor,
+  plugin
+});

package/dist/cjs/generate/plugins/rw-typescript-resolvers/visitor.d.ts

@@ -0,0 +1,10 @@
+import type { TypeScriptResolversPluginConfig } from '@graphql-codegen/typescript-resolvers';
+import { TypeScriptResolversVisitor } from '@graphql-codegen/typescript-resolvers';
+import type { FieldDefinitionResult } from '@graphql-codegen/visitor-plugin-common';
+import type { FieldDefinitionNode, GraphQLSchema, ObjectTypeDefinitionNode } from 'graphql';
+export declare class RwTypeScriptResolversVisitor extends TypeScriptResolversVisitor {
+    constructor(pluginConfig: TypeScriptResolversPluginConfig, schema: GraphQLSchema);
+    FieldDefinition(node: FieldDefinitionNode, key: string | number, parent: any): FieldDefinitionResult;
+    ObjectTypeDefinition(node: ObjectTypeDefinitionNode): string | null;
+}
+//# sourceMappingURL=visitor.d.ts.map

package/dist/cjs/generate/plugins/rw-typescript-resolvers/visitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor.d.ts","sourceRoot":"","sources":["../../../../../src/generate/plugins/rw-typescript-resolvers/visitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,uCAAuC,CAAA;AAC5F,OAAO,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAA;AAElF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAA;AACnF,OAAO,KAAK,EACV,mBAAmB,EACnB,aAAa,EACb,wBAAwB,EACzB,MAAM,SAAS,CAAA;AAEhB,qBAAa,4BAA6B,SAAQ,0BAA0B;gBAExE,YAAY,EAAE,+BAA+B,EAC7C,MAAM,EAAE,aAAa;IAMvB,eAAe,CACb,IAAI,EAAE,mBAAmB,EACzB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,MAAM,EAAE,GAAG,GACV,qBAAqB;IAgCxB,oBAAoB,CAAC,IAAI,EAAE,wBAAwB,GAAG,MAAM,GAAG,IAAI;CA6FpE"}