jitsu-cli 1.10.3 → 1.11.0

package/src/commands/config/resources.ts

@@ -0,0 +1,110 @@
+// Single source of truth for the `jitsu config <noun>` command tree.
+// `kind` selects which verb handlers apply; `type` is the segment used in
+// /api/{workspaceId}/config/{type} for standard config objects.
+
+export type ResourceKind = "configObject" | "workspace" | "link" | "profile-builder";
+
+export type Resource = {
+  noun: string;
+  aliases: string[];
+  kind: ResourceKind;
+  type?: string;
+  supportsTest?: boolean;
+  // Description used in `--help`.
+  description: string;
+};
+
+export const resources: Resource[] = [
+  {
+    noun: "workspaces",
+    aliases: ["workspace"],
+    kind: "workspace",
+    description: "Workspaces accessible to the current user",
+  },
+  {
+    noun: "destinations",
+    aliases: ["destination", "dest"],
+    kind: "configObject",
+    type: "destination",
+    supportsTest: true,
+    description: "Destinations (warehouses, databases, services receiving events)",
+  },
+  {
+    noun: "streams",
+    aliases: ["stream"],
+    kind: "configObject",
+    type: "stream",
+    supportsTest: true,
+    description: "Event streams (formerly known as sources)",
+  },
+  {
+    noun: "functions",
+    aliases: ["function", "fn"],
+    kind: "configObject",
+    type: "function",
+    description: "User-defined functions (UDFs). For dev workflow see `jitsu deploy`.",
+  },
+  {
+    noun: "services",
+    aliases: ["service"],
+    kind: "configObject",
+    type: "service",
+    supportsTest: true,
+    description: "External connector services (Airbyte protocol)",
+  },
+  {
+    noun: "domains",
+    aliases: ["domain"],
+    kind: "configObject",
+    type: "domain",
+    description: "Custom ingestion domains",
+  },
+  {
+    noun: "misc",
+    aliases: [],
+    kind: "configObject",
+    type: "misc",
+    description: "Miscellaneous configuration entities (free-form)",
+  },
+  {
+    noun: "notifications",
+    aliases: ["notification"],
+    kind: "configObject",
+    type: "notification",
+    description: "Alert channels (email/Slack)",
+  },
+  {
+    noun: "connections",
+    aliases: ["connection", "link", "links"],
+    kind: "link",
+    description: "Connections between streams/services and destinations",
+  },
+  {
+    noun: "profile-builders",
+    aliases: ["profile-builder"],
+    kind: "profile-builder",
+    description: "Profile builders (identity stitching)",
+  },
+];
+
+export type Verb = "list" | "get" | "create" | "update" | "delete" | "test";
+
+// Which verbs apply to a given resource kind.
+export function verbsFor(kind: ResourceKind): Verb[] {
+  switch (kind) {
+    case "configObject":
+      return ["list", "get", "create", "update", "delete"];
+    case "workspace":
+      return ["list", "get", "create", "update", "delete"];
+    case "link":
+      // link has no per-id GET; list+create(upsert)+update(alias)+delete
+      return ["list", "create", "update", "delete"];
+    case "profile-builder":
+      return ["list", "create", "update", "delete"];
+  }
+}
+
+export function findResource(name: string): Resource | undefined {
+  const lower = name.toLowerCase();
+  return resources.find(r => r.noun === lower || r.aliases.includes(lower));
+}

package/src/commands/default-workspace.ts

