zinkee 0.1.0

package/src/commands/schemas.test.ts

@@ -0,0 +1,748 @@
+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-schemas-"));
+  const filePath = join(dir, "config.toml");
+  writeFileSync(filePath, contents, "utf8");
+  return filePath;
+}
+
+function createApiConfig(): string {
+  return createTempConfig(`
+default_profile = "prod"
+
+[profiles.prod]
+api_key = "schema-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("schemas commands", () => {
+  it("registers the schemas command group", () => {
+    const program = buildProgram();
+
+    expect(program.commands.some((command) => command.name() === "schemas")).toBe(true);
+  });
+
+  it("lists schemas through /api/v2/schemas and emits a JSON envelope", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse([
+        {
+          id: "schema-1",
+          name: "Contacts",
+          slug: "contacts",
+          auditable: true,
+          commentable: false,
+        },
+      ]),
+    );
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await program.parseAsync(["node", "zinkee", "--json", "schemas", "list"]);
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://api.zinkee.test/api/v2/schemas");
+
+    const init = fetchMock.mock.calls[0]?.[1];
+    const headers = new Headers(init?.headers);
+
+    expect(init?.method).toBe("GET");
+    expect(headers.get("accept")).toBe("application/json");
+    expect(headers.get("authorization")).toBe("Bearer schema-token-1234");
+    expect(JSON.parse(output.read())).toEqual({
+      data: [
+        {
+          id: "schema-1",
+          name: "Contacts",
+          slug: "contacts",
+          auditable: true,
+          commentable: false,
+        },
+      ],
+      meta: {
+        command: "schemas list",
+        configPath,
+      },
+    });
+  });
+
+  it("normalizes UUID selectors for schemas get", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "550e8400-e29b-41d4-a716-446655440000",
+        name: "Contacts",
+        slug: "contacts",
+      }),
+    );
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await program.parseAsync([
+      "node",
+      "zinkee",
+      "--json",
+      "schemas",
+      "get",
+      "550E8400-E29B-41D4-A716-446655440000",
+    ]);
+
+    expect(fetchMock.mock.calls[0]?.[0]).toBe(
+      "https://api.zinkee.test/api/v2/schemas/550e8400-e29b-41d4-a716-446655440000",
+    );
+  });
+
+  it("creates schemas with the expected request body", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "schema-1",
+        name: "Contacts",
+        slug: "contacts",
+        auditable: true,
+        commentable: true,
+      }),
+    );
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await program.parseAsync([
+      "node",
+      "zinkee",
+      "--json",
+      "schemas",
+      "create",
+      "--name",
+      "Contacts",
+      "--slug",
+      "contacts",
+      "--auditable",
+      "--commentable",
+    ]);
+
+    const init = fetchMock.mock.calls[0]?.[1];
+    const headers = new Headers(init?.headers);
+
+    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://api.zinkee.test/api/v2/schemas");
+    expect(init?.method).toBe("POST");
+    expect(headers.get("content-type")).toBe("application/json");
+    expect(JSON.parse(String(init?.body))).toEqual({
+      name: "Contacts",
+      slug: "contacts",
+      auditable: true,
+      commentable: true,
+    });
+  });
+
+  it("blocks destructive schema 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",
+        "schemas",
+        "delete",
+        "contacts",
+      ]),
+    ).rejects.toThrowError('Command "schemas delete" is not allowed in read-only mode.');
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("creates fields by merging raw JSON with explicit flags", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    mockSchemaLookup(fetchMock);
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "field-1",
+        type: "text",
+        slug: "email",
+        label: "Email",
+        required: true,
+        settings: {
+          maxLength: 255,
+        },
+      }),
+    );
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await program.parseAsync([
+      "node",
+      "zinkee",
+      "--json",
+      "schemas",
+      "fields",
+      "create",
+      "contacts",
+      "--type",
+      "text",
+      "--slug",
+      "email",
+      "--label",
+      "Email",
+      "--required",
+      "true",
+      "--raw",
+      '{"settings":{"maxLength":255},"label":"Wrong","required":false}',
+    ]);
+
+    const init = fetchMock.mock.calls[1]?.[1];
+
+    expect(fetchMock.mock.calls[1]?.[0]).toBe(
+      "https://api.zinkee.test/api/v2/schemas/schema-1/fields",
+    );
+    expect(init?.method).toBe("POST");
+    expect(JSON.parse(String(init?.body))).toEqual({
+      settings: {
+        maxLength: 255,
+      },
+      type: "TextField",
+      slug: "email",
+      label: "Email",
+      required: true,
+    });
+  });
+
+  it("updates fields from a raw file and normalizes field UUID selectors", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    const rawFile = join(
+      mkdtempSync(join(tmpdir(), "zinkee-field-update-")),
+      "field.json",
+    );
+    writeFileSync(
+      rawFile,
+      JSON.stringify({
+        settings: {
+          multiline: true,
+        },
+      }),
+      "utf8",
+    );
+    mockSchemaLookup(fetchMock);
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "550e8400-e29b-41d4-a716-446655440001",
+        type: "TextField",
+        slug: "notes",
+        label: "Notes",
+        required: false,
+      }),
+    );
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "550e8400-e29b-41d4-a716-446655440001",
+        slug: "notes",
+        label: "Notes",
+        required: false,
+        settings: {
+          multiline: true,
+        },
+      }),
+    );
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await program.parseAsync([
+      "node",
+      "zinkee",
+      "--json",
+      "schemas",
+      "fields",
+      "update",
+      "contacts",
+      "550E8400-E29B-41D4-A716-446655440001",
+      "--label",
+      "Notes",
+      "--required",
+      "false",
+      "--raw-file",
+      rawFile,
+    ]);
+
+    const init = fetchMock.mock.calls[2]?.[1];
+
+    expect(fetchMock.mock.calls[2]?.[0]).toBe(
+      "https://api.zinkee.test/api/v2/schemas/schema-1/fields/550e8400-e29b-41d4-a716-446655440001",
+    );
+    expect(init?.method).toBe("PATCH");
+    expect(JSON.parse(String(init?.body))).toEqual({
+      settings: {
+        multiline: true,
+      },
+      type: "TextField",
+      label: "Notes",
+      required: false,
+    });
+  });
+
+  it("strips formula status from update payloads", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    mockSchemaLookup(fetchMock);
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "550e8400-e29b-41d4-a716-446655440002",
+        type: "FormulaField",
+        slug: "total",
+        label: "Total",
+        required: false,
+      }),
+    );
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "550e8400-e29b-41d4-a716-446655440002",
+        type: "FormulaField",
+        slug: "total",
+        label: "Total",
+        required: false,
+      }),
+    );
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await program.parseAsync([
+      "node",
+      "zinkee",
+      "--json",
+      "schemas",
+      "fields",
+      "update",
+      "contacts",
+      "550E8400-E29B-41D4-A716-446655440002",
+      "--raw",
+      '{"status":"draft","config":{"formulaText":"{price} * {quantity}","status":"active","uiFormatKind":"number"}}',
+    ]);
+
+    expect(JSON.parse(String(fetchMock.mock.calls[2]?.[1]?.body))).toEqual({
+      type: "FormulaField",
+      config: {
+        formulaText: "{price} * {quantity}",
+        uiFormatKind: "number",
+      },
+    });
+  });
+
+  it("creates fields from a complete raw payload without duplicating required flags", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    mockSchemaLookup(fetchMock);
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "field-2",
+        type: "TextField",
+        slug: "phone",
+        label: "Phone",
+        required: true,
+      }),
+    );
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await program.parseAsync([
+      "node",
+      "zinkee",
+      "--json",
+      "schemas",
+      "fields",
+      "create",
+      "contacts",
+      "--raw",
+      '{"type":"text","slug":"phone","label":"Phone","required":true}',
+    ]);
+
+    expect(fetchMock.mock.calls[1]?.[0]).toBe(
+      "https://api.zinkee.test/api/v2/schemas/schema-1/fields",
+    );
+    expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body))).toEqual({
+      type: "TextField",
+      slug: "phone",
+      label: "Phone",
+      required: true,
+    });
+  });
+
+  it("strips formula status from create payloads", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    mockSchemaLookup(fetchMock);
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "field-formula-1",
+        type: "FormulaField",
+        slug: "total",
+        label: "Total",
+      }),
+    );
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await program.parseAsync([
+      "node",
+      "zinkee",
+      "--json",
+      "schemas",
+      "fields",
+      "create",
+      "contacts",
+      "--raw",
+      '{"type":"formula","slug":"total","label":"Total","status":"draft","config":{"formulaText":"{price} * {quantity}","status":"active","uiFormatKind":"number"}}',
+    ]);
+
+    expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body))).toEqual({
+      type: "FormulaField",
+      slug: "total",
+      label: "Total",
+      config: {
+        formulaText: "{price} * {quantity}",
+        uiFormatKind: "number",
+      },
+    });
+  });
+
+  it("normalizes autoincremental field aliases to AutoIncrementalField", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    mockSchemaLookup(fetchMock);
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "field-3",
+        type: "AutoIncrementalField",
+        slug: "counter",
+        label: "Counter",
+      }),
+    );
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await program.parseAsync([
+      "node",
+      "zinkee",
+      "--json",
+      "schemas",
+      "fields",
+      "create",
+      "contacts",
+      "--type",
+      "autoincremental",
+      "--slug",
+      "counter",
+      "--label",
+      "Counter",
+    ]);
+
+    expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body))).toEqual({
+      type: "AutoIncrementalField",
+      slug: "counter",
+      label: "Counter",
+    });
+  });
+
+  it("normalizes member field aliases to MemberField", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    mockSchemaLookup(fetchMock);
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "field-member-1",
+        type: "MemberField",
+        slug: "owner",
+        label: "Owner",
+      }),
+    );
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await program.parseAsync([
+      "node",
+      "zinkee",
+      "--json",
+      "schemas",
+      "fields",
+      "create",
+      "contacts",
+      "--type",
+      "member",
+      "--slug",
+      "owner",
+      "--label",
+      "Owner",
+    ]);
+
+    expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body))).toEqual({
+      type: "MemberField",
+      slug: "owner",
+      label: "Owner",
+    });
+  });
+
+  it("normalizes option field shorthand payloads into the backend shape", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    mockSchemaLookup(fetchMock);
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "field-4",
+        type: "OptionField",
+        slug: "status",
+        label: "Status",
+      }),
+    );
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await program.parseAsync([
+      "node",
+      "zinkee",
+      "--json",
+      "schemas",
+      "fields",
+      "create",
+      "contacts",
+      "--raw",
+      '{"type":"option","slug":"status","label":"Status","options":[{"id":1,"label":"Open"},{"id":2,"label":"Closed","color":"success"}]}',
+    ]);
+
+    expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body))).toEqual({
+      type: "OptionField",
+      slug: "status",
+      label: "Status",
+      config: {
+        options: [
+          {
+            id: 1,
+            name: "Open",
+            color: "default",
+          },
+          {
+            id: 2,
+            name: "Closed",
+            color: "success",
+          },
+        ],
+      },
+    });
+  });
+
+  it("rejects unsupported field types before making network requests", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await expect(
+      program.parseAsync([
+        "node",
+        "zinkee",
+        "schemas",
+        "fields",
+        "create",
+        "contacts",
+        "--type",
+        "invalid",
+        "--slug",
+        "bad",
+        "--label",
+        "Bad",
+      ]),
+    ).rejects.toThrowError(
+      'Unsupported field type "InvalidField". Valid types: text, number, date, option, file, reference, formula, member, autoincremental.',
+    );
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("shows valid types and raw shapes in schemas fields create help", () => {
+    const program = buildProgram();
+    const schemas = program.commands.find((command) => command.name() === "schemas");
+    const fields = schemas?.commands.find((command) => command.name() === "fields");
+    const create = fields?.commands.find((command) => command.name() === "create");
+    const help = create?.helpInformation() ?? "";
+
+    expect(help).toContain("--type <type>");
+    expect(help).toContain("member");
+    expect(help).toContain("autoincremental");
+    expect(help).toContain("Raw payload shapes by type:");
+    expect(help).toContain('"type":"number","slug":"price-eur"');
+    expect(help).toContain('"defaultValue":"0"');
+    expect(help).toContain('"symbolEnabled":true');
+    expect(help).toContain('- member: Workspace member field.');
+    expect(help).toContain('"type":"member","slug":"owner","label":"Owner"');
+    expect(help).toContain('- option: Dropdown/select field with options.');
+    expect(help).toContain('"type":"option","slug":"status","label":"Status"');
+    expect(help).toContain('Use "zinkee --example schemas fields create --type <type>"');
+  });
+
+  it("surfaces a descriptive option payload error before hitting the backend", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await expect(
+      program.parseAsync([
+        "node",
+        "zinkee",
+        "schemas",
+        "fields",
+        "create",
+        "contacts",
+        "--raw",
+        '{"type":"option","slug":"status","label":"Status","options":[1,2]}',
+      ]),
+    ).rejects.toThrowError(
+      'Option fields require an "options" array with at least one entry like {"id":1,"name":"Open","color":"default"}.',
+    );
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("enriches generic backend validation errors with the expected raw shape", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    mockSchemaLookup(fetchMock);
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse(
+        {
+          error: {
+            message: "Schema payload is invalid. One or more fields are invalid.",
+          },
+        },
+        400,
+      ),
+    );
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await expect(
+      program.parseAsync([
+        "node",
+        "zinkee",
+        "schemas",
+        "fields",
+        "create",
+        "contacts",
+        "--raw",
+        '{"type":"option","slug":"status","label":"Status","options":[{"id":1,"name":"Open","color":"default"}]}',
+      ]),
+    ).rejects.toThrowError(
+      'Invalid payload for field type "option". Expected raw shape: {"type":"option","slug":"status","label":"Status","config":{"options":[{"id":1,"name":"Open","color":"default"},{"id":2,"name":"Closed","color":"success"}]}}',
+    );
+  });
+
+  it("deletes fields by slug after resolving the field id", async () => {
+    const configPath = createApiConfig();
+    const output = createStdoutBuffer();
+    const fetchMock = createFetchMock();
+    mockSchemaLookup(fetchMock);
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        id: "schema-1",
+        slug: "contacts",
+        fields: [
+          {
+            id: "550e8400-e29b-41d4-a716-446655440001",
+            slug: "email",
+            type: "TextField",
+            label: "Email",
+          },
+        ],
+      }),
+    );
+    fetchMock.mockResolvedValueOnce(jsonResponse({ deleted: true }));
+    const program = buildProgram({ configPath, stdout: output.stdout });
+
+    await program.parseAsync([
+      "node",
+      "zinkee",
+      "--json",
+      "schemas",
+      "fields",
+      "delete",
+      "contacts",
+      "email",
+    ]);
+
+    expect(fetchMock.mock.calls[2]?.[0]).toBe(
+      "https://api.zinkee.test/api/v2/schemas/schema-1/fields/550e8400-e29b-41d4-a716-446655440001",
+    );
+    expect(fetchMock.mock.calls[2]?.[1]?.method).toBe("DELETE");
+    expect(JSON.parse(output.read())).toEqual({
+      data: {
+        schema: "schema-1",
+        field: "550e8400-e29b-41d4-a716-446655440001",
+        deleted: true,
+      },
+      meta: {
+        command: "schemas fields delete",
+        configPath,
+      },
+    });
+  });
+});