@asteroidai/cli 1.9.27 → 1.9.30

package/src/request.ts

@@ -1,252 +0,0 @@
-import { readFileSync } from "node:fs";
-import { basename } from "node:path";
-
-import { type Parsed, UsageError } from "./args";
-import type { CliCommand, Option } from "./types";
-
-export interface BuiltRequest {
-  method: CliCommand["method"];
-  path: string;
-  query: URLSearchParams;
-  json?: unknown;
-  form?: FormData;
-}
-
-function camel(segment: string): string {
-  return segment.replace(/-([a-z0-9])/g, (_, c: string) => c.toUpperCase());
-}
-
-function scalar(option: Option, raw: string): unknown {
-  const type = option.type.replace("[]", "");
-  if (option.enum && !option.enum.includes(raw)) {
-    throw new UsageError(
-      `--${option.flag} must be one of ${option.enum.join(", ")}`,
-    );
-  }
-  if (type === "integer" || type === "number") {
-    const value = Number(raw);
-    if (
-      raw.trim() === "" ||
-      Number.isNaN(value) ||
-      (type === "integer" && !Number.isInteger(value))
-    ) {
-      throw new UsageError(
-        `--${option.flag} must be ${type === "integer" ? "an integer" : "a number"}`,
-      );
-    }
-    return value;
-  }
-  if (type === "boolean") {
-    if (raw !== "true" && raw !== "false") {
-      throw new UsageError(`--${option.flag} must be true or false`);
-    }
-    return raw === "true";
-  }
-  if (type === "json") return parseJson(raw, `--${option.flag}`);
-  return raw;
-}
-
-function value(option: Option, raws: string[]): unknown {
-  if (option.type.endsWith("[]")) return raws.map((raw) => scalar(option, raw));
-  return scalar(option, raws.at(-1)!);
-}
-
-export interface InputReader {
-  text(path: string | 0): Promise<string>;
-  bytes(path: string): Promise<Uint8Array<ArrayBuffer>>;
-}
-
-export const nodeReader: InputReader = {
-  text: async (path) => readFileSync(path, "utf8"),
-  bytes: async (path) => new Uint8Array(readFileSync(path)),
-};
-
-async function readInput(raw: string, io: InputReader): Promise<string> {
-  if (raw === "-") return io.text(0);
-  if (raw.startsWith("@")) return io.text(raw.slice(1));
-  return raw;
-}
-
-async function resolveInputs(
-  command: CliCommand,
-  parsed: Parsed,
-  io: InputReader,
-): Promise<Parsed> {
-  const jsonFlags = [...command.query, ...(command.body?.fields ?? [])]
-    .filter((option) => option.type === "json")
-    .map((option) => option.flag);
-  const flags = new Map(parsed.flags);
-  for (const flag of jsonFlags) {
-    const raws = flags.get(flag);
-    if (raws)
-      flags.set(flag, await Promise.all(raws.map((raw) => readInput(raw, io))));
-  }
-  const body =
-    parsed.body === undefined ? undefined : await readInput(parsed.body, io);
-  return { ...parsed, flags, body };
-}
-
-function parseJson(raw: string, label: string): unknown {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    throw new UsageError(`${label} is not valid JSON`);
-  }
-}
-
-function loose(raw: string): unknown {
-  if (/^(true|false|null)$/.test(raw) || /^[[{]/.test(raw.trim())) {
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return raw;
-    }
-  }
-  return raw;
-}
-
-function setPath(
-  target: Record<string, unknown>,
-  path: string[],
-  value: unknown,
-) {
-  let node = target;
-  for (const key of path.slice(0, -1)) {
-    const next = node[key];
-    if (typeof next !== "object" || next === null || Array.isArray(next))
-      node[key] = {};
-    node = node[key] as Record<string, unknown>;
-  }
-  node[path.at(-1)!] = value;
-}
-
-export interface RequestContext {
-  io?: InputReader;
-  organizationId?: string;
-}
-
-export async function buildRequest(
-  command: CliCommand,
-  input: Parsed,
-  context: RequestContext = {},
-): Promise<BuiltRequest> {
-  const io = context.io ?? nodeReader;
-  const parsed = await resolveInputs(command, input, io);
-  if (parsed.positionals.length !== command.args.length) {
-    const expected =
-      command.args.map((a) => `<${a.flag}>`).join(" ") || "no arguments";
-    throw new UsageError(
-      `expected ${expected}, got ${parsed.positionals.length} argument(s)`,
-    );
-  }
-  let path = command.path;
-  command.args.forEach((arg, i) => {
-    path = path.replace(
-      `{${arg.name}}`,
-      encodeURIComponent(parsed.positionals[i]),
-    );
-  });
-
-  const flags = new Map(parsed.flags);
-  const query = new URLSearchParams();
-  for (const option of command.query) {
-    const raws = flags.get(option.flag);
-    flags.delete(option.flag);
-    if (!raws) {
-      if (option.required) throw new UsageError(`--${option.flag} is required`);
-      continue;
-    }
-    const parsedValue = value(option, raws);
-    const values = Array.isArray(parsedValue) ? parsedValue : [parsedValue];
-    if (option.explode === false)
-      query.append(option.name, values.map(String).join(","));
-    else for (const v of values) query.append(option.name, String(v));
-  }
-
-  const built: BuiltRequest = { method: command.method, path, query };
-  const body = command.body;
-  if (!body) {
-    if (parsed.body) throw new UsageError(`${command.command} takes no body`);
-    rejectUnknown(flags);
-    return built;
-  }
-
-  if (body.contentType === "multipart/form-data") {
-    if (parsed.body) {
-      throw new UsageError(
-        `${command.command} uploads files; use the file flags, not --body`,
-      );
-    }
-    const form = new FormData();
-    for (const file of body.files) {
-      const paths = flags.get(file) ?? [];
-      if (body.required && paths.length === 0) {
-        throw new UsageError(`--${file} is required`);
-      }
-      for (const filePath of paths) {
-        form.append(
-          file,
-          new Blob([await io.bytes(filePath)]),
-          basename(filePath),
-        );
-      }
-      flags.delete(file);
-    }
-    for (const field of body.fields) {
-      const raws = flags.get(field.flag);
-      flags.delete(field.flag);
-      if (raws) for (const raw of raws) form.append(field.name, raw);
-    }
-    rejectUnknown(flags);
-    built.form = form;
-    return built;
-  }
-
-  const base = parsed.body ? parseJson(parsed.body, "--body") : {};
-  if (typeof base !== "object" || base === null || Array.isArray(base)) {
-    throw new UsageError("--body must be a JSON object");
-  }
-  const json = base as Record<string, unknown>;
-  for (const field of body.fields) {
-    const raws = flags.get(field.flag);
-    if (!raws) continue;
-    flags.delete(field.flag);
-    json[field.name] = value(field, raws);
-  }
-  for (const [flag, raws] of [...flags]) {
-    const [head, ...rest] = flag.split(".");
-    const field = body.fields.find((f) => f.flag === head);
-    if (!field || rest.length === 0) continue;
-    flags.delete(flag);
-    const current = json[field.name];
-    json[field.name] =
-      typeof current === "object" && current !== null ? current : {};
-    setPath(json, [field.name, ...rest.map(camel)], loose(raws.at(-1)!));
-  }
-  rejectUnknown(flags);
-  delete json.organizationId;
-  if (body.credentialOrganization) {
-    if (!context.organizationId) {
-      throw new UsageError(
-        "could not tell which organization this credential acts in",
-      );
-    }
-    json.organizationId = context.organizationId;
-  }
-  for (const field of body.fields) {
-    if (field.required && json[field.name] === undefined) {
-      throw new UsageError(`--${field.flag} is required`);
-    }
-  }
-  if (body.required || Object.keys(json).length > 0) built.json = json;
-  return built;
-}
-
-function rejectUnknown(flags: Map<string, string[]>) {
-  const unknown = [...flags.keys()];
-  if (unknown.length > 0) {
-    throw new UsageError(
-      `unknown flag${unknown.length > 1 ? "s" : ""}: ${unknown.map((f) => `--${f}`).join(", ")}`,
-    );
-  }
-}