@@ -0,0 +1,44 @@
+import { ApiClient, ApiError } from "../lib/api-client";
+import { authFilePath, readAuthFile, resolveAuth, updateAuthFile } from "../lib/auth-file";
+import { red } from "../lib/chalk-code-highlight";
+
+export type DefaultWorkspaceOpts = {
+  host?: string;
+  apikey?: string;
+};
+
+export async function setDefaultWorkspace(idOrSlug: string, opts: DefaultWorkspaceOpts) {
+  try {
+    const auth = resolveAuth(opts);
+    const client = new ApiClient(auth);
+    let workspace: { id: string; slug?: string; name?: string };
+    try {
+      workspace = await client.request({
+        method: "GET",
+        path: `/api/workspace/${encodeURIComponent(idOrSlug)}`,
+      });
+    } catch (e) {
+      if (e instanceof ApiError && e.status === 404) {
+        throw new Error(`Workspace '${idOrSlug}' not found (or you don't have access)`);
+      }
+      throw e;
+    }
+    updateAuthFile({ defaultWorkspace: workspace.id });
+    const label = workspace.slug ? `${workspace.slug} (${workspace.id})` : workspace.id;
+    console.log(`Default workspace set to ${label}.`);
+    console.log(`Saved to ${authFilePath()}.`);
+  } catch (e) {
+    console.error(red(`Error: ${e instanceof Error ? e.message : String(e)}`));
+    process.exit(1);
+  }
+}
+
+export async function unsetDefaultWorkspace() {
+  const file = readAuthFile();
+  if (!file?.defaultWorkspace) {
+    console.log("No default workspace is set.");
+    return;
+  }
+  updateAuthFile({ defaultWorkspace: undefined });
+  console.log("Default workspace unset.");
+}

package/src/commands/deploy.ts

@@ -3,10 +3,11 @@ import { homedir } from "os";
 import inquirer from "inquirer";
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { loadPackageJson } from "./shared";
-import fetch from "node-fetch";
 import cuid from "cuid";
 import { b, green, red } from "../lib/chalk-code-highlight";
 import { getFunctionFromFilePath } from "../lib/compiled-function";
