@reliverse/rempts 1.7.28 → 1.7.30

package/bin/{components → libs}/launcher/launcher-types.d.ts

@@ -1,18 +1,17 @@
 export type EmptyArgs = Record<string, never>;
-export type BaseArgProps = {
+export interface BaseArgProps {
     description?: string;
     required?: boolean;
     allowed?: string[];
-};
-export type BaseArgDefinition = {
+}
+export interface BaseArgDefinition {
     type: string;
     description?: string;
     required?: boolean;
     default?: any;
     allowed?: any[];
     dependencies?: string[];
-    useTsType?: unknown;
-};
+}
 export type PositionalArgDefinition = BaseArgDefinition & {
     type: "positional";
     default?: string;
@@ -41,13 +40,13 @@ export type ArrayArgDefinition = BaseArgDefinition & {
 };
 export type ArgDefinition = PositionalArgDefinition | BooleanArgDefinition | StringArgDefinition | NumberArgDefinition | ArrayArgDefinition;
 export type ArgDefinitions = Record<string, ArgDefinition>;
-export type CommandMeta = {
+export interface CommandMeta {
     name: string;
     version?: string;
     description?: string;
     hidden?: boolean;
     aliases?: string[];
-};
+}
 /**
  * A subcommand can be either:
  * 1) A string path to a module with a default export of type Command.
@@ -58,13 +57,13 @@ export type CommandSpec = string | (() => Promise<{
     default: Command<any>;
 } | Command<any>>);
 export type CommandsMap = Record<string, CommandSpec>;
-export type CommandContext<ARGS> = {
+export interface CommandContext<ARGS> {
     args: ARGS;
     raw: string[];
-};
+}
 export type CommandRun<ARGS> = (ctx: CommandContext<ARGS>) => void | Promise<void>;
 export type CommandHook<ARGS> = (ctx: CommandContext<ARGS>) => void | Promise<void>;
-export type DefineCommandOptions<A extends ArgDefinitions = EmptyArgs> = {
+export interface DefineCommandOptions<A extends ArgDefinitions = EmptyArgs> {
     meta?: CommandMeta;
     args?: A;
     run?: CommandRun<InferArgTypes<A>>;
@@ -100,8 +99,8 @@ export type DefineCommandOptions<A extends ArgDefinitions = EmptyArgs> = {
      * Called once per CLI process, after all command/run() logic is finished
      */
     onLauncherExit?: () => void | Promise<void>;
-};
-export type Command<A extends ArgDefinitions = EmptyArgs> = {
+}
+export interface Command<A extends ArgDefinitions = EmptyArgs> {
     meta?: CommandMeta;
     args: A;
     run?: CommandRun<InferArgTypes<A>>;
@@ -137,15 +136,13 @@ export type Command<A extends ArgDefinitions = EmptyArgs> = {
      * Called once per CLI process, after all command/run() logic is finished
      */
     onLauncherExit?: () => void | Promise<void>;
-};
+}
 export type InferArgTypes<A extends ArgDefinitions> = {
-    [K in keyof A]: A[K] extends {
-        useTsType: infer T;
-    } ? T : A[K] extends PositionalArgDefinition ? string : A[K] extends BooleanArgDefinition ? boolean : A[K] extends StringArgDefinition ? string : A[K] extends NumberArgDefinition ? number : A[K] extends {
+    [K in keyof A]: A[K] extends PositionalArgDefinition ? string : A[K] extends BooleanArgDefinition ? boolean : A[K] extends StringArgDefinition ? string : A[K] extends NumberArgDefinition ? number : A[K] extends {
         type: "array";
     } ? string[] : never;
 };
-export type FileBasedCmdsOptions = {
+export interface FileBasedOptions {
     enable: boolean;
     cmdsRootPath: string;
-};
+}

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

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { OmeletteInstanceLike } from "./types";
+/** uses omelette to add completions to a commander program */
+export declare function addCompletions(program: Command, completion: OmeletteInstanceLike): void;

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

@@ -0,0 +1,45 @@
+export function addCompletions(program, completion) {
+  const commandSymbol = Symbol("command");
+  const cTree = {};
+  function addCommandCompletions(command, cTreeNode) {
+    command.commands.forEach((c) => {
+      const node = cTreeNode[c.name()] ||= {};
+      Object.defineProperty(node, commandSymbol, {
+        value: c,
+        enumerable: false
+      });
+      addCommandCompletions(c, node);
+    });
+  }
+  addCommandCompletions(program, cTree);
+  completion.on("complete", (fragment, params) => {
+    const segments = params.line.split(/ +/).slice(1, params.fragment);
+    const last = segments.at(-1);
+    let node = cTree;
+    const existingFlags = /* @__PURE__ */ new Set();
+    for (const segment of segments) {
+      if (segment.startsWith("-")) {
+        existingFlags.add(segment);
+        continue;
+      }
+      if (existingFlags.size > 0) continue;
+      node = node[segment];
+      if (!node) return;
+    }
+    const correspondingCommand = node[commandSymbol];
+    if (correspondingCommand?.options?.length) {
+      const suggestions = [];
+      for (const o of correspondingCommand.options) {
+        if (last === o.long || last === o.short) {
+          if (o.argChoices) suggestions.push(...o.argChoices);
+          if (!o.isBoolean()) break;
+        }
+        if (existingFlags.has(o.long)) continue;
+        if (existingFlags.has(o.short)) continue;
+        suggestions.push(o.long);
+      }
+      return params.reply(suggestions);
+    }
+  });
+  completion.tree(cTree).init();
+}

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

@@ -0,0 +1,11 @@
+/** An error thrown when the trpc procedure results in a bad request */
+export declare class CliValidationError extends Error {
+}
+/** An error which is only thrown when a custom \`process\` parameter is used. Under normal circumstances, this should not be used, even internally. */
+export declare class FailedToExitError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, { exitCode, cause }: {
+        exitCode: number;
+        cause: unknown;
+    });
+}

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

