@reliverse/rempts 1.7.44 → 1.7.46

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

@@ -1,641 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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;