zinkee 0.1.44 → 0.1.45

package/src/cli-runner.ts

@@ -1,95 +0,0 @@
-import { realpathSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-import chalk from "chalk";
-
-import { extractExampleRequest, showExamples } from "./cli-examples.js";
-import { commandRegistry } from "./command-registry.js";
-import {
-  extractCompletionFlag,
-  handleCompletionFlag,
-  isCompletionRequest,
-  runCompletionRequest,
-} from "./completion/runtime.js";
-import { buildProgram } from "./program.js";
-import {
-  buildOptionMetadata,
-  hoistGlobalOptions,
-} from "./utils/argv-rewrite.js";
-import {
-  formatCliErrorJson,
-  formatCliErrorText,
-  getExitCode,
-} from "./utils/errors.js";
-
-class ExampleDisplayed extends Error {
-  override name = "ExampleDisplayed";
-}
-
-function hasJsonOutput(argv: readonly string[]): boolean {
-  return argv.includes("--json");
-}
-
-function resolveExecutablePath(candidatePath: string): string {
-  try {
-    return realpathSync(candidatePath);
-  } catch {
-    return candidatePath;
-  }
-}
-
-export function isExecutedAsEntry(argvEntry: string | undefined, moduleUrl: string): boolean {
-  if (!argvEntry) {
-    return false;
-  }
-
-  return resolveExecutablePath(argvEntry) === resolveExecutablePath(fileURLToPath(moduleUrl));
-}
-
-export async function runCli(argv: string[]): Promise<void> {
-  try {
-    if (isCompletionRequest()) {
-      runCompletionRequest();
-      return;
-    }
-
-    const completionFlag = extractCompletionFlag(argv);
-    if (completionFlag) {
-      const exitCode = handleCompletionFlag(completionFlag);
-      process.exitCode = exitCode;
-      return;
-    }
-
-    const program = buildProgram();
-    const optionMeta = buildOptionMetadata(program);
-    const exampleRequest = extractExampleRequest(argv, optionMeta);
-
-    if (exampleRequest) {
-      showExamples(
-        exampleRequest.commandName,
-        exampleRequest.json,
-        undefined,
-        exampleRequest.filters,
-      );
-      throw new ExampleDisplayed();
-    }
-
-    const rewrittenArgv = hoistGlobalOptions(argv, optionMeta, commandRegistry);
-    await program.parseAsync(rewrittenArgv);
-  } catch (error) {
-    if (error instanceof ExampleDisplayed) {
-      process.exitCode = 0;
-      return;
-    }
-
-    const exitCode = getExitCode(error);
-
-    if (hasJsonOutput(argv)) {
-      process.stderr.write(`${formatCliErrorJson(error, { exitCode })}\n`);
-    } else {
-      process.stderr.write(`${chalk.red("Error:")} ${formatCliErrorText(error)}\n`);
-    }
-
-    process.exitCode = exitCode;
-  }
-}

package/src/client.test.ts

@@ -1,189 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import { ApiClient, ApiClientError } from "./client.js";
-
-type FetchInput = Parameters<typeof fetch>[0];
-
-function jsonResponse(body: unknown, init: ResponseInit = {}): Response {
-  return new Response(JSON.stringify(body), {
-    ...init,
-    headers: {
-      "content-type": "application/json",
-      ...(init.headers ?? {}),
-    },
-  });
-}
-
-function binaryResponse(bytes: number[], init: ResponseInit = {}): Response {
-  return new Response(new Uint8Array(bytes), {
-    ...init,
-    headers: {
-      "content-type": "application/octet-stream",
-      ...(init.headers ?? {}),
-    },
-  });
-}
-
-describe("ApiClient", () => {
-  it("adds auth headers and parses JSON responses", async () => {
-    const fetchMock = vi.fn(async (_input: FetchInput, init?: RequestInit) => {
-      const headers = new Headers(init?.headers);
-
-      expect(headers.get("authorization")).toBe("Bearer secret");
-      expect(headers.get("accept")).toBe("application/json");
-
-      return jsonResponse({ data: { id: "1" } });
-    });
-
-    const client = new ApiClient({
-      baseUrl: "https://api.example.com",
-      apiKey: "secret",
-      fetch: fetchMock,
-    });
-
-    await expect(client.getJson<{ data: { id: string } }>("/api/v2/schemas")).resolves.toEqual({
-      data: { id: "1" },
-    });
-  });
-
-  it("preserves JSON error payloads from failed responses", async () => {
-    const fetchMock = vi.fn(async () =>
-      jsonResponse(
-        {
-          error: { code: "bad_request", message: "Bad request" },
-          meta: { requestId: "req_1" },
-        },
-        { status: 400, statusText: "Bad Request" },
-      ),
-    );
-
-    const client = new ApiClient({
-      baseUrl: "https://api.example.com",
-      fetch: fetchMock,
-    });
-
-    await expect(client.getJson("/api/v2/schemas")).rejects.toMatchObject({
-      name: "ApiClientError",
-      code: "http_error",
-      status: 400,
-      responseBody: {
-        error: { code: "bad_request", message: "Bad request" },
-        meta: { requestId: "req_1" },
-      },
-    });
-  });
-
-  it("times out slow requests", async () => {
-    vi.useFakeTimers();
-
-    try {
-      const fetchMock = vi.fn(
-        (_input: FetchInput, init?: RequestInit) =>
-          new Promise<Response>((_resolve, reject) => {
-            const signal = init?.signal;
-
-            signal?.addEventListener(
-              "abort",
-              () => {
-                reject(new Error("aborted"));
-              },
-              { once: true },
-            );
-          }),
-      );
-
-      const client = new ApiClient({
-        baseUrl: "https://api.example.com",
-        timeoutMs: 10,
-        fetch: fetchMock,
-      });
-
-      const promise = client.getJson("/api/v2/schemas");
-      const assertion = expect(promise).rejects.toMatchObject({
-        name: "ApiClientError",
-        code: "timeout",
-        message: "Request timed out after 10ms.",
-      });
-
-      await vi.advanceTimersByTimeAsync(10);
-
-      await assertion;
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it("surfaces the underlying network cause in the error message", async () => {
-    const dnsCause = Object.assign(new Error("getaddrinfo ENOTFOUND api-z2.zinkee.invalid"), {
-      code: "ENOTFOUND",
-    });
-    const fetchError = Object.assign(new TypeError("fetch failed"), { cause: dnsCause });
-    const fetchMock = vi.fn(async () => {
-      throw fetchError;
-    });
-
-    const client = new ApiClient({
-      baseUrl: "https://api-z2.zinkee.invalid",
-      fetch: fetchMock,
-    });
-
-    await expect(client.getJson("/api/v2/schemas")).rejects.toMatchObject({
-      name: "ApiClientError",
-      code: "network_error",
-      message:
-        "Request failed for GET https://api-z2.zinkee.invalid/api/v2/schemas: getaddrinfo ENOTFOUND api-z2.zinkee.invalid.",
-      cause: fetchError,
-    });
-  });
-
-  it("appends the cause code when it is not already part of the message", async () => {
-    const tlsCause = Object.assign(new Error("self signed certificate"), {
-      code: "DEPTH_ZERO_SELF_SIGNED_CERT",
-    });
-    const fetchError = Object.assign(new TypeError("fetch failed"), { cause: tlsCause });
-    const fetchMock = vi.fn(async () => {
-      throw fetchError;
-    });
-
-    const client = new ApiClient({
-      baseUrl: "https://self-signed.example.com",
-      fetch: fetchMock,
-    });
-
-    await expect(client.getJson("/api/v2/schemas")).rejects.toMatchObject({
-      code: "network_error",
-      message:
-        "Request failed for GET https://self-signed.example.com/api/v2/schemas: self signed certificate (DEPTH_ZERO_SELF_SIGNED_CERT).",
-    });
-  });
-
-  it("falls back to the bare message when the network cause has no useful detail", async () => {
-    const fetchMock = vi.fn(async () => {
-      throw new TypeError("fetch failed");
-    });
-
-    const client = new ApiClient({
-      baseUrl: "https://api.example.com",
-      fetch: fetchMock,
-    });
-
-    await expect(client.getJson("/api/v2/schemas")).rejects.toMatchObject({
-      name: "ApiClientError",
-      code: "network_error",
-      message: "Request failed for GET https://api.example.com/api/v2/schemas.",
-    });
-  });
-
-  it("returns binary responses as ArrayBuffers", async () => {
-    const fetchMock = vi.fn(async () => binaryResponse([1, 2, 3]));
-
-    const client = new ApiClient({
-      baseUrl: "https://api.example.com",
-      fetch: fetchMock,
-    });
-
-    const result = await client.requestBinary("/api/v2/files/abc");
-
-    expect(Array.from(new Uint8Array(result))).toEqual([1, 2, 3]);
-  });
-});

package/src/client.ts

@@ -1,269 +0,0 @@
-export interface ApiClientOptions {
-  baseUrl: string;
-  apiKey?: string;
-  timeoutMs?: number;
-  fetch?: typeof fetch;
-}
-
-export type ApiClientErrorCode =
-  | "network_error"
-  | "http_error"
-  | "timeout"
-  | "invalid_json";
-
-export interface ApiClientErrorDetails {
-  url: string;
-  method: string;
-  status?: number;
-  responseBody?: unknown;
-  responseText?: string;
-  cause?: unknown;
-}
-
-export class ApiClientError extends Error {
-  override name = "ApiClientError";
-
-  readonly code: ApiClientErrorCode;
-
-  readonly url: string;
-
-  readonly method: string;
-
-  readonly status?: number;
-
-  readonly responseBody?: unknown;
-
-  readonly responseText?: string;
-
-  override readonly cause?: unknown;
-
-  constructor(
-    code: ApiClientErrorCode,
-    message: string,
-    details: ApiClientErrorDetails,
-  ) {
-    super(message);
-    this.code = code;
-    this.url = details.url;
-    this.method = details.method;
-    this.status = details.status;
-    this.responseBody = details.responseBody;
-    this.responseText = details.responseText;
-    this.cause = details.cause;
-  }
-}
-
-export interface ApiRequestOptions extends RequestInit {
-  timeoutMs?: number;
-}
-
-function isJsonContentType(contentType: string | null): boolean {
-  return contentType ? /(^|\/|\+)json\b/i.test(contentType) : false;
-}
-
-function looksLikeJson(text: string): boolean {
-  const trimmed = text.trim();
-
-  return (
-    trimmed.startsWith("{") ||
-    trimmed.startsWith("[") ||
-    trimmed === "null" ||
-    trimmed === "true" ||
-    trimmed === "false" ||
-    /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?$/.test(trimmed) ||
-    trimmed.startsWith('"')
-  );
-}
-
-function parseJsonBody<T>(text: string, url: string, method: string): T {
-  const trimmed = text.trim();
-
-  if (trimmed.length === 0) {
-    return undefined as T;
-  }
-
-  try {
-    return JSON.parse(trimmed) as T;
-  } catch (cause) {
-    throw new ApiClientError("invalid_json", `Failed to parse JSON response from ${method} ${url}.`, {
-      url,
-      method,
-      responseText: text,
-      cause,
-    });
-  }
-}
-
-function parseErrorBody(text: string, contentType: string | null): unknown {
-  if (text.trim().length === 0) {
-    return undefined;
-  }
-
-  if (!isJsonContentType(contentType) && !looksLikeJson(text)) {
-    return text;
-  }
-
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-
-function summarizeNetworkCause(cause: unknown): string | undefined {
-  const seen = new Set<unknown>();
-  let current: unknown = cause;
-
-  while (current && typeof current === "object" && !seen.has(current)) {
-    seen.add(current);
-
-    const candidate = current as { message?: unknown; code?: unknown; cause?: unknown };
-    const message = typeof candidate.message === "string" ? candidate.message.trim() : "";
-    const code = typeof candidate.code === "string" ? candidate.code : undefined;
-
-    if (message && message !== "fetch failed") {
-      return code && !message.includes(code) ? `${message} (${code})` : message;
-    }
-
-    current = candidate.cause;
-  }
-
-  return undefined;
-}
-
-export class ApiClient {
-  private readonly fetchImpl: typeof fetch;
-
-  constructor(private readonly options: ApiClientOptions) {
-    this.fetchImpl = options.fetch ?? fetch;
-  }
-
-  async getJson<T>(path: string, init: ApiRequestOptions = {}): Promise<T> {
-    return this.requestJson<T>(path, { ...init, method: "GET" });
-  }
-
-  async requestJson<T>(path: string, init: ApiRequestOptions = {}): Promise<T> {
-    const response = await this.request(path, init, "application/json");
-
-    if (!response.ok) {
-      const text = await response.text();
-      throw this.buildHttpError(response, text, init, "requestJson");
-    }
-
-    const text = await response.text();
-    return parseJsonBody<T>(text, response.url, init.method ?? "GET");
-  }
-
-  async requestBinary(path: string, init: ApiRequestOptions = {}): Promise<ArrayBuffer> {
-    const response = await this.request(path, init);
-
-    if (!response.ok) {
-      const text = await response.text();
-      throw this.buildHttpError(response, text, init, "requestBinary");
-    }
-
-    return response.arrayBuffer();
-  }
-
-  private buildUrl(path: string): string {
-    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-
-    return new URL(normalizedPath, this.options.baseUrl).toString();
-  }
-
-  private async request(
-    path: string,
-    init: ApiRequestOptions,
-    accept?: string,
-  ): Promise<Response> {
-    const url = this.buildUrl(path);
-    const method = init.method ?? "GET";
-    const headers = new Headers(init.headers);
-
-    if (accept && !headers.has("accept")) {
-      headers.set("accept", accept);
-    }
-
-    if (this.options.apiKey && !headers.has("authorization")) {
-      headers.set("authorization", `Bearer ${this.options.apiKey}`);
-    }
-
-    const controller = new AbortController();
-    const timeoutMs = init.timeoutMs ?? this.options.timeoutMs;
-    let timedOut = false;
-    let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
-
-    const abortListener = (): void => {
-      controller.abort();
-    };
-
-    if (init.signal) {
-      if (init.signal.aborted) {
-        controller.abort();
-      } else {
-        init.signal.addEventListener("abort", abortListener, { once: true });
-      }
-    }
-
-    if (timeoutMs !== undefined) {
-      timeoutHandle = setTimeout(() => {
-        timedOut = true;
-        controller.abort();
-      }, timeoutMs);
-    }
-
-    try {
-      return await this.fetchImpl(url, {
-        ...init,
-        headers,
-        signal: controller.signal,
-      });
-    } catch (cause) {
-      if (timedOut) {
-        throw new ApiClientError("timeout", `Request timed out after ${timeoutMs}ms.`, {
-          url,
-          method,
-          cause,
-        });
-      }
-
-      const causeSummary = summarizeNetworkCause(cause);
-      const message = causeSummary
-        ? `Request failed for ${method} ${url}: ${causeSummary}.`
-        : `Request failed for ${method} ${url}.`;
-
-      throw new ApiClientError("network_error", message, {
-        url,
-        method,
-        cause,
-      });
-    } finally {
-      if (timeoutHandle !== undefined) {
-        clearTimeout(timeoutHandle);
-      }
-
-      if (init.signal) {
-        init.signal.removeEventListener("abort", abortListener);
-      }
-    }
-  }
-
-  private buildHttpError(
-    response: Response,
-    text: string,
-    init: ApiRequestOptions,
-    operation: string,
-  ): ApiClientError {
-    const method = init.method ?? "GET";
-    const responseBody = parseErrorBody(text, response.headers.get("content-type"));
-
-    return new ApiClientError("http_error", `Request failed with status ${response.status} for ${method} ${response.url}.`, {
-      url: response.url,
-      method,
-      status: response.status,
-      responseBody,
-      responseText: responseBody === text ? text : undefined,
-      cause: new Error(operation),
-    });
-  }
-}