@@ -0,0 +1,10 @@
+export class CliValidationError extends Error {
+}
+export class FailedToExitError extends Error {
+  exitCode;
+  constructor(message, { exitCode, cause }) {
+    const fullMessage = `${message}. The process was expected to exit with exit code ${exitCode} but did not. This may be because a custom \`process\` parameter was used. The exit reason is in the \`cause\` property.`;
+    super(fullMessage, { cause });
+    this.exitCode = exitCode;
+  }
+}

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

@@ -0,0 +1,34 @@
+import { Command as BaseCommand } from "commander";
+import type { AnyRouter } from "./trpc-compat";
+import type { ParsedProcedure, TrpcCli, TrpcCliMeta, TrpcCliParams } from "./types";
+export * from "./types";
+export { z } from "zod/v4";
+export * as zod from "zod";
+export * as trpcServer from "@trpc/server";
+export declare class TrpcCommand extends BaseCommand {
+    /** @internal track the commands that have been run, so that we can find the `__result` of the last command */
+    __ran: TrpcCommand[];
+    __input?: unknown;
+    /** @internal stash the return value of the underlying procedure on the command so to pass to `FailedToExitError` for use in a pinch */
+    __result?: unknown;
+}
+/**
+ * @internal takes a trpc router and returns an object that you **could** use to build a CLI, or UI, or a bunch of other things with.
+ * Officially, just internal for building a CLI. GLHF.
+ */
+export declare const parseRouter: <R extends AnyRouter>({ router, ...params }: TrpcCliParams<R>) => [string, ProcedureInfo][];
+interface ProcedureInfo {
+    meta: TrpcCliMeta;
+    parsedProcedure: ParsedProcedure;
+    incompatiblePairs: [string, string][];
+    procedure: {};
+}
+/**
+ * Run a trpc router as a CLI.
+ *
+ * @param router A trpc router
+ * @param context The context to use when calling the procedures - needed if your router requires a context
+ * @param trpcServer The trpc server module to use. Only needed if using trpc v10.
+ * @returns A CLI object with a `run` method that can be called to run the CLI. The `run` method will parse the command line arguments, call the appropriate trpc procedure, log the result and exit the process. On error, it will log the error and exit with a non-zero exit code.
+ */
+export declare function createRpcCli<R extends AnyRouter>({ router, ...params }: TrpcCliParams<R>): TrpcCli;