@reliverse/rempts 1.7.29 → 1.7.30

package/bin/libs/launcher/trpc-orpc-support/parse-procedure.js

@@ -0,0 +1,486 @@
+import { inspect } from "node:util";
+import zodToJsonSchema from "zod-to-json-schema";
+import * as zod4 from "zod/v4/core";
+import { CliValidationError } from "./errors.js";
+import { getSchemaTypes } from "./json-schema.js";
+function toJsonSchema(input2, dependencies2) {
+  try {
+    const jsonSchemaConverters = getJsonSchemaConverters(dependencies2);
+    const vendor = getVendor(input2);
+    if (vendor && vendor in jsonSchemaConverters) {
+      const converter = jsonSchemaConverters[vendor];
+      const converted = converter(input2);
+      return { success: true, value: converted };
+    }
+    return { success: false, error: "Schema not convertible to JSON schema" };
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    return {
+      success: false,
+      error: `Failed to convert input to JSON Schema: ${message}`
+    };
+  }
+}
+function looksLikeJsonSchema(value) {
+  return typeof value === "object" && value !== null && ("type" in value && (typeof value.type === "string" || Array.isArray(value.type)) || "const" in value || "oneOf" in value || "anyOf" in value);
+}
+export function parseProcedureInputs(inputs, dependencies2) {
+  if (inputs.length === 0) {
+    return {
+      success: true,
+      value: {
+        positionalParameters: [],
+        optionsJsonSchema: {},
+        getPojoInput: () => ({})
+      }
+    };
+  }
+  const allJsonSchemaable = inputs.every((input2) => looksJsonSchemaable(input2));
+  if (!allJsonSchemaable) {
+    return {
+      success: false,
+      error: `Invalid input type ${inputs.map((s) => s?.constructor.name).join(", ")}, only inputs that can be converted to JSON Schema are supported`
+    };
+  }
+  if (inputs.length > 1) {
+    return parseMultiInputs(inputs, dependencies2);
+  }
+  const mergedSchemaResult = toJsonSchema(inputs[0], dependencies2);
+  if (!mergedSchemaResult.success) {
+    return {
+      success: false,
+      error: mergedSchemaResult.error
+    };
+  }
+  const mergedSchema = mergedSchemaResult.value;
+  return handleMergedSchema(mergedSchema);
+}
+function handleMergedSchema(mergedSchema) {
+  if (mergedSchema.additionalProperties) {
+    return {
+      success: false,
+      error: "Inputs with additional properties are not currently supported"
+    };
+  }
+  if (mergedSchema.type === "string") {
+    return {
+      success: true,
+      value: {
+        positionalParameters: [
+          {
+            type: "string",
+            array: false,
+            description: mergedSchema.description || "",
+            name: mergedSchema.title || "string",
+            required: !isOptional(mergedSchema)
+          }
+        ],
+        optionsJsonSchema: {},
+        getPojoInput: (argv) => argv.positionalValues[0]
+      }
+    };
+  }
+  if (acceptedPrimitiveTypes(mergedSchema).length > 0) {
+    return parsePrimitiveInput(mergedSchema);
+  }
+  if (isTuple(mergedSchema)) {
+    return parseTupleInput(mergedSchema);
+  }
+  if (mergedSchema.type === "array") {
+    return parseArrayInput(
+      mergedSchema
+    );
+  }
+  if (mergedSchema.anyOf) {
+    const allObjects = mergedSchema.anyOf.every(
+      (sub) => acceptsObject(toRoughJsonSchema7(sub))
+    );
+    if (allObjects) {
+      return {
+        success: true,
+        value: {
+          positionalParameters: [],
+          optionsJsonSchema: mergedSchema,
+          getPojoInput: (argv) => argv.options
+        }
+      };
+    }
+    if (mergedSchema.anyOf.length === 2 && JSON.stringify(mergedSchema.anyOf[0]) === '{"not":{}}') {
+      return handleMergedSchema(mergedSchema.anyOf[1]);
+    }
+  }
+  if (mergedSchema.type !== "object") {
+    return {
+      success: false,
+      error: `Invalid input type ${inspect(mergedSchema, { depth: 2, breakLength: Number.POSITIVE_INFINITY })}, expected object or tuple.`
+    };
+  }
+  return {
+    success: true,
+    value: {
+      positionalParameters: [],
+      optionsJsonSchema: mergedSchema,
+      getPojoInput: (argv) => argv.options
+    }
+  };
+}
+function isOptional(schema) {
+  if (schema && typeof schema === "object" && "optional" in schema)
+    return schema.optional === true;
+  const anyOf = schemaDefPropValue(schema, "anyOf");
+  if (anyOf?.length === 2 && JSON.stringify(anyOf[0]) === '{"not":{}}')
+    return true;
+  if (anyOf?.some((sub) => isOptional(sub))) return true;
+  return false;
+}
+function parsePrimitiveInput(schema) {
+  const typeName = acceptedPrimitiveTypes(schema).join(" | ");
+  const name = (schema.title || schema.description || /\W/.test(typeName) ? "value" : typeName).replaceAll(/\s+/g, "_");
+  return {
+    success: true,
+    value: {
+      positionalParameters: [
+        {
+          name,
+          array: false,
+          description: schema.description || "",
+          required: !isOptional(schema),
+          type: typeName
+        }
+      ],
+      optionsJsonSchema: {},
+      getPojoInput: (argv) => convertPositional(schema, argv.positionalValues[0])
+    }
+  };
+}
+const schemaDefPropValue = (schema, prop) => {
+  if (schema && typeof schema === "object" && prop in schema)
+    return schema[prop];
+  return void 0;
+};
+const primitiveCandidateTypes = [
+  "string",
+  "number",
+  "boolean",
+  "integer"
+];
+function acceptedPrimitiveTypes(schema) {
+  let constVals = [
+    toRoughJsonSchema7(schema).const,
+    toRoughJsonSchema7(schema).enum
+  ].flat().filter(Boolean).map((s) => typeof s);
+  if (constVals.length === 0) constVals = void 0;
+  const typeList = constVals || schemaDefPropValue(schema, "type") || schemaDefPropValue(schema, "oneOf")?.flatMap(
+    (s) => acceptedPrimitiveTypes(s)
+  ) || schemaDefPropValue(schema, "anyOf")?.flatMap(
+    (s) => acceptedPrimitiveTypes(s)
+  );
+  const acceptedJsonSchemaTypes = new Set([typeList].flat().filter(Boolean));
+  return primitiveCandidateTypes.filter((c) => acceptedJsonSchemaTypes.has(c));
+}
+function parseMultiInputs(inputs, dependencies2) {
+  const parsedIndividually = inputs.map(
+    (input2) => parseProcedureInputs([input2], dependencies2)
+  );
+  const failures = parsedIndividually.flatMap(
+    (p) => p.success ? [] : [p.error]
+  );
+  if (failures.length > 0) {
+    return { success: false, error: failures.join("\n") };
+  }
+  const allObjects = parsedIndividually.every(
+    (p) => p.success && p.value.positionalParameters.length === 0
+  );
+  if (!allObjects) {
+    return {
+      success: false,
+      error: `Can't use positional parameters with multi-input type.`
+    };
+  }
+  return {
+    success: true,
+    value: {
+      positionalParameters: [],
+      optionsJsonSchema: {
+        allOf: parsedIndividually.map((p) => {
+          const successful = p;
+          const optionsSchema = successful.value.optionsJsonSchema;
+          if ("additionalProperties" in optionsSchema && optionsSchema.additionalProperties === false) {
+            const { additionalProperties, ...rest } = optionsSchema;
+            return rest;
+          }
+          return optionsSchema;
+        })
+      },
+      getPojoInput: (argv) => argv.options
+    }
+  };
+}
+function isNullable(schema) {
+  if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
+  if (schema.type === "null") return true;
+  if ((schema.anyOf || schema.oneOf)?.some(
+    (sub) => isNullable(toRoughJsonSchema7(sub))
+  ))
+    return true;
+  if (schema.const === null) return true;
+  return false;
+}
+const tupleItemsSchemas = (schema) => {
+  if (!schema || typeof schema !== "object") return void 0;
+  if (Array.isArray(schema.items)) return schema.items;
+  if ("prefixItems" in schema && Array.isArray(schema.prefixItems))
+    return schema.prefixItems;
+  return void 0;
+};
+function isTuple(schema) {
+  return Array.isArray(tupleItemsSchemas(schema));
+}
+function parseArrayInput(array) {
+  if (looksLikeJsonSchema(array.items) && isNullable(array.items)) {
+    return {
+      success: false,
+      error: `Invalid input type Array<${getSchemaTypes(array.items).join(" | ")}>. Nullable arrays are not supported.`
+    };
+  }
+  return {
+    success: true,
+    value: {
+      positionalParameters: [
+        {
+          name: parameterName(array, 1),
+          array: true,
+          description: array.description || "",
+          required: !isOptional(array),
+          type: "string"
+        }
+      ],
+      optionsJsonSchema: {},
+      getPojoInput: (argv) => argv.positionalValues.at(-1).map(
+        (s) => convertPositional(array.items, s)
+      )
+    }
+  };
+}
+function parseTupleInput(tuple) {
+  const items = tupleItemsSchemas(tuple);
+  if (!Array.isArray(items))
+    throw new Error(".items is not an array, is this really a tuple?");
+  const flagsSchemaIndex = items.findIndex((item) => {
+    if (acceptedPrimitiveTypes(item).length > 0) {
+      return false;
+    }
+    if (looksLikeArray(item) && acceptedPrimitiveTypes(item.items).length > 0) {
+      return false;
+    }
+    return true;
+  });
+  const types = `[${items.map((s) => schemaDefPropValue(s, "type")).join(", ")}]`;
+  if (flagsSchemaIndex > -1 && flagsSchemaIndex !== items.length - 1) {
+    return {
+      success: false,
+      error: `Invalid input type ${types}. Positional parameters must be strings, numbers or booleans.`
+    };
+  }
+  const flagsSchema = flagsSchemaIndex === -1 ? null : items[flagsSchemaIndex];
+  if (flagsSchema && !acceptsObject(flagsSchema)) {
+    return {
+      success: false,
+      error: `Invalid input type ${types}. The last type must accept object inputs.`
+    };
+  }
+  const positionalSchemas = flagsSchemaIndex === -1 ? items : items.slice(0, flagsSchemaIndex);
+  return {
+    success: true,
+    value: {
+      positionalParameters: positionalSchemas.map((schema, i) => ({
+        name: parameterName(schema, i + 1),
+        array: looksLikeArray(schema),
+        description: schemaDefPropValue(schema, "description") || "",
+        required: !isOptional(schema),
+        type: getSchemaTypes(toRoughJsonSchema7(schema)).join(" | ")
+      })),
+      optionsJsonSchema: flagsSchema && typeof flagsSchema === "object" ? flagsSchema : {},
+      getPojoInput: (commandArgs) => {
+        const inputs = commandArgs.positionalValues.map((v2, i) => {
+          const correspondingSchema = positionalSchemas[i];
+          if (!correspondingSchema) {
+            throw new CliValidationError(`No schema found for position ${i}`);
+          }
+          if (looksLikeArray(correspondingSchema)) {
+            if (!Array.isArray(v2)) {
+              throw new CliValidationError(
+                `Expected array at position ${i}, got ${typeof v2}`
+              );
+            }
+            return v2.map((s) => {
+              if (!correspondingSchema.items || Array.isArray(correspondingSchema.items))
+                return s;
+              return convertPositional(correspondingSchema.items, s);
+            });
+          }
+          if (typeof v2 !== "string" && v2 !== void 0) {
+            throw new CliValidationError(
+              `Expected string at position ${i}, got ${typeof v2}`
+            );
+          }
+          return convertPositional(correspondingSchema, v2);
+        });
+        if (flagsSchema) {
+          inputs.push(commandArgs.options);
+        }
+        return inputs;
+      }
+    }
+  };
+}
+const convertPositional = (schema, value) => {
+  let preprocessed;
+  const acceptedTypes = new Set(acceptedPrimitiveTypes(schema));
+  if (acceptedTypes.has("string")) {
+    preprocessed = value;
+  }
+  if (acceptedTypes.has("boolean")) {
+    if (value === "true") preprocessed = true;
+    else if (value === "false") preprocessed = false;
+  }
+  if (acceptedTypes.has("number")) {
+    const number = Number(value);
+    if (!Number.isNaN(number)) {
+      preprocessed = number;
+    }
+  }
+  if (acceptedTypes.has("integer")) {
+    const num = Number(value);
+    if (Number.isInteger(num)) {
+      preprocessed = num;
+    } else if (!Number.isNaN(num) && acceptedTypes === void 0) {
+      preprocessed = value;
+    }
+  }
+  if (preprocessed === void 0) {
+    return value;
+  }
+  return preprocessed;
+};
+const looksLikeArray = (schema) => {
+  return schemaDefPropValue(schema, "type") === "array";
+};
+const toRoughJsonSchema7 = (schema) => {
+  if (!schema || typeof schema !== "object") {
+    return {};
+  }
+  return schema;
+};
+const parameterName = (s, position) => {
+  if (looksLikeArray(s)) {
+    const items = toRoughJsonSchema7(s).items;
+    const elementName = parameterName(
+      !items || Array.isArray(items) ? {} : items,
+      position
+    );
+    return `[${elementName.slice(1, -1)}...]`;
+  }
+  let name = schemaDefPropValue(s, "title") || schemaDefPropValue(s, "description") || `parameter_${position}`;
+  name = name.replaceAll(/\W+/g, " ").trim();
+  return isOptional(s) ? `[${name}]` : `<${name}>`;
+};
+const acceptsObject = (schema) => {
+  return (schema.type === "object" || schema.anyOf?.some((sub) => acceptsObject(toRoughJsonSchema7(sub)))) ?? false;
+};
+const getJsonSchemaConverters = (dependencies) => {
+  return {
+    zod: (input2) => {
+      if (input2._zod?.version?.major === 4) {
+        return zod4.toJSONSchema(input2, {
+          // todo[zod@>=4.0.0] remove the line if https://github.com/colinhacks/zod/issues/4167 is resolved, or this comment if it's closed
+          io: "input",
+          // todo[zod@>=4.0.0] remove the override if https://github.com/colinhacks/zod/issues/4164 is resolved, or this comment if it's closed
+          unrepresentable: "any",
+          // todo[zod@>=4.0.0] remove the override if https://github.com/colinhacks/zod/issues/4164 is resolved, or this comment if it's closed
+          override: (ctx) => {
+            if (ctx.zodSchema?.constructor?.name === "ZodOptional") {
+              ctx.jsonSchema.optional = true;
+            }
+          }
+        });
+      }
+      return zodToJsonSchema(input2);
+    },
+    arktype: (input2) => {
+      const type = prepareArktypeType(input2);
+      return type.toJsonSchema({
+        fallback: (ctx) => {
+          if (ctx.code === "unit" && ctx.unit === void 0)
+            return { ...ctx.base, optional: true };
+          return ctx.base;
+        }
+      });
+    },
+    valibot: (input) => {
+      let valibotToJsonSchemaLib = dependencies["@valibot/to-json-schema"];
+      if (!valibotToJsonSchemaLib) {
+        try {
+          valibotToJsonSchemaLib = eval(`require('@valibot/to-json-schema')`);
+        } catch (e) {
+          throw new Error(
+            "@valibot/to-json-schema could not be found - try installing it and re-running",
+            { cause: e }
+          );
+        }
+      }
+      const valibotToJsonSchema = valibotToJsonSchemaLib?.toJsonSchema;
+      if (!valibotToJsonSchema) {
+        throw new Error(
+          `no 'toJsonSchema' function found in @valibot/to-json-schema - check you are using a supported version`
+        );
+      }
+      let v;
+      try {
+        v = eval(`require('valibot')`);
+      } catch {
+        return valibotToJsonSchema(input);
+      }
+      const parent = valibotToJsonSchema(
+        v.object({ child: input }),
+        {
+          errorMode: "ignore"
+        }
+      );
+      const child = parent.properties.child;
+      return parent.required?.length === 0 ? Object.assign(child, { optional: true }) : child;
+    },
+    effect: (input) => {
+      const effect = dependencies.effect || eval(`require('effect')`);
+      if (!effect) {
+        throw new Error(
+          "effect dependency could not be found - try installing it and re-running"
+        );
+      }
+      if (!effect.Schema.isSchema(input)) {
+        const message = "input was not an effect schema - please use effect version 3.14.2 or higher. See https://github.com/mmkal/trpc-cli/pull/63";
+        throw new Error(message);
+      }
+      return effect.JSONSchema.make(input);
+    }
+  };
+};
+function getVendor(schema) {
+  return schema?.["~standard"]?.vendor ?? null;
+}
+const jsonSchemaVendorNames = new Set(Object.keys(getJsonSchemaConverters({})));
+function looksJsonSchemaable(value) {
+  const vendor = getVendor(value);
+  return !!vendor && jsonSchemaVendorNames.has(vendor);
+}
+function prepareArktypeType(type) {
+  let innerType = type;
+  while (innerType) {
+    if (innerType?.in && innerType.in !== innerType) {
+      innerType = innerType.in;
+    } else {
+      break;
+    }
+  }
+  return innerType;
+}

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

@@ -0,0 +1,18 @@
+import { Argument, Command, Option } from "commander";
+import type { CommanderProgramLike, Promptable } from "./types";
+interface Shadowed<T> {
+    original: T;
+    shadow: T;
+}
+type WithValue<T> = Shadowed<T> & {
+    value: string | undefined;
+    specified: boolean;
+};
+interface Analysis {
+    command: Shadowed<Command>;
+    arguments: WithValue<Argument>[];
+    options: WithValue<Option>[];
+}
+export declare const createShadowCommand: (command: Command, onAnalyze: (params: Analysis) => void | Promise<void>) => Command;
+export declare const promptify: (program: CommanderProgramLike, prompts: Promptable) => CommanderProgramLike;
+export {};