zinkee 0.1.44 → 0.1.46

package/src/commands/records.test.ts

@@ -1,860 +0,0 @@
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { buildProgram } from "../index.js";
-
-function createTempConfig(contents: string): string {
-  const dir = mkdtempSync(join(tmpdir(), "zinkee-records-"));
-  const filePath = join(dir, "config.toml");
-  writeFileSync(filePath, contents, "utf8");
-  return filePath;
-}
-
-function createApiConfig(): string {
-  return createTempConfig(`
-default_profile = "prod"
-
-[profiles.prod]
-api_key = "records-token-1234"
-base_url = "https://api.zinkee.test"
-`);
-}
-
-function createStdoutBuffer() {
-  let output = "";
-
-  return {
-    stdout: {
-      write(chunk: string) {
-        output += chunk;
-        return true;
-      },
-    },
-    read() {
-      return output;
-    },
-  };
-}
-
-function jsonResponse(body: unknown, status: number = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: {
-      "content-type": "application/json",
-    },
-  });
-}
-
-function createFetchMock() {
-  const fetchMock = vi.fn<typeof fetch>();
-  vi.stubGlobal("fetch", fetchMock);
-  return fetchMock;
-}
-
-function mockSchemaLookup(fetchMock: ReturnType<typeof createFetchMock>, id: string = "schema-1") {
-  fetchMock.mockResolvedValueOnce(
-    jsonResponse([
-      {
-        id,
-        slug: "contacts",
-        name: "Contacts",
-      },
-    ]),
-  );
-}
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.restoreAllMocks();
-});
-
-describe("records commands", () => {
-  it("registers the records command group", () => {
-    const program = buildProgram();
-
-    expect(program.commands.some((command) => command.name() === "records")).toBe(true);
-  });
-
-  it("lists records with simple pagination and emits page metadata", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        records: [
-          {
-            recordId: "record-1",
-            values: { name: "Ana" },
-          },
-        ],
-        page: { offset: 20, limit: 10, total: 1, count: 1, hasMore: false },
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "list",
-      "contacts",
-      "--limit",
-      "10",
-      "--offset",
-      "20",
-    ]);
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://api.zinkee.test/api/v2/schemas");
-
-    const url = new URL(String(fetchMock.mock.calls[1]?.[0]));
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(url.origin + url.pathname).toBe("https://api.zinkee.test/api/v2/schemas/schema-1/records");
-    expect(init?.method).toBe("GET");
-    expect(url.searchParams.get("limit")).toBe("10");
-    expect(url.searchParams.get("offset")).toBe("20");
-    expect(JSON.parse(output.read())).toEqual({
-      data: [{ recordId: "record-1", values: { name: "Ana" } }],
-      meta: {
-        command: "records list",
-        configPath,
-        page: { offset: 20, limit: 10, total: 1, count: 1, hasMore: false },
-      },
-    });
-  });
-
-  it("queries records with the same normalized query model used by list", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        records: [{ recordId: "record-1", values: { name: "Ana" } }],
-        page: { offset: 10, limit: 5, total: 1, count: 1, hasMore: false },
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "query",
-      "contacts",
-      "--select",
-      "id,name",
-      "--where",
-      "status eq active",
-      "--sort",
-      "name:asc,createdAt:desc",
-      "--limit",
-      "5",
-      "--offset",
-      "10",
-      "--raw",
-      '{"select":["wrong"],"extra":"keep"}',
-    ]);
-
-    const init = fetchMock.mock.calls[1]?.[1];
-    const headers = new Headers(init?.headers);
-
-    expect(fetchMock.mock.calls[1]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/schemas/schema-1/records:query",
-    );
-    expect(init?.method).toBe("POST");
-    expect(headers.get("content-type")).toBe("application/json");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      extra: "keep",
-      select: ["id", "name"],
-      where: [
-        {
-          field: "status",
-          op: "eq",
-          value: "active",
-        },
-      ],
-      sort: [
-        { field: "name", direction: "ASC" },
-        { field: "createdAt", direction: "DESC" },
-      ],
-      page: { limit: 5, offset: 10 },
-    });
-    expect(JSON.parse(output.read())).toEqual({
-      data: [{ recordId: "record-1", values: { name: "Ana" } }],
-      meta: {
-        command: "records query",
-        configPath,
-        page: { offset: 10, limit: 5, total: 1, count: 1, hasMore: false },
-      },
-    });
-  });
-
-  it("maps --search to a search.term object in the query body", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        records: [{ recordId: "record-1", values: { name: "Ana Garcia" } }],
-        page: { offset: 0, limit: 25, total: 1, count: 1, hasMore: false },
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "query",
-      "contacts",
-      "--select",
-      "id,name,status",
-      "--where",
-      "status in OPEN",
-      "--search",
-      "garcia",
-      "--limit",
-      "25",
-    ]);
-
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(JSON.parse(String(init?.body))).toEqual({
-      select: ["id", "name", "status"],
-      where: [{ field: "status", op: "in", value: ["OPEN"] }],
-      search: { term: "garcia" },
-      page: { limit: 25 },
-    });
-  });
-
-  it("accumulates repeated --select flags into a single field selection", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        records: [{ recordId: "record-1", values: { name: "Ana" } }],
-        page: { offset: 0, limit: 25, total: 1, count: 1, hasMore: false },
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "query",
-      "contacts",
-      "--select",
-      "campo-1",
-      "--select",
-      "campo-2",
-    ]);
-
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(JSON.parse(String(init?.body))).toEqual({
-      select: ["campo-1", "campo-2"],
-    });
-  });
-
-  it("mixes comma-separated and repeated --select flags preserving order", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        records: [{ recordId: "record-1", values: { name: "Ana" } }],
-        page: { offset: 0, limit: 25, total: 1, count: 1, hasMore: false },
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "query",
-      "contacts",
-      "--select",
-      "a,b",
-      "--select",
-      "c",
-    ]);
-
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(JSON.parse(String(init?.body))).toEqual({
-      select: ["a", "b", "c"],
-    });
-  });
-
-  it("deduplicates repeated fields across --select and --sort flags", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        records: [{ recordId: "record-1", values: { name: "Ana" } }],
-        page: { offset: 0, limit: 25, total: 1, count: 1, hasMore: false },
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "query",
-      "contacts",
-      "--select",
-      "id",
-      "--select",
-      "id",
-      "--sort",
-      "name:asc",
-      "--sort",
-      "name:asc",
-    ]);
-
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(JSON.parse(String(init?.body))).toEqual({
-      select: ["id"],
-      sort: [{ field: "name", direction: "ASC" }],
-    });
-  });
-
-  it("normalizes UUID selectors for records get", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        recordId: "550e8400-e29b-41d4-a716-446655440001",
-        values: { name: "Ana" },
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "get",
-      "550E8400-E29B-41D4-A716-446655440000",
-      "550E8400-E29B-41D4-A716-446655440001",
-    ]);
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/schemas/550e8400-e29b-41d4-a716-446655440000/records/550e8400-e29b-41d4-a716-446655440001",
-    );
-  });
-
-  it("creates a single record by merging raw JSON with set and set-json assignments", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        created: ["record-1"],
-        errors: [],
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "create",
-      "contacts",
-      "--set",
-      "name=Ana",
-      "--set-json",
-      'profile={"tier":"gold"}',
-      "--raw",
-      '{"name":"Wrong","status":"active"}',
-    ]);
-
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(fetchMock.mock.calls[1]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/schemas/schema-1/records",
-    );
-    expect(init?.method).toBe("POST");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      records: [
-        {
-          name: "Ana",
-          status: "active",
-          profile: {
-            tier: "gold",
-          },
-        },
-      ],
-    });
-  });
-
-  it("creates multiple records from a --records-file", async () => {
-    const configPath = createApiConfig();
-    const recordsFile = createTempConfig(
-      JSON.stringify([
-        { "contact-name": "Ada", status: 2 },
-        { "contact-name": "Grace", tags: ["a", "b"] },
-      ]),
-    );
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        created: ["record-1", "record-2"],
-        errors: [],
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "create",
-      "contacts",
-      "--records-file",
-      recordsFile,
-    ]);
-
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(fetchMock.mock.calls[1]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/schemas/schema-1/records",
-    );
-    expect(init?.method).toBe("POST");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      records: [
-        { "contact-name": "Ada", status: 2 },
-        { "contact-name": "Grace", tags: ["a", "b"] },
-      ],
-    });
-  });
-
-  it("rejects combining --records-file with single-record flags", async () => {
-    const configPath = createApiConfig();
-    const recordsFile = createTempConfig(JSON.stringify([{ "contact-name": "Ada" }]));
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "records",
-        "create",
-        "contacts",
-        "--records-file",
-        recordsFile,
-        "--set",
-        "contact-name=Grace",
-      ]),
-    ).rejects.toThrowError(/not both/);
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("rejects a --records-file that is not a JSON array", async () => {
-    const configPath = createApiConfig();
-    const recordsFile = createTempConfig(JSON.stringify({ "contact-name": "Ada" }));
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "records",
-        "create",
-        "contacts",
-        "--records-file",
-        recordsFile,
-      ]),
-    ).rejects.toThrowError(/JSON array/);
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("wraps raw-file fields into the set payload", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const rawFile = join(
-      mkdtempSync(join(tmpdir(), "zinkee-record-update-")),
-      "record.json",
-    );
-    writeFileSync(
-      rawFile,
-      JSON.stringify({
-        status: "inactive",
-        metadata: {
-          imported: true,
-        },
-      }),
-      "utf8",
-    );
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        id: "550e8400-e29b-41d4-a716-446655440001",
-        status: "active",
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "update",
-      "contacts",
-      "550E8400-E29B-41D4-A716-446655440001",
-      "--set",
-      "status=active",
-      "--set-json",
-      'profile={"tier":"gold"}',
-      "--unset",
-      "tempField",
-      "--unset",
-      "status",
-      "--raw-file",
-      rawFile,
-    ]);
-
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(fetchMock.mock.calls[1]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/schemas/schema-1/records/550e8400-e29b-41d4-a716-446655440001",
-    );
-    expect(init?.method).toBe("PATCH");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      set: {
-        status: "active",
-        metadata: {
-          imported: true,
-        },
-        profile: {
-          tier: "gold",
-        },
-      },
-      unset: ["tempField"],
-    });
-  });
-
-  it("wraps bare raw fields into the set payload", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        id: "550e8400-e29b-41d4-a716-446655440001",
-        uno: "prueba mod",
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "update",
-      "contacts",
-      "550E8400-E29B-41D4-A716-446655440001",
-      "--raw",
-      '{"uno":"prueba mod"}',
-    ]);
-
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(fetchMock.mock.calls[1]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/schemas/schema-1/records/550e8400-e29b-41d4-a716-446655440001",
-    );
-    expect(init?.method).toBe("PATCH");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      set: {
-        uno: "prueba mod",
-      },
-    });
-  });
-
-  it("lets --set override raw fields with the same key", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        id: "550e8400-e29b-41d4-a716-446655440001",
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "update",
-      "contacts",
-      "550E8400-E29B-41D4-A716-446655440001",
-      "--raw",
-      '{"uno":"raw value"}',
-      "--set",
-      "uno=set value",
-    ]);
-
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(init?.method).toBe("PATCH");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      set: {
-        uno: "set value",
-      },
-    });
-  });
-
-  it("blocks destructive record commands in read-only mode", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--read-only",
-        "records",
-        "delete",
-        "contacts",
-        "--record",
-        "550e8400-e29b-41d4-a716-446655440000",
-      ]),
-    ).rejects.toThrowError('Command "records delete" is not allowed in read-only mode.');
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("deletes multiple records via repeatable --record flags and de-duplicates", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        recordIds: [
-          "550e8400-e29b-41d4-a716-446655440000",
-          "550e8400-e29b-41d4-a716-446655440001",
-        ],
-        deleted: true,
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "delete",
-      "contacts",
-      "--record",
-      "550e8400-e29b-41d4-a716-446655440000",
-      "--record",
-      "550e8400-e29b-41d4-a716-446655440001",
-      "--record",
-      "550e8400-e29b-41d4-a716-446655440000",
-    ]);
-
-    expect(fetchMock.mock.calls[1]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/schemas/schema-1/records:delete",
-    );
-
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(init?.method).toBe("POST");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      recordIds: [
-        "550e8400-e29b-41d4-a716-446655440000",
-        "550e8400-e29b-41d4-a716-446655440001",
-      ],
-    });
-
-    const payload = JSON.parse(output.read());
-
-    expect(payload.data).toEqual({
-      recordIds: [
-        "550e8400-e29b-41d4-a716-446655440000",
-        "550e8400-e29b-41d4-a716-446655440001",
-      ],
-      deleted: true,
-    });
-  });
-
-  it("loads record ids from a file and merges them with --record", async () => {
-    const configPath = createApiConfig();
-    const idsFile = createTempConfig(
-      "550e8400-e29b-41d4-a716-446655440000\n  550e8400-e29b-41d4-a716-446655440002  \n\n",
-    );
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        recordIds: [
-          "550e8400-e29b-41d4-a716-446655440000",
-          "550e8400-e29b-41d4-a716-446655440002",
-        ],
-        deleted: true,
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "delete",
-      "contacts",
-      "--record",
-      "550e8400-e29b-41d4-a716-446655440000",
-      "--records-file",
-      idsFile,
-    ]);
-
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(init?.method).toBe("POST");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      recordIds: [
-        "550e8400-e29b-41d4-a716-446655440000",
-        "550e8400-e29b-41d4-a716-446655440002",
-      ],
-    });
-  });
-
-  it("requires at least one record id for delete", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await expect(
-      program.parseAsync(["node", "zinkee", "records", "delete", "contacts"]),
-    ).rejects.toThrowError(/at least one record id/);
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("rejects a non-uuid record id for delete", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "records",
-        "delete",
-        "contacts",
-        "--record",
-        "not-a-uuid",
-      ]),
-    ).rejects.toThrow();
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("clears all records in a schema", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    mockSchemaLookup(fetchMock);
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        schemaId: "schema-1",
-        cleared: true,
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "records",
-      "clear",
-      "contacts",
-    ]);
-
-    const init = fetchMock.mock.calls[1]?.[1];
-
-    expect(fetchMock.mock.calls[1]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/schemas/schema-1/records:clear",
-    );
-    expect(init?.method).toBe("DELETE");
-    expect(init?.body).toBeUndefined();
-
-    const payload = JSON.parse(output.read());
-
-    expect(payload.data).toEqual({
-      schemaId: "schema-1",
-      cleared: true,
-    });
-  });
-
-  it("blocks records clear in read-only mode", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--read-only",
-        "records",
-        "clear",
-        "contacts",
-      ]),
-    ).rejects.toThrowError('Command "records clear" is not allowed in read-only mode.');
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-});