@reliverse/rempts 1.7.29 → 1.7.31

package/bin/libs/launcher/trpc-orpc-support/index.js

@@ -0,0 +1,641 @@
+import * as trpcServer11 from "@trpc/server";
+import {
+  Argument,
+  Command as BaseCommand,
+  InvalidArgumentError,
+  Option
+} from "commander";
+import { inspect } from "node:util";
+import { addCompletions } from "./completions.js";
+import { FailedToExitError, CliValidationError } from "./errors.js";
+import { commandToJSON } from "./json.js";
+import {
+  flattenedProperties,
+  incompatiblePropertyPairs,
+  getDescription,
+  getSchemaTypes,
+  getEnumChoices
+} from "./json-schema.js";
+import { lineByLineConsoleLogger } from "./logging.js";
+import { parseProcedureInputs } from "./parse-procedure.js";
+import { promptify } from "./prompts.js";
+import { prettifyStandardSchemaError } from "./standard-schema/errors.js";
+import { looksLikeStandardSchemaFailure } from "./standard-schema/utils.js";
+import { isOrpcRouter } from "./trpc-compat.js";
+import { looksLikeInstanceof } from "./util.js";
+export * from "./types.js";
+export { z } from "zod/v4";
+export * as zod from "zod";
+export * as trpcServer from "@trpc/server";
+export class TrpcCommand extends BaseCommand {
+  /** @internal track the commands that have been run, so that we can find the `__result` of the last command */
+  __ran = [];
+  __input;
+  /** @internal stash the return value of the underlying procedure on the command so to pass to `FailedToExitError` for use in a pinch */
+  __result;
+}
+export const parseRouter = ({
+  router: router2,
+  ...params2
+}) => {
+  if (isOrpcRouter(router2)) return parseOrpcRouter({ router: router2, ...params2 });
+  return parseTrpcRouter({ router: router2, ...params2 });
+};
+const parseTrpcRouter = ({
+  router: router2,
+  ...params2
+}) => {
+  const defEntries = Object.entries(router2._def.procedures);
+  return defEntries.map(
+    ([procedurePath2, procedure2]) => {
+      const meta2 = getMeta(procedure2);
+      if (meta2.jsonInput) {
+        return [
+          procedurePath2,
+          {
+            meta: meta2,
+            parsedProcedure: jsonProcedureInputs(),
+            incompatiblePairs: [],
+            procedure: procedure2
+          }
+        ];
+      }
+      const procedureInputsResult = parseProcedureInputs(
+        procedure2._def.inputs,
+        params2
+      );
+      if (!procedureInputsResult.success) {
+        const procedureInputs2 = jsonProcedureInputs(
+          `procedure's schema couldn't be converted to CLI arguments: ${procedureInputsResult.error}`
+        );
+        return [
+          procedurePath2,
+          {
+            meta: meta2,
+            parsedProcedure: procedureInputs2,
+            incompatiblePairs: [],
+            procedure: procedure2
+          }
+        ];
+      }
+      const procedureInputs = procedureInputsResult.value;
+      const incompatiblePairs2 = incompatiblePropertyPairs(
+        procedureInputs.optionsJsonSchema
+      );
+      return [
+        procedurePath2,
+        {
+          meta: getMeta(procedure2),
+          parsedProcedure: procedureInputs,
+          incompatiblePairs: incompatiblePairs2,
+          procedure: procedure2
+        }
+      ];
+    }
+  );
+};
+const parseOrpcRouter = (params) => {
+  const entries = [];
+  const { traverseContractProcedures, isProcedure } = eval(
+    `require('@orpc/server')`
+  );
+  const router = params.router;
+  const lazyRoutes = traverseContractProcedures(
+    { path: [], router },
+    ({ contract, path }) => {
+      let procedure2 = params.router;
+      for (const p of path) procedure2 = procedure2[p];
+      if (!isProcedure(procedure2)) return;
+      const procedureInputsResult = parseProcedureInputs(
+        [contract["~orpc"].inputSchema],
+        {
+          "@valibot/to-json-schema": params["@valibot/to-json-schema"],
+          effect: params.effect
+        }
+      );
+      const procedurePath2 = path.join(".");
+      const procedureish = {
+        _def: { meta: contract["~orpc"].meta }
+      };
+      const meta2 = getMeta(procedureish);
+      if (meta2.jsonInput) {
+        entries.push([
+          procedurePath2,
+          {
+            meta: meta2,
+            parsedProcedure: jsonProcedureInputs(),
+            incompatiblePairs: [],
+            procedure: procedure2
+          }
+        ]);
+        return;
+      }
+      if (!procedureInputsResult.success) {
+        const parsedProcedure3 = jsonProcedureInputs(
+          `procedure's schema couldn't be converted to CLI arguments: ${procedureInputsResult.error}`
+        );
+        entries.push([
+          procedurePath2,
+          {
+            meta: meta2,
+            parsedProcedure: parsedProcedure3,
+            incompatiblePairs: [],
+            procedure: procedure2
+          }
+        ]);
+        return;
+      }
+      const parsedProcedure2 = procedureInputsResult.value;
+      const incompatiblePairs2 = incompatiblePropertyPairs(
+        parsedProcedure2.optionsJsonSchema
+      );
+      entries.push([
+        procedurePath2,
+        { procedure: procedure2, meta: meta2, incompatiblePairs: incompatiblePairs2, parsedProcedure: parsedProcedure2 }
+      ]);
+    }
+  );
+  if (lazyRoutes.length) {
+    const suggestion = `Please use \`import {unlazyRouter} from '@orpc/server'\` to unlazy the router before passing it to @reliverse/rempts`;
+    const routes = lazyRoutes.map(({ path }) => path.join(".")).join(", ");
+    throw new Error(
+      `Lazy routers are not supported. ${suggestion}. Lazy routes detected: ${routes}`
+    );
+  }
+  return entries;
+};
+const jsonProcedureInputs = (reason) => {
+  let description = "Input formatted as JSON";
+  if (reason) description += ` (${reason})`;
+  return {
+    positionalParameters: [],
+    optionsJsonSchema: {
+      type: "object",
+      properties: {
+        input: { type: "json", description }
+      }
+    },
+    getPojoInput: (parsedCliParams) => {
+      if (parsedCliParams.options.input == null)
+        return parsedCliParams.options.input;
+      return JSON.parse(parsedCliParams.options.input);
+    }
+  };
+};
+export function createRpcCli({
+  router,
+  ...params
+}) {
+  const procedureEntries = parseRouter({ router, ...params });
+  function buildProgram(runParams) {
+    const logger = { ...lineByLineConsoleLogger, ...runParams?.logger };
+    const program = new TrpcCommand(params.name);
+    if (params.version) program.version(params.version);
+    if (params.description) program.description(params.description);
+    if (params.usage)
+      [params.usage].flat().forEach((usage) => program.usage(usage));
+    program.showHelpAfterError();
+    program.showSuggestionAfterError();
+    const commandTree = {
+      "": program
+      // Root level
+    };
+    const defaultCommands = {};
+    const _process = runParams?.process || process;
+    const configureCommand = (command, procedurePath, { meta, parsedProcedure, incompatiblePairs, procedure }) => {
+      const optionJsonSchemaProperties = flattenedProperties(
+        parsedProcedure.optionsJsonSchema
+      );
+      command.exitOverride((ec) => {
+        _process.exit(ec.exitCode);
+        throw new FailedToExitError(`Command ${command.name()} exitOverride`, {
+          exitCode: ec.exitCode,
+          cause: ec
+        });
+      });
+      command.configureOutput({
+        writeOut: (str) => {
+          logger.info?.(str);
+        },
+        writeErr: (str) => {
+          logger.error?.(str);
+        }
+      });
+      command.showHelpAfterError();
+      if (meta.usage) command.usage([meta.usage].flat().join("\n"));
+      if (meta.examples)
+        command.addHelpText(
+          "after",
+          `
+Examples:
+${[meta.examples].flat().join("\n")}`
+        );
+      meta?.aliases?.command?.forEach((alias) => {
+        command.alias(alias);
+      });
+      command.description(meta?.description || "");
+      parsedProcedure.positionalParameters.forEach((param) => {
+        const descriptionParts = [
+          param.type === "string" ? "" : param.type,
+          // "string" is the default assumption, don't bother showing it
+          param.description,
+          param.required ? "(required)" : ""
+        ];
+        const argument = new Argument(
+          param.name,
+          descriptionParts.filter(Boolean).join(" ")
+        );
+        if (param.type === "number") {
+          argument.argParser((value) => {
+            const number = numberParser(value, { fallback: null });
+            if (number == null)
+              throw new InvalidArgumentError(`Invalid number: ${value}`);
+            return value;
+          });
+        }
+        argument.required = param.required;
+        argument.variadic = param.array;
+        command.addArgument(argument);
+      });
+      const unusedOptionAliases = {
+        ...meta.aliases?.options
+      };
+      const addOptionForProperty = ([propertyKey, propertyValue]) => {
+        const description = getDescription(propertyValue);
+        const longOption = `--${kebabCase(propertyKey)}`;
+        let flags = longOption;
+        const alias = meta.aliases?.options?.[propertyKey];
+        if (alias) {
+          let prefix = "-";
+          if (alias.startsWith("-")) prefix = "";
+          else if (alias.length > 1) prefix = "--";
+          flags = `${prefix}${alias}, ${flags}`;
+          delete unusedOptionAliases[propertyKey];
+        }
+        const defaultValue = "default" in propertyValue ? { exists: true, value: propertyValue.default } : { exists: false };
+        const rootTypes = getSchemaTypes(propertyValue).sort();
+        const getValueParser = (types) => {
+          types = types.map((t) => t === "integer" ? "number" : t);
+          if (types.length === 2 && types[0] === "boolean" && types[1] === "number") {
+            return {
+              type: "boolean|number",
+              parser: (value) => booleanParser(value, { fallback: null }) ?? numberParser(value)
+            };
+          }
+          if (types.length === 1 && types[0] === "boolean") {
+            return {
+              type: "boolean",
+              parser: (value) => booleanParser(value)
+            };
+          }
+          if (types.length === 1 && types[0] === "number") {
+            return {
+              type: "number",
+              parser: (value) => numberParser(value)
+            };
+          }
+          if (types.length === 1 && types[0] === "string") {
+            return { type: "string", parser: null };
+          }
+          return {
+            type: "json",
+            parser: (value) => {
+              let parsed;
+              try {
+                parsed = JSON.parse(value);
+              } catch {
+                throw new InvalidArgumentError("Malformed JSON.");
+              }
+              const jsonSchemaType = Array.isArray(parsed) ? "array" : parsed === null ? "null" : typeof parsed;
+              if (!types.includes(jsonSchemaType)) {
+                throw new InvalidArgumentError(
+                  `Got ${jsonSchemaType} but expected ${types.join(" or ")}`
+                );
+              }
+              return parsed;
+            }
+          };
+        };
+        const propertyType = rootTypes[0];
+        const isValueRequired = "required" in parsedProcedure.optionsJsonSchema && parsedProcedure.optionsJsonSchema.required?.includes(propertyKey);
+        const isCliOptionRequired = isValueRequired && propertyType !== "boolean" && !defaultValue.exists;
+        function negate() {
+          const negation = new Option(
+            longOption.replace("--", "--no-"),
+            `Negate \`${longOption}\` option.`.trim()
+          );
+          command.addOption(negation);
+        }
+        const bracketise = (name) => isCliOptionRequired ? `<${name}>` : `[${name}]`;
+        if (rootTypes.length === 2 && rootTypes[0] === "boolean" && rootTypes[1] === "string") {
+          const option2 = new Option(`${flags} [value]`, description);
+          option2.default(defaultValue.exists ? defaultValue.value : false);
+          command.addOption(option2);
+          negate();
+          return;
+        }
+        if (rootTypes.length === 2 && rootTypes[0] === "boolean" && rootTypes[1] === "number") {
+          const option2 = new Option(`${flags} [value]`, description);
+          option2.argParser(getValueParser(rootTypes).parser);
+          option2.default(defaultValue.exists ? defaultValue.value : false);
+          command.addOption(option2);
+          negate();
+          return;
+        }
+        if (rootTypes.length === 2 && rootTypes[0] === "number" && rootTypes[1] === "string") {
+          const option2 = new Option(
+            `${flags} ${bracketise("value")}`,
+            description
+          );
+          option2.argParser((value) => {
+            const number = numberParser(value, { fallback: null });
+            return number ?? value;
+          });
+          if (defaultValue.exists) option2.default(defaultValue.value);
+          command.addOption(option2);
+          return;
+        }
+        if (rootTypes.length !== 1) {
+          const option2 = new Option(
+            `${flags} ${bracketise("json")}`,
+            `${description} (value will be parsed as JSON)`
+          );
+          option2.argParser(getValueParser(rootTypes).parser);
+          command.addOption(option2);
+          return;
+        }
+        if (propertyType === "boolean" && isValueRequired) {
+          const option2 = new Option(flags, description);
+          option2.default(defaultValue.exists ? defaultValue.value : false);
+          command.addOption(option2);
+          negate();
+          return;
+        }
+        if (propertyType === "boolean") {
+          const option2 = new Option(`${flags} [boolean]`, description);
+          option2.argParser((value) => booleanParser(value));
+          if (defaultValue.exists) option2.default(defaultValue.value);
+          command.addOption(option2);
+          negate();
+          return;
+        }
+        let option;
+        if (propertyType === "string") {
+          option = new Option(`${flags} ${bracketise("string")}`, description);
+        } else if (propertyType === "boolean") {
+          option = new Option(flags, description);
+        } else if (propertyType === "number" || propertyType === "integer") {
+          option = new Option(`${flags} ${bracketise("number")}`, description);
+          option.argParser((value) => numberParser(value, { fallback: null }));
+        } else if (propertyType === "array") {
+          option = new Option(`${flags} [values...]`, description);
+          if (defaultValue.exists) option.default(defaultValue.value);
+          else if (isValueRequired) option.default([]);
+          const itemsProp = "items" in propertyValue ? propertyValue.items : null;
+          const itemTypes = itemsProp ? getSchemaTypes(itemsProp) : [];
+          const itemEnumTypes = itemsProp && getEnumChoices(itemsProp);
+          if (itemEnumTypes?.type === "string_enum") {
+            option.choices(itemEnumTypes.choices);
+          }
+          const itemParser = getValueParser(itemTypes);
+          if (itemParser.parser) {
+            option.argParser((value, previous) => {
+              const parsed = itemParser.parser(value);
+              if (Array.isArray(previous))
+                return [...previous, parsed];
+              return [parsed];
+            });
+          }
+        }
+        option ||= new Option(`${flags} [json]`, description);
+        if (defaultValue.exists && option.defaultValue !== defaultValue.value) {
+          option.default(defaultValue.value);
+        }
+        if (option.flags.includes("<")) {
+          option.makeOptionMandatory();
+        }
+        const enumChoices = getEnumChoices(propertyValue);
+        if (enumChoices?.type === "string_enum") {
+          option.choices(enumChoices.choices);
+        }
+        option.conflicts(
+          incompatiblePairs.flatMap((pair) => {
+            const filtered = pair.filter((p) => p !== propertyKey);
+            if (filtered.length === pair.length) return [];
+            return filtered;
+          })
+        );
+        command.addOption(option);
+        if (propertyType === "boolean") negate();
+      };
+      Object.entries(optionJsonSchemaProperties).forEach(addOptionForProperty);
+      const invalidOptionAliases = Object.entries(unusedOptionAliases).map(
+        ([option, alias]) => `${option}: ${alias}`
+      );
+      if (invalidOptionAliases.length) {
+        throw new Error(
+          `Invalid option aliases: ${invalidOptionAliases.join(", ")}`
+        );
+      }
+      command.action(async (...args) => {
+        program.__ran ||= [];
+        program.__ran.push(command);
+        const options = command.opts();
+        if (args.at(-2) !== options) {
+          throw new Error(
+            "Unexpected args format, second last arg is not the options object",
+            { cause: args }
+          );
+        }
+        if (args.at(-1) !== command) {
+          throw new Error(
+            "Unexpected args format, last arg is not the Command instance",
+            { cause: args }
+          );
+        }
+        const positionalValues = args.slice(0, -2);
+        const input = parsedProcedure.getPojoInput({
+          positionalValues,
+          options
+        });
+        const resolvedTrpcServer = await (params.trpcServer || trpcServer11);
+        let caller;
+        const deprecatedCreateCaller = Reflect.get(
+          params,
+          "createCallerFactory"
+        );
+        if (deprecatedCreateCaller) {
+          const message = `Using deprecated \`createCallerFactory\` option. Use \`trpcServer\` instead. e.g. \`createRpcCli({router: myRouter, trpcServer: import('@trpc/server')})\``;
+          logger.error?.(message);
+          caller = deprecatedCreateCaller(router)(params.context);
+        } else if (isOrpcRouter(router)) {
+          const { call } = eval(
+            `require('@orpc/server')`
+          );
+          caller = {
+            [procedurePath]: (_input) => call(procedure, _input, { context: params.context })
+          };
+        } else {
+          const createCallerFactor = resolvedTrpcServer.initTRPC.create().createCallerFactory;
+          caller = createCallerFactor(router)(params.context);
+        }
+        const result = await (caller[procedurePath]?.(input)).catch((err) => {
+          throw transformError(err, command);
+        });
+        command.__result = result;
+        if (result != null) logger.info?.(result);
+      });
+    };
+    procedureEntries.forEach(([procedurePath2, commandConfig]) => {
+      const segments = procedurePath2.split(".");
+      let currentPath = "";
+      for (let i = 0; i < segments.length - 1; i++) {
+        const segment = segments[i];
+        if (!segment) continue;
+        const parentPath2 = currentPath;
+        currentPath = currentPath ? `${currentPath}.${segment}` : segment;
+        if (!commandTree[currentPath]) {
+          const parentCommand2 = commandTree[parentPath2];
+          if (!parentCommand2) continue;
+          const newCommand = new TrpcCommand(kebabCase(segment));
+          newCommand.showHelpAfterError();
+          parentCommand2.addCommand(newCommand);
+          commandTree[currentPath] = newCommand;
+        }
+      }
+      const leafName = segments.at(-1);
+      if (!leafName) return;
+      const parentPath = segments.length > 1 ? segments.slice(0, -1).join(".") : "";
+      const parentCommand = commandTree[parentPath];
+      if (!parentCommand) return;
+      const leafCommand = new TrpcCommand(kebabCase(leafName));
+      configureCommand(leafCommand, procedurePath2, commandConfig);
+      parentCommand.addCommand(leafCommand);
+      const meta2 = commandConfig.meta;
+      if (meta2.default === true) {
+        parentCommand.allowExcessArguments();
+        parentCommand.allowUnknownOption();
+        parentCommand.addHelpText("after", leafCommand.helpInformation());
+        parentCommand.action(async () => {
+          await leafCommand.parseAsync([...parentCommand.args], {
+            from: "user"
+          });
+        });
+        defaultCommands[parentPath] = {
+          procedurePath: procedurePath2,
+          config: commandConfig,
+          command: leafCommand
+        };
+      }
+    });
+    Object.entries(commandTree).forEach(([path, command2]) => {
+      if (command2.commands.length === 0) return;
+      const subcommandNames = command2.commands.map((cmd) => cmd.name());
+      const defaultCommand = defaultCommands[path]?.command.name();
+      const formattedSubcommands = subcommandNames.map((name) => name === defaultCommand ? `${name} (default)` : name).join(", ");
+      const existingDescription = command2.description() || "";
+      const descriptionParts = [
+        existingDescription,
+        `Available subcommands: ${formattedSubcommands}`
+      ];
+      command2.description(descriptionParts.filter(Boolean).join("\n"));
+    });
+    return program;
+  }
+  const run = async (runParams2, program2 = buildProgram(runParams2)) => {
+    if (!looksLikeInstanceof(program2, "TrpcCommand"))
+      throw new Error("program is not a TrpcCommand instance");
+    const opts = runParams2?.argv ? { from: "user" } : void 0;
+    const argv = [...runParams2?.argv || process.argv];
+    const _process2 = runParams2?.process || process;
+    const logger2 = { ...lineByLineConsoleLogger, ...runParams2?.logger };
+    program2.exitOverride((exit) => {
+      _process2.exit(exit.exitCode);
+      throw new FailedToExitError("Root command exitOverride", {
+        exitCode: exit.exitCode,
+        cause: exit
+      });
+    });
+    program2.configureOutput({
+      writeOut: (str) => logger2.info?.(str),
+      writeErr: (str) => logger2.error?.(str)
+    });
+    if (runParams2?.completion) {
+      const completion = typeof runParams2.completion === "function" ? await runParams2.completion() : runParams2.completion;
+      addCompletions(program2, completion);
+    }
+    const formatError = runParams2?.formatError || ((err) => {
+      if (err instanceof CliValidationError) {
+        return err.message;
+      }
+      return inspect(err);
+    });
+    if (runParams2?.prompts) {
+      program2 = promptify(program2, runParams2.prompts);
+    }
+    await program2.parseAsync(argv, opts).catch((err) => {
+      if (err instanceof FailedToExitError) throw err;
+      const logMessage = looksLikeInstanceof(err, Error) ? formatError(err) || err.message : `Non-error of type ${typeof err} thrown: ${err}`;
+      logger2.error?.(logMessage);
+      _process2.exit(1);
+      throw new FailedToExitError("Program exit after failure", {
+        exitCode: 1,
+        cause: err
+      });
+    });
+    _process2.exit(0);
+    throw new FailedToExitError("Program exit after success", {
+      exitCode: 0,
+      cause: program2.__ran.at(-1)?.__result
+    });
+  };
+  return {
+    run,
+    buildProgram,
+    toJSON: (program2 = buildProgram()) => commandToJSON(program2)
+  };
+}
+function getMeta(procedure2) {
+  const meta2 = procedure2._def.meta;
+  return meta2?.cliMeta || meta2 || {};
+}
+function kebabCase(propName) {
+  return propName.replaceAll(/([A-Z])/g, "-$1").toLowerCase();
+}
+function transformError(err, command2) {
+  if (looksLikeInstanceof(err, Error) && err.message.includes("This is a client-only function")) {
+    return new Error(
+      "Failed to create trpc caller. If using trpc v10, either upgrade to v11 or pass in the `@trpc/server` module to `createRpcCli` explicitly"
+    );
+  }
+  if (looksLikeInstanceof(err, "TRPCError")) {
+    const cause = err.cause;
+    if (looksLikeStandardSchemaFailure(cause)) {
+      const prettyMessage = prettifyStandardSchemaError(cause);
+      return new CliValidationError(
+        `${prettyMessage}
+${command2.helpInformation()}`
+      );
+    }
+    if (err.code === "BAD_REQUEST" && (err.cause?.constructor?.name === "TraversalError" || // arktype error
+    err.cause?.constructor?.name === "StandardSchemaV1Error")) {
+      return new CliValidationError(
+        `${err.cause.message}
+${command2.helpInformation()}`
+      );
+    }
+    if (err.code === "INTERNAL_SERVER_ERROR") {
+      return cause;
+    }
+  }
+  return err;
+}
+const numberParser = (val, { fallback = val } = {}) => {
+  const number = Number(val);
+  return Number.isNaN(number) ? fallback : number;
+};
+const booleanParser = (val, { fallback = val } = {}) => {
+  if (val === "true") return true;
+  if (val === "false") return false;
+  return fallback;
+};

package/bin/libs/launcher/trpc-orpc-support/json-schema.d.ts

@@ -0,0 +1,17 @@
+import type { JsonSchema7ObjectType, JsonSchema7Type } from "zod-to-json-schema";
+export declare const flattenedProperties: (sch: JsonSchema7Type) => JsonSchema7ObjectType["properties"];
+/** For a union type, returns a list of pairs of properties which *shouldn't* be used together (because they don't appear in the same type variant) */
+export declare const incompatiblePropertyPairs: (sch: JsonSchema7Type) => [string, string][];
+/**
+ * Tries fairly hard to build a roughly human-readable description of a json-schema type.
+ * A few common properties are given special treatment, most others are just stringified and output in `key: value` format.
+ */
+export declare const getDescription: (v: JsonSchema7Type, depth?: number) => string;
+export declare const getSchemaTypes: (propertyValue: JsonSchema7Type) => ("string" | "boolean" | "number" | (string & {}))[];
+export declare const getEnumChoices: (propertyValue: JsonSchema7Type) => {
+    readonly type: "string_enum";
+    readonly choices: string[];
+} | {
+    readonly type: "number_enum";
+    readonly choices: number[];
+} | null;