@cedarjs/internal 0.0.4

package/dist/generate/graphqlCodeGen.js

@@ -0,0 +1,339 @@
+"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_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var addPlugin = __toESM(require("@graphql-codegen/add"));
+var import_cli = require("@graphql-codegen/cli");
+var import_core = require("@graphql-codegen/core");
+var typescriptPlugin = __toESM(require("@graphql-codegen/typescript"));
+var typescriptOperations = __toESM(require("@graphql-codegen/typescript-operations"));
+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"));
+var import_graphql = require("graphql");
+var import_project_config = require("@cedarjs/project-config");
+var import_project = require("../project");
+var rwTypescriptResolvers = __toESM(require("./plugins/rw-typescript-resolvers"));
+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.concat(output.paths);
+    } catch (e) {
+      if (e instanceof Error) {
+        errors.push({
+          message: e.message,
+          error: e
+        });
+      }
+    }
+    return {
+      typeDefFiles: dtsFiles,
+      errors
+    };
+  }
+  const filename = import_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 extraPlugins = [
+    {
+      name: "add",
+      options: {
+        content: [
+          'import { Prisma } from "@prisma/client"',
+          "import { MergePrismaWithSdlTypes, MakeRelationsOptional } from '@cedarjs/api'",
+          `import { ${prismaImports.join(", ")} } from '@prisma/client'`
+        ],
+        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_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 "@prisma/client"',
+        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 mergedConfig = {
+    ...await getPluginConfig(side),
+    ...userCodegenConfig?.config?.config
+  };
+  const options = getCodegenOptions(documents, mergedConfig, extraPlugins);
+  const output = await (0, import_core.codegen)(options);
+  import_fs.default.mkdirSync(import_path.default.dirname(filename), { recursive: true });
+  import_fs.default.writeFileSync(filename, output);
+  return [filename];
+}
+function getLoadDocumentsOptions(filename) {
+  const loadTypedefsConfig = {
+    cwd: (0, import_project_config.getPaths)().base,
+    ignore: [import_path.default.join(process.cwd(), filename)],
+    loaders: [new import_code_file_loader.CodeFileLoader()],
+    sort: true
+  };
+  return loadTypedefsConfig;
+}
+async function getPrismaClient(hasGenerated = false) {
+  const { default: localPrisma } = await import("@prisma/client");
+  if (!localPrisma.ModelName) {
+    if (hasGenerated) {
+      return { ModelName: {} };
+    } else {
+      import_execa.default.sync("yarn rw prisma generate", { shell: true });
+      Object.keys(require.cache).forEach((key) => {
+        if (key.includes("/node_modules/@prisma/client/") || key.includes("/node_modules/.prisma/client/")) {
+          delete require.cache[key];
+        }
+      });
+      return getPrismaClient(true);
+    }
+  }
+  return localPrisma;
+}
+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: "Buffer"
+  };
+  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#RedwoodGraphQLContext`
+  };
+  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/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/generate/graphqlSchema.d.ts.map

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

package/dist/generate/graphqlSchema.js

