@settlemint/dalp-cli 3.1.32-main.42202049300 → 3.1.32-main.42209626311

package/src/lib/sdk-cli-schema.ts

@@ -0,0 +1,363 @@
+import { z } from "incur";
+import type { SurfaceOperation, SurfaceParam } from "./openapi-surface-types.ts";
+
+export type ZodTypeAny = z.ZodType;
+
+const cliValueSchema = z.union([z.json(), z.date(), z.bigint(), z.undefined()]);
+const looseBagSchema = z.record(z.string(), cliValueSchema);
+
+export type LooseBag = z.output<typeof looseBagSchema>;
+
+export const parseLooseBag = (value: unknown): LooseBag => looseBagSchema.parse(value);
+
+function zodDefType(schema: ZodTypeAny): string | undefined {
+  const def = Reflect.get(schema, "def") as { type?: string } | undefined;
+  return def?.type ?? Reflect.get(schema, "type");
+}
+
+function zodInner(schema: ZodTypeAny): ZodTypeAny | undefined {
+  const def = Reflect.get(schema, "def") as { innerType?: ZodTypeAny; schema?: ZodTypeAny } | undefined;
+  return def?.innerType ?? def?.schema;
+}
+
+function unwrapZod(schema: ZodTypeAny): ZodTypeAny {
+  let current = schema;
+  for (let depth = 0; depth < 8; depth += 1) {
+    const type = zodDefType(current);
+    if (type === "optional" || type === "nullable" || type === "default" || type === "readonly") {
+      const inner = zodInner(current);
+      if (inner === undefined) {
+        return current;
+      }
+      current = inner;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+
+export type ZodShape = Record<string, ZodTypeAny>;
+
+export function objectShape(schema: ZodTypeAny | undefined): ZodShape | undefined {
+  if (schema === undefined) {
+    return undefined;
+  }
+  const core = unwrapZod(schema);
+  if (zodDefType(core) !== "object") {
+    return undefined;
+  }
+  const def = Reflect.get(core, "def") as {
+    shape?: ZodShape | (() => ZodShape);
+  };
+  const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+  if (shape === undefined) {
+    return Reflect.get(core, "shape") as ZodShape | undefined;
+  }
+  return shape;
+}
+
+function needsJsonStringInput(schema: ZodTypeAny): boolean {
+  const type = zodDefType(unwrapZod(schema));
+  return type === "object" || type === "array" || type === "union" || type === "intersection";
+}
+
+export function asCliField(schema: ZodTypeAny, description?: string): ZodTypeAny {
+  const core = unwrapZod(schema);
+  let field: ZodTypeAny;
+
+  if (needsJsonStringInput(schema)) {
+    field = z.preprocess((value: unknown) => {
+      if (typeof value !== "string") {
+        return value;
+      }
+      const trimmed = value.trim();
+      if (trimmed === "") {
+        return value;
+      }
+      try {
+        const parsed: unknown = JSON.parse(trimmed);
+        return parsed;
+      } catch {
+        return value;
+      }
+    }, schema);
+  } else if (zodDefType(core) === "number") {
+    field = z.preprocess((value: unknown) => {
+      if (typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value))) {
+        return Number(value);
+      }
+      return value;
+    }, schema);
+  } else if (zodDefType(core) === "boolean") {
+    field = z.preprocess((value: unknown) => {
+      if (value === "true" || value === true) {
+        return true;
+      }
+      if (value === "false" || value === false) {
+        return false;
+      }
+      return value;
+    }, schema);
+  } else {
+    field = schema;
+  }
+
+  if (description !== undefined && description.trim() !== "") {
+    return field.describe(description);
+  }
+  return field;
+}
+
+function asCliJsonOption(schema: ZodTypeAny, description: string): ZodTypeAny {
+  return z
+    .preprocess((value: unknown) => {
+      if (value === undefined || value === null || value === "") {
+        return value;
+      }
+      if (typeof value === "string") {
+        try {
+          const parsed: unknown = JSON.parse(value);
+          return parsed;
+        } catch {
+          return value;
+        }
+      }
+      return value;
+    }, schema.optional())
+    .describe(description);
+}
+
+function openApiFieldDescription(
+  surface: SurfaceOperation | undefined,
+  location: "path" | "query" | "body",
+  name: string
+): string | undefined {
+  if (surface === undefined) {
+    return undefined;
+  }
+  if (location === "path") {
+    const param = surface.pathParams.find((entry) => entry.name === name);
+    return formatSurfaceDescribe(param?.description, param?.examples, param?.pattern);
+  }
+  if (location === "query") {
+    const param = surface.queryParams.find((entry) => entry.name === name);
+    if (param === undefined) {
+      return undefined;
+    }
+    return formatSurfaceDescribe(param.description, param.examples, param.pattern);
+  }
+  const field = surface.bodyFields.find((entry) => entry.name === name);
+  return formatSurfaceDescribe(field?.description, field?.examples, field?.pattern);
+}
+
+function formatSurfaceDescribe(
+  description: string | null | undefined,
+  examples: ReadonlyArray<string> | undefined,
+  pattern: string | null | undefined
+): string | undefined {
+  const parts: Array<string> = [];
+  if (description !== undefined && description !== null && description.trim() !== "") {
+    parts.push(description);
+  }
+  if (pattern !== undefined && pattern !== null && pattern !== "") {
+    parts.push(`Pattern: ${pattern}`);
+  }
+  if (examples !== undefined && examples.length > 0) {
+    parts.push(`Example: ${examples[0]}`);
+  }
+  return parts.length > 0 ? parts.join(" ") : undefined;
+}
+
+export function buildArgsFromSdkPath(
+  pathSchema: ZodTypeAny | undefined,
+  surface: SurfaceOperation | undefined,
+  makeOptional: boolean
+): z.ZodObject<ZodShape> | undefined {
+  const shape = objectShape(pathSchema);
+  if (shape === undefined || Object.keys(shape).length === 0) {
+    return undefined;
+  }
+  const out: ZodShape = {};
+  for (const [name, fieldSchema] of Object.entries(shape)) {
+    const described = asCliField(fieldSchema, openApiFieldDescription(surface, "path", name));
+    out[name] = makeOptional ? described.optional() : described;
+  }
+  return z.object(out);
+}
+
+export function buildOptionsFromSdk(
+  querySchema: ZodTypeAny | undefined,
+  bodySchema: ZodTypeAny | undefined,
+  surface: SurfaceOperation | undefined,
+  extras?: ZodShape
+): z.ZodObject<ZodShape> | undefined {
+  const out: ZodShape = extras === undefined ? {} : { ...extras };
+
+  const queryShape = objectShape(querySchema);
+  if (queryShape !== undefined) {
+    for (const [name, fieldSchema] of Object.entries(queryShape)) {
+      out[name] = asCliField(fieldSchema, openApiFieldDescription(surface, "query", name));
+    }
+  }
+  if (querySchema !== undefined) {
+    out.query = asCliJsonOption(
+      querySchema,
+      surface?.queryParams.map((param) => param.description).find((text) => text !== null && text !== "") ??
+        "Full query object as JSON (SDK query schema)"
+    );
+  }
+
+  if (bodySchema !== undefined) {
+    out.body = asCliJsonOption(bodySchema, surface?.requestBodyDescription ?? "JSON request body (SDK body schema)");
+    const bodyShape = objectShape(bodySchema);
+    if (bodyShape !== undefined) {
+      for (const [name, fieldSchema] of Object.entries(bodyShape)) {
+        if (needsJsonStringInput(fieldSchema)) {
+          continue;
+        }
+        if (out[name] !== undefined) {
+          continue;
+        }
+        out[name] = asCliField(fieldSchema, openApiFieldDescription(surface, "body", name)).optional();
+      }
+    }
+  }
+
+  for (const param of surface?.headerParams ?? []) {
+    const headerOption = param.name
+      .replaceAll(/([a-z0-9])([A-Z])/gu, "$1-$2")
+      .replaceAll("_", "-")
+      .replaceAll(/-+/gu, "-")
+      .toLowerCase();
+    if (out[headerOption] !== undefined) {
+      continue;
+    }
+    out[headerOption] = z
+      .string()
+      .optional()
+      .describe(formatSurfaceDescribe(param.description, param.examples, param.pattern) ?? param.name);
+  }
+
+  if (Object.keys(out).length === 0) {
+    return undefined;
+  }
+  return z.object(out);
+}
+
+export function collectQueryBag(options: LooseBag, querySchema: ZodTypeAny | undefined): unknown {
+  if (options.query !== undefined) {
+    return options.query;
+  }
+  const shape = objectShape(querySchema);
+  if (shape === undefined) {
+    return undefined;
+  }
+  const query: LooseBag = {};
+  for (const name of Object.keys(shape)) {
+    if (options[name] !== undefined) {
+      query[name] = options[name];
+    }
+  }
+  return Object.keys(query).length > 0 ? query : undefined;
+}
+
+export function collectBodyBag(options: LooseBag, bodySchema: ZodTypeAny | undefined): unknown {
+  if (options.body !== undefined) {
+    return options.body;
+  }
+  const shape = objectShape(bodySchema);
+  if (shape === undefined) {
+    return undefined;
+  }
+  const body: LooseBag = {};
+  for (const [name, fieldSchema] of Object.entries(shape)) {
+    if (needsJsonStringInput(fieldSchema)) {
+      continue;
+    }
+    if (options[name] !== undefined) {
+      body[name] = options[name];
+    }
+  }
+  if (Object.keys(body).length === 0) {
+    return undefined;
+  }
+  if (bodySchema === undefined) {
+    return body;
+  }
+  const parsed = bodySchema.safeParse(body);
+  if (!parsed.success) {
+    return body;
+  }
+  return parsed.data;
+}
+
+export function collectPathBag(args: LooseBag): LooseBag | undefined {
+  const path: LooseBag = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (value !== undefined && value !== "") {
+      path[key] = value;
+    }
+  }
+  return Object.keys(path).length > 0 ? path : undefined;
+}
+
+export function parseWithSdkSchema<T>(schema: ZodTypeAny, value: unknown, label: string): T {
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    throw new Error(`${label}: ${parsed.error.message}`);
+  }
+  return parsed.data as T;
+}
+
+function zodForSurfaceParam(param: SurfaceParam): ZodTypeAny {
+  let schema: ZodTypeAny;
+  if (param.enum !== null && param.enum.length > 0) {
+    schema = z.enum(param.enum as [string, ...Array<string>]);
+  } else if (param.fields.length > 0) {
+    schema = z.object(Object.fromEntries(param.fields.map((field) => [field.name, zodForSurfaceParam(field)])));
+  } else {
+    switch (param.type ?? "string") {
+      case "integer":
+      case "number": {
+        schema = z.number();
+        break;
+      }
+      case "boolean": {
+        schema = z.boolean();
+        break;
+      }
+      case "array": {
+        schema = z.array(z.json());
+        break;
+      }
+      case "object": {
+        schema = z.record(z.string(), z.json());
+        break;
+      }
+      default: {
+        schema = param.pattern === null ? z.string() : z.string().regex(new RegExp(param.pattern, "u"));
+      }
+    }
+  }
+  const described = asCliField(schema, param.description ?? undefined);
+  return param.required ? described : described.optional();
+}
+
+export function zodFromSurfaceParams(params: ReadonlyArray<SurfaceParam>): z.ZodObject<ZodShape> | undefined {
+  if (params.length === 0) {
+    return undefined;
+  }
+  return z.object(Object.fromEntries(params.map((param) => [param.name, zodForSurfaceParam(param)])));
+}
+
+export function zodForRequestBody(surface: SurfaceOperation | undefined): z.ZodType | undefined {
+  if (surface === undefined || !surface.hasRequestBody) {
+    return undefined;
+  }
+  if (surface.bodyIsComplex) {
+    const partial = zodFromSurfaceParams(surface.bodyFields);
+    return partial === undefined ? z.record(z.string(), z.json()) : partial.catchall(z.json());
+  }
+  return zodFromSurfaceParams(surface.bodyFields) ?? z.record(z.string(), z.json());
+}