+import { loadProjectConfig } from "../lib/project-config";
+import { readDefaultWorkspace } from "../lib/auth-file";
 
 function readLoginFile() {
   const configFile = `${homedir()}/.jitsu/jitsu-cli.json`;
@@ -56,34 +57,57 @@ export async function deploy({ dir, workspace, name: names, ...params }: Args) {
   }
   const workspaces = (await res.json()) as any[];
 
-  let workspaceId = workspace;
-  if (!workspace) {
-    if (workspaces.length === 0) {
-      console.error(`${red("No workspaces found")}`);
+  // Which workspace to deploy to. Precedence:
+  //   -w/--workspace flag  →  project config (jitsu.json / package.json "jitsu")
+  //   →  default workspace in ~/.jitsu/jitsu-cli.json  →  interactive prompt.
+  // The reference may be an id or a slug — both are matched against the list.
+  const findWorkspace = (ref?: string) => (ref ? workspaces.find(w => w.id === ref || w.slug === ref) : undefined);
+  const projectConfig = loadProjectConfig(projectDir, packageJson);
+
+  let workspaceObj: Workspace | undefined;
+  if (workspace) {
+    // Explicit -w/--workspace expresses clear intent: fail hard if it doesn't resolve.
+    workspaceObj = findWorkspace(workspace);
+    if (!workspaceObj) {
+      console.error(red(`Workspace '${b(workspace)}' not found (or you don't have access)`));
       process.exit(1);
-    } else if (workspaces.length === 1) {
-      workspaceId = workspaces[0].id;
-    } else {
-      workspaceId = (
-        await inquirer.prompt([
-          {
-            type: "list",
-            name: "workspaceId",
-            message: `Select workspace:`,
-            choices: workspaces.map(w => ({
-              name: `${w.name} (${w.id})`,
-              value: w.id,
-            })),
-          },
-        ])
-      ).workspaceId;
+    }
+  } else {
+    // "Soft" default from project config or ~/.jitsu. If it doesn't resolve (stale,
+    // deleted, wrong account), fall back to auto-select / interactive prompt instead
+    // of hard-failing — preserving the pre-config behavior of `deploy` with no -w.
+    const softRef = projectConfig.workspace ?? readDefaultWorkspace();
+    workspaceObj = findWorkspace(softRef);
+    if (!workspaceObj) {
+      if (softRef) {
+        console.warn(`Configured workspace ${b(softRef)} not found or not accessible. Selecting manually.`);
+      }
+      if (workspaces.length === 0) {
+        console.error(`${red("No workspaces found")}`);
+        process.exit(1);
+      } else if (workspaces.length === 1) {
+        workspaceObj = workspaces[0];
+      } else {
+        const workspaceId = (
+          await inquirer.prompt([
+            {
+              type: "list",
+              name: "workspaceId",
+              message: `Select workspace:`,
+              choices: workspaces.map(w => ({
+                name: `${w.name} (${w.id})`,
+                value: w.id,
+              })),
+            },
+          ])
+        ).workspaceId;
+        workspaceObj = findWorkspace(workspaceId);
+      }
     }
   }
 
-  const workspaceObj = workspaces.find(w => w.id === workspaceId);
-  const workspaceName = workspaceObj?.name;
-  if (!workspaceId || !workspaceName) {
-    console.error(red(`Workspace with id ${workspaceId} not found`));
+  if (!workspaceObj?.id || !workspaceObj?.name) {
+    console.error(red(`Workspace not found`));
     process.exit(1);
   }
   await deployFunctions({ ...params, host, apikey, name: names }, projectDir, packageJson, workspaceObj, "function");
@@ -101,12 +125,14 @@ async function deployFunctions(
   const dir = `dist/${kind}s`;
   const functionsDir = path.resolve(projectDir, dir);
 
+  if (!existsSync(functionsDir)) {
+    console.warn(`No ${b(dir)} directory found, skipping ${kind}s. Please make sure that you have built the project.`);
+    return;
+  }
   const functionsFiles = readdirSync(functionsDir);
   if (functionsFiles.length === 0) {
-    console.warn(
-      red(`Can't find function files in ${b(dir)} directory. Please make sure that you have built the project.`)
-    );
-    process.exit(1);
+    console.warn(`No ${kind} files found in ${b(dir)}, skipping. Please make sure that you have built the project.`);
+    return;
   }
   const selectedFiles: string[] = [];
   if (selected) {
@@ -144,6 +170,11 @@ async function deployFunctions(
     profileBuilders = ((await res.json()) as any).profileBuilders as any[];
   }
 
+  // Fetch the existing function list once for slug/id resolution. Previously
+  // every deployFunction() call refetched the whole list (with code blobs) —
+  // O(N) requests per deploy, each pulling all N rows from the console DB.
+  const existingFunctions = await fetchExistingFunctions({ host, apikey, workspaceId: workspace.id! });
+
   for (const file of selectedFiles) {
     console.log(
       `${b(`𝑓`)} Deploying function ${b(path.basename(file))} to workspace ${workspace.name} (${host}/${
@@ -151,27 +182,98 @@ async function deployFunctions(
       })`
     );
     await deployFunction(
+      projectDir,
       { host, apikey },
       packageJson,
       workspace,
       kind,
       path.resolve(functionsDir, file),
-      profileBuilders
+      profileBuilders,
+      existingFunctions
     );
   }
 }
 
+// Cache of functions already present in the workspace. byId and bySlug share
+// object identity so a single mutation visible from both. `slug` is tracked
+// per entry so we can detect (and reflect) renames on PUT.
+type ExistingFunction = { id: string; slug?: string };
+type ExistingFunctionsCache = {
+  bySlug: Map<string, ExistingFunction>;
+  byId: Map<string, ExistingFunction>;
+};
+
+async function fetchExistingFunctions({
+  host,
+  apikey,
+  workspaceId,
+}: {
+  host?: string;
+  apikey?: string;
+  workspaceId?: string;
+}): Promise<ExistingFunctionsCache> {
+  const res = await fetch(`${host}/api/${workspaceId}/config/function`, {
+    headers: { Authorization: `Bearer ${apikey}` },
+  });
+  if (!res.ok) {
+    console.error(red(`Cannot list existing functions:\n${b(await res.text())}`));
+    process.exit(1);
+  }
+  const { objects } = (await res.json()) as { objects: { id: string; slug?: string }[] };
+  const bySlug = new Map<string, ExistingFunction>();
+  const byId = new Map<string, ExistingFunction>();
+  for (const f of objects) {
+    const entry: ExistingFunction = { id: f.id, slug: f.slug };
+    byId.set(f.id, entry);
+    if (f.slug) bySlug.set(f.slug, entry);
+  }
+  return { bySlug, byId };
+}
+
+// Update the cache after a successful POST. Both maps must reflect the new
+// function so a later file with the same slug/id in this same deploy run
+// switches to PUT instead of trying a second POST.
+function cacheAfterCreate(cache: ExistingFunctionsCache, id: string, slug: string | undefined) {
+  const entry: ExistingFunction = { id, slug };
+  cache.byId.set(id, entry);
+  if (slug) cache.bySlug.set(slug, entry);
+}
+
+// Update the cache after a successful PUT. Preserves the previous re-fetch
+// semantics for slug renames: the old slug is no longer pointing at this id
+// on the server, so drop it from the slug index and install the new one.
+function cacheAfterUpdate(cache: ExistingFunctionsCache, id: string, newSlug: string | undefined) {
+  const entry = cache.byId.get(id);
+  if (!entry) {
+    // Function existed only on the server, not in our hoisted cache (shouldn't
+    // normally happen since the PUT branch only runs when we resolved an id).
+    // Insert defensively so later files in this run see it.
+    cacheAfterCreate(cache, id, newSlug);
+    return;
+  }
+  if (entry.slug && entry.slug !== newSlug) {
+    cache.bySlug.delete(entry.slug);
+  }
+  entry.slug = newSlug;
+  if (newSlug) cache.bySlug.set(newSlug, entry);
+}
+
 async function deployFunction(
+  projectDir: string,
   { host, apikey }: Args,
   packageJson: any,
   workspace: Workspace,
   kind: "function" | "profile",
   file: string,
-  profileBuilders: any[] = []
+  profileBuilders: any[] = [],
+  existingFunctions: ExistingFunctionsCache = {
+    bySlug: new Map(),
+    byId: new Map(),
+  }
 ) {
   const code = readFileSync(file, "utf-8");
 
-  const wrapped = await getFunctionFromFilePath(file, kind, profileBuilders);
+  const wrapped = await getFunctionFromFilePath(projectDir, file, kind, profileBuilders);
   const meta = wrapped.meta;
   if (meta) {
     console.log(`  meta: slug=${meta.slug}, name=${meta.name || "not set"}`);
@@ -181,18 +283,8 @@ async function deployFunction(
   }
   let existingFunctionId: string | undefined;
   if (meta.slug) {
-    const res = await fetch(`${host}/api/${workspace.id}/config/function`, {
-      headers: {
-        Authorization: `Bearer ${apikey}`,
-      },
-    });
-    if (!res.ok) {
-      console.error(red(`Cannot add function to workspace:\n${b(await res.text())}`));
-      process.exit(1);
-    } else {
-      const existing = (await res.json()) as any;
-      existingFunctionId = existing.objects.find(f => f.slug === meta.slug || f.id === meta.id)?.id;
-    }
+    existingFunctionId =
+      existingFunctions.bySlug.get(meta.slug)?.id ?? (meta.id ? existingFunctions.byId.get(meta.id)?.id : undefined);
   }
   let functionPayload = {};
   if (kind === "profile") {
@@ -230,6 +322,11 @@ async function deployFunction(
       console.error(red(`Cannot add function to workspace:\n${b(await res.text())}`));
       process.exit(1);
     } else {
+      // Reflect the new function in the hoisted cache so a later file in
+      // this same deploy that targets the same slug switches to PUT instead
+      // of POSTing a duplicate. Matches the pre-hoist behavior where each
+      // file re-fetched the list.
+      cacheAfterCreate(existingFunctions, id, meta.slug);
       console.log(`Function ${b(meta.name)} was successfully added to workspace ${workspace.name} with id: ${b(id)}`);
     }
   } else {
@@ -255,6 +352,10 @@ async function deployFunction(
       console.error(red(`⚠ Cannot deploy function ${b(meta.slug)}(${id}):\n${b(await res.text())}`));
       process.exit(1);
     } else {
+      // Slug may have been renamed by this PUT — update the slug index so a
+      // later file deploying under the old slug (if any) creates a new
+      // function instead of clobbering this one.
+      cacheAfterUpdate(existingFunctions, id, meta.slug);
       console.log(`${green(`✓`)} ${b(meta.name)} deployed successfully!`);
     }
   }

package/src/commands/login.ts

@@ -35,7 +35,9 @@ export async function logout({ force }: { force?: boolean }) {
 }
 
 export async function login({ host, apikey, force }: { host: string; apikey?: string; force?: boolean }) {
-  const jitsuFile = `${homedir()}/.jitsu/jitsu-cli.json`;
+  const jitsuDir = `${homedir()}/.jitsu`;
+  fs.mkdirSync(jitsuDir, { recursive: true });
+  const jitsuFile = `${jitsuDir}/jitsu-cli.json`;
   if (fs.existsSync(jitsuFile) && !force) {
     const loginInfo = JSON.parse(readFileSync(jitsuFile, { encoding: "utf-8" }));
     console.error(

package/src/commands/spec.ts

@@ -0,0 +1,32 @@
+import { Command } from "commander";
+import { red } from "../lib/chalk-code-highlight";
+import { normalizeHost, readAuthFile, resolveAuth } from "../lib/auth-file";
+import { fetchSpec } from "../lib/spec";
+import { DEFAULT_OUTPUT, SUPPORTED_OUTPUTS, print } from "../lib/renderer";
+
+export function buildSpecCommand(): Command {
+  return new Command("spec")
+    .description("Print the live OpenAPI spec served at /api/spec")
+    .option("-o, --output <format>", `Output format: ${SUPPORTED_OUTPUTS.join(", ")}`, DEFAULT_OUTPUT)
+    .option("-h, --host <host>", "Jitsu host (overrides ~/.jitsu/jitsu-cli.json)")
+    .option("-k, --apikey <api-key>", "API key (overrides ~/.jitsu/jitsu-cli.json)")
+    .action(async (opts: { output?: string; host?: string; apikey?: string }) => {
+      try {
+        // Pass a placeholder apikey if missing — /api/spec is public, but resolveAuth
+        // expects an apikey. Fall back to a synthetic one if user has no auth file.
+        const auth = (() => {
+          try {
+            return resolveAuth(opts);
+          } catch {
+            const host = opts.host ?? readAuthFile()?.host ?? "https://use.jitsu.com";
+            return { host: normalizeHost(host), apikey: "anonymous" };
+          }
+        })();
+        const spec = await fetchSpec(auth);
+        print(spec, opts.output);
+      } catch (e) {
+        console.error(red(`Error: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+      }
+    });
+}

package/src/index.ts

@@ -8,12 +8,27 @@ import { test } from "./commands/test";
 
 import { jitsuCliVersion, jitsuCliPackageName } from "./lib/version";
 import { whoami } from "./commands/whoami";
+import { buildConfigCommand } from "./commands/config";
+import { buildSpecCommand } from "./commands/spec";
+import { setDefaultWorkspace, unsetDefaultWorkspace } from "./commands/default-workspace";
+import { preprocessArgv } from "./lib/body-fields";
 
-console.log(figlet.textSync("Jitsu CLI", { horizontalLayout: "full" }));
+// Pull ad-hoc body field flags (--name=val, --credentials.password=...) out of argv
+// before Commander parses it. Reserved option names are left in place.
+process.argv = preprocessArgv(process.argv);
+
+// Figlet banner is decorative — write it to stderr so `jitsu config ... -o json | jq`
+// works without filtering. Skip it entirely when stdout is being piped or for spec output
+// (which is also typically piped to other tools).
+const isPipedStdout = !process.stdout.isTTY;
+if (!isPipedStdout) {
+  process.stderr.write(figlet.textSync("Jitsu CLI", { horizontalLayout: "full" }) + "\n");
+}
 
 const p = new Command();
 
-p.name(jitsuCliPackageName).description("CLI command to create, test and deploy extensions for Jitsu Next");
+p.name(jitsuCliPackageName).description("Jitsu CLI — manage workspaces, configuration objects, and extensions");
+
 p.command("init")
   .description("Initialize a new Jitsu extension project")
   .arguments("[dir]")
@@ -31,19 +46,6 @@ p.command("test")
   .option("-d, --dir <dir>", "the directory of project. (Optional). By default, current directory is used")
   .action(test);
 
-// p.command("run")
-//   .description("Check extensions on provided event, config and persistent storage state")
-//   .option("-d, --dir <dir>", "the directory of project. (Optional). By default, current directory is used")
-//   .option(
-//     "-n, --name <name>",
-//     "name of function file to check (optional). Required if multiple functions are defined in project"
-//   )
-//   .option("-t, --type <type>", "entity type to run", "function")
-//   .requiredOption("-e, --event <file_or_json>", "path to file with event json or event json as a string")
-//   .option("-p, --props <file_or_json>", "path to file with config json or config json as a string. (Optional)")
-//   .option("-s, --store <file_or_json>", "path to file with state json or state json as a string. (Optional)")
-//   .action(run);
-
 p.command("whoami")
   .description("Check if current user is logged in. Shows user's info if logged in")
   .option("-h, --host <host>", "Jitsu host or base url", "https://use.jitsu.com")
@@ -56,6 +58,7 @@ p.command("login")
   .option("-h, --host <host>", "Jitsu host or base url", "https://use.jitsu.com")
   .option("-k, --apikey <api-key>", "Jitsu user's Api Key. (Optional). Disables interactive login.")
   .action(login);
+
 p.command("logout").description("Logout").option("-f, --force", "Do not ask for confirmation").action(logout);
 
 p.command("deploy")
@@ -68,16 +71,30 @@ p.command("deploy")
   )
   .option("-k, --apikey <api-key>", "(Optional) Jitsu user's Api Key.")
   .option(
-    "-w, --workspace <workspace-id>",
-    "Id of workspace where to deploy function (Optional). By default, interactive prompt is shown to select workspace"
+    "-w, --workspace <id-or-slug>",
+    'Workspace id or slug to deploy to (Optional). Falls back to jitsu.json / package.json "jitsu" config, then the default workspace, then an interactive prompt'
   )
   .option("-t, --type <type>", "entity type to deploy", "function")
   .option("-n, --name <name...>", "limit deploy to provided entities only. (Optional)")
   .action(deploy);
 
-//version
+p.command("set-default-workspace")
+  .description(
+    "Save a default workspace to ~/.jitsu/jitsu-cli.json. Subsequent `jitsu config` commands use it when -w is omitted."
+  )
+  .argument("<id-or-slug>", "Workspace id or slug")
+  .option("-h, --host <host>", "Jitsu host (overrides ~/.jitsu/jitsu-cli.json)")
+  .option("-k, --apikey <api-key>", "API key in form keyId:secret (overrides ~/.jitsu/jitsu-cli.json)")
+  .action(setDefaultWorkspace);
+
+p.command("unset-default-workspace")
+  .description("Remove the saved default workspace from ~/.jitsu/jitsu-cli.json")
+  .action(unsetDefaultWorkspace);
+
+p.addCommand(buildConfigCommand());
+p.addCommand(buildSpecCommand());
+
 p.version(jitsuCliPackageName + " " + jitsuCliVersion, "-v, --version");
-//help
 p.helpOption("--help", "display help for command");
 
 p.parse();

package/src/lib/api-client.ts

@@ -0,0 +1,64 @@
+import { AuthInfo } from "./auth-file";
+
+export type ApiRequest = {
+  method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+  path: string;
+  query?: Record<string, string | number | boolean | undefined | null>;
+  body?: unknown;
+};
+
+export class ApiError extends Error {
+  status: number;
+  payload: unknown;
+  constructor(status: number, message: string, payload: unknown) {
+    super(message);
+    this.status = status;
+    this.payload = payload;
+  }
+}
+
+export class ApiClient {
+  constructor(private auth: AuthInfo) {}
+
+  url(path: string, query?: ApiRequest["query"]): string {
+    const base = this.auth.host;
+    const p = path.startsWith("/") ? path : `/${path}`;
+    if (!query) return `${base}${p}`;
+    const qs = Object.entries(query)
+      .filter(([, v]) => v !== undefined && v !== null && v !== "")
+      .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+      .join("&");
+    return qs ? `${base}${p}?${qs}` : `${base}${p}`;
+  }
+
+  async request<T = unknown>(req: ApiRequest): Promise<T> {
+    const method = req.method ?? "GET";
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      Authorization: `Bearer ${this.auth.apikey}`,
+    };
+    let body: string | undefined;
+    if (req.body !== undefined) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(req.body);
+    }
+    const res = await fetch(this.url(req.path, req.query), { method, headers, body });
+    const text = await res.text();
+    let parsed: unknown = text;
+    if (text && res.headers.get("content-type")?.includes("application/json")) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        // fall through with raw text
+      }
+    }
+    if (!res.ok) {
+      const msg =
+        (parsed && typeof parsed === "object" && "message" in (parsed as any)
+          ? String((parsed as any).message)
+          : undefined) ?? `HTTP ${res.status} ${method} ${req.path}`;
+      throw new ApiError(res.status, msg, parsed);
+    }
+    return parsed as T;
+  }
+}