@@ -0,0 +1,153 @@
+"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_fs = __toESM(require("fs"));
+var import_core = require("@graphql-codegen/core");
+var schemaAstPlugin = __toESM(require("@graphql-codegen/schema-ast"));
+var import_code_file_loader = require("@graphql-tools/code-file-loader");
+var import_load = require("@graphql-tools/load");
+var import_internals = require("@prisma/internals");
+var import_chalk = __toESM(require("chalk"));
+var import_graphql = require("graphql");
+var import_terminal_link = __toESM(require("terminal-link"));
+var import_graphql_server = require("@cedarjs/graphql-server");
+var import_project_config = require("@cedarjs/project-config");
+const generateGraphQLSchema = async () => {
+  const redwoodProjectPaths = (0, import_project_config.getPaths)();
+  const redwoodProjectConfig = (0, import_project_config.getConfig)();
+  const schemaPointerMap = {
+    [(0, import_graphql.print)(import_graphql_server.rootSchema.schema)]: {},
+    "graphql/**/*.sdl.{js,ts}": {},
+    "directives/**/*.{js,ts}": {},
+    "subscriptions/**/*.{js,ts}": {}
+  };
+  for (const [name, schema] of Object.entries(import_graphql_server.rootSchema.scalarSchemas)) {
+    if (redwoodProjectConfig.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: redwoodProjectPaths.api.src,
+    schema: Object.keys(schemaPointerMap),
+    generates: {
+      [redwoodProjectPaths.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 schemaPrisma = (await (0, import_internals.getSchema)(redwoodProjectPaths.api.dbSchema)).toString();
+      const errorObject = {
+        message: `Schema loading failed. ${e.message}`,
+        error: e
+      };
+      errors.push(errorObject);
+      if (name && schemaPrisma.includes(`model ${name}`)) {
+        errorObject.message = [
+          errorObject.message,
+          "",
+          `  ${import_chalk.default.bgYellow(` ${import_chalk.default.black.bold("Heads up")} `)}`,
+          "",
+          import_chalk.default.yellow(
+            `  It looks like you have a ${name} model in your Prisma schema.`
+          ),
+          import_chalk.default.yellow(
+            `  If it's part of a relation, you may have to generate SDL or scaffolding for ${name} too.`
+          ),
+          import_chalk.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_chalk.default.yellow(
+            `  See the ${(0, import_terminal_link.default)(
+              "Troubleshooting Generators",
+              "https://redwoodjs.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: redwoodProjectPaths.generated.schema,
+    documents: []
+  };
+  if (loadedSchema) {
+    try {
+      const schema = await (0, import_core.codegen)(options);
+      import_fs.default.writeFileSync(redwoodProjectPaths.generated.schema, schema);
+      return { schemaPath: redwoodProjectPaths.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/generate/plugins/rw-typescript-resolvers/index.d.ts

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

package/dist/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,EACL,+BAA+B,EAEhC,MAAM,uCAAuC,CAAA;AAG9C,OAAO,EAAE,4BAA4B,EAAE,MAAM,WAAW,CAAA;AAExD,eAAO,MAAM,MAAM,EAAE,cAAc,CACjC,+BAA+B,EAC/B,KAAK,CAAC,mBAAmB,CAgF1B,CAAA;AAED,OAAO,EAAE,4BAA4B,EAAE,+BAA+B,EAAE,CAAA"}

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

@@ -0,0 +1,67 @@
+"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,
+  TypeScriptResolversPluginConfig: () => import_typescript_resolvers.TypeScriptResolversPluginConfig,
+  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");
+const plugin = (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 } = (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().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,
+  TypeScriptResolversPluginConfig,
+  plugin
+});

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

@@ -0,0 +1,9 @@
+import type { TypeScriptResolversPluginConfig } from '@graphql-codegen/typescript-resolvers';
+import { TypeScriptResolversVisitor } from '@graphql-codegen/typescript-resolvers';
+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): (parentName: string) => string | null;
+    ObjectTypeDefinition(node: ObjectTypeDefinitionNode): string;
+}
+//# sourceMappingURL=visitor.d.ts.map

package/dist/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;AAKlF,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;IAKvB,eAAe,CACb,IAAI,EAAE,mBAAmB,EACzB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,MAAM,EAAE,GAAG,GACV,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI;IAuBxC,oBAAoB,CAAC,IAAI,EAAE,wBAAwB,GAAG,MAAM;CAgG7D"}

package/dist/generate/plugins/rw-typescript-resolvers/visitor.js

@@ -0,0 +1,84 @@
+"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 visitor_exports = {};
+__export(visitor_exports, {
+  RwTypeScriptResolversVisitor: () => RwTypeScriptResolversVisitor
+});
+module.exports = __toCommonJS(visitor_exports);
+var import_typescript_resolvers = require("@graphql-codegen/typescript-resolvers");
+var import_visitor_plugin_common = require("@graphql-codegen/visitor-plugin-common");
+class RwTypeScriptResolversVisitor extends import_typescript_resolvers.TypeScriptResolversVisitor {
+  constructor(pluginConfig, schema) {
+    super(pluginConfig, schema);
+  }
+  FieldDefinition(node, key, parent) {
+    const hasArguments = node.arguments && node.arguments.length > 0;
+    const superFieldDefinition = super.FieldDefinition(node, key, parent);
+    return (parentName) => {
+      const fieldDef = superFieldDefinition(parentName);
+      if (!hasArguments && fieldDef?.includes(": Resolver<")) {
+        return fieldDef.replace(": Resolver<", ": OptArgsResolverFn<");
+      }
+      return fieldDef;
+    };
+  }
+  // Original implementation is here:
+  // https://github.com/dotansimha/graphql-code-generator/blob/c6c60a3078f3797af435c3852220d8898964031d/packages/plugins/other/visitor-plugin-common/src/base-resolvers-visitor.ts#L1091
+  ObjectTypeDefinition(node) {
+    const originalBlock = super.ObjectTypeDefinition(node);
+    const name = this.convertName(node, {
+      suffix: this.config.resolverTypeSuffix
+    });
+    const typeName = node.name;
+    const parentType = this.getParentTypeToUse(typeName);
+    const fieldsContent = (node.fields || []).map((f) => f(node.name));
+    const isRootType = [
+      this.schema.getQueryType()?.name,
+      this.schema.getMutationType()?.name,
+      this.schema.getSubscriptionType()?.name
+    ].includes(typeName);
+    if (!isRootType) {
+      fieldsContent.push(
+        (0, import_visitor_plugin_common.indent)(
+          `${this.config.internalResolversPrefix}isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>${this.getPunctuation(
+            "type"
+          )}`
+        )
+      );
+    }
+    const blockRelationsResolver = new import_visitor_plugin_common.DeclarationBlock(
+      this._declarationBlockConfig
+    ).export().asKind("type").withName(
+      name.replace("Resolvers", "RelationResolvers"),
+      `<ContextType = ${this.config.contextType.type}, ${this.transformParentGenericType(parentType)}>`
+    ).withBlock(
+      fieldsContent.map(
+        (content) => content.replace(
+          /: (?:OptArgs)?Resolver(?:Fn)?/,
+          "?: RequiredResolverFn"
+        )
+      ).join("\n")
+    );
+    return originalBlock + "\n" + blockRelationsResolver.string;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RwTypeScriptResolversVisitor
+});