package/src/lib/secret-prompt.ts

@@ -0,0 +1,23 @@
+import { createInterface } from "node:readline";
+import { Writable } from "node:stream";
+
+const muted = new Writable({
+  write(_chunk, _encoding, done) {
+    done();
+  },
+});
+
+export const promptSecret = (question: string): Promise<string> =>
+  new Promise((resolve, reject) => {
+    process.stdout.write(question);
+    const reader = createInterface({ input: process.stdin, output: muted, terminal: true });
+    reader.once("line", (answer) => {
+      reader.close();
+      process.stdout.write("\n");
+      resolve(answer.trim());
+    });
+    reader.once("SIGINT", () => {
+      reader.close();
+      reject(new Error("Cancelled"));
+    });
+  });

package/src/lib/vars.ts

@@ -0,0 +1,19 @@
+import type { DalpClient } from "@settlemint/dalp-sdk";
+import { z } from "incur";
+import type { StoredCredentials } from "./credential-store.ts";
+import packageJson from "../../package.json" with { type: "json" };
+
+export const CLI_VERSION = packageJson.version;
+export const CLI_USER_AGENT = `DALP CLI v${CLI_VERSION}`;
+
+function middlewareInjectedVar<T>() {
+  return z.custom<T>().optional();
+}
+
+export const cliVars = z.object({
+  apiUrl: middlewareInjectedVar<string>(),
+  credentials: middlewareInjectedVar<StoredCredentials>(),
+  client: middlewareInjectedVar<DalpClient>(),
+});
+
+export type CliVars = z.infer<typeof cliVars>;