zinkee 0.1.44 → 0.1.45

package/src/commands/displays.test.ts

@@ -1,1105 +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-displays-"));
-  const filePath = join(dir, "config.toml");
-  writeFileSync(filePath, contents, "utf8");
-  return filePath;
-}
-
-function createApiConfig(): string {
-  return createTempConfig(`
-default_profile = "prod"
-
-[profiles.prod]
-api_key = "displays-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;
-}
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.restoreAllMocks();
-});
-
-describe("displays commands", () => {
-  it("registers the displays command group", () => {
-    const program = buildProgram();
-    expect(program.commands.some((command) => command.name() === "displays")).toBe(true);
-  });
-
-  it("creates displays with the expected payload", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "create",
-      "--name",
-      "Pipeline",
-      "--template",
-      "widget_row_tabs",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://api.zinkee.test/api/v2/displays");
-    expect(init?.method).toBe("POST");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      name: "Pipeline",
-      layout: { template: "widget_row_tabs" },
-    });
-    expect(JSON.parse(output.read())).toEqual({
-      data: { displayId: "display-1" },
-      meta: { command: "displays create" },
-    });
-  });
-
-  it("creates displays with a description", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "create",
-      "--name",
-      "Pipeline",
-      "--description",
-      "Sales pipeline overview",
-      "--template",
-      "widget_row_tabs",
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      name: "Pipeline",
-      description: "Sales pipeline overview",
-      layout: { template: "widget_row_tabs" },
-    });
-  });
-
-  it.each([
-    ["sets", "Sales pipeline overview"],
-    ["clears", ""],
-  ])("%s a display description without renaming it", async (_action, description) => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "update",
-      "display-1",
-      "--description",
-      description,
-    ]);
-
-    expect(fetchMock.mock.calls[0]?.[1]?.method).toBe("PATCH");
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({ description });
-  });
-
-  it.each(["", "   "])("rejects an empty display name", async (name) => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--json",
-        "displays",
-        "update",
-        "display-1",
-        "--name",
-        name,
-      ]),
-    ).rejects.toThrow("Display name cannot be empty.");
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("creates freeform displays with nested freeform layouts", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-2" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "create",
-      "--name",
-      "Control Proyecto Freeform",
-      "--template",
-      "freeform",
-      "--freeform-layouts",
-      '{"lg":[{"i":"widget-1","x":0,"y":0,"w":6,"h":5}]}',
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body))).toEqual({
-      name: "Control Proyecto Freeform",
-      layout: {
-        template: "freeform",
-        freeformLayouts: {
-          lg: [{ i: "widget-1", x: 0, y: 0, w: 6, h: 5 }],
-        },
-      },
-    });
-    expect(JSON.parse(output.read())).toEqual({
-      data: { displayId: "display-2" },
-      meta: { command: "displays create" },
-    });
-  });
-
-  it("creates widgets through the generic --type path", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1", widgetId: "widget-1" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "chart",
-      "--name",
-      "Revenue",
-      "--chart-type",
-      "bars",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://api.zinkee.test/api/v2/displays/display-1/widgets");
-    expect(JSON.parse(String(init?.body))).toMatchObject({
-      type: "CHART",
-      presentation: { name: "Revenue" },
-      chart: { chartType: "bars" },
-    });
-    expect(JSON.parse(output.read())).toEqual({
-      data: { displayId: "display-1", widgetId: "widget-1" },
-      meta: { command: "displays widgets create" },
-    });
-  });
-
-  it("keeps the widget description flag in presentation and sends an empty clear value", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1", widgetId: "widget-1" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "update",
-      "display-1",
-      "widget-1",
-      "--description",
-      "",
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      presentation: { description: "" },
-    });
-  });
-
-  it("deep merges chart flags with chart data from --raw", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1", widgetId: "widget-2" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "chart",
-      "--name",
-      "Horas",
-      "--origin-resource",
-      "schema-1",
-      "--chart-type",
-      "bars",
-      "--x-axis-field",
-      "rh-empleado",
-      "--raw",
-      '{"chart":{"yAxisSeries":[{"typeCalc":"SUM","fieldCalc":"rh-horas","axisType":"PRIMARY"}],"legend":{"position":"bottom"}}}',
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body))).toMatchObject({
-      type: "CHART",
-      presentation: { name: "Horas" },
-      source: { originResourceId: "schema-1" },
-      chart: {
-        chartType: "bars",
-        xAxisFieldId: "rh-empleado",
-        yAxisSeries: [{ typeCalc: "SUM", fieldCalc: "rh-horas", axisType: "PRIMARY" }],
-        legend: { position: "bottom" },
-      },
-    });
-    expect(JSON.parse(output.read())).toEqual({
-      data: { displayId: "display-1", widgetId: "widget-2" },
-      meta: { command: "displays widgets create" },
-    });
-  });
-
-  it("preserves raw chart properties when --y-axis-serie is used", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1", widgetId: "widget-3" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "chart",
-      "--raw",
-      '{"chart":{"chartType":"bars","xAxisFieldId":"rh-empleado"}}',
-      "--y-axis-serie",
-      '{"typeCalc":"SUM","fieldCalc":"rh-horas","axisType":"PRIMARY"}',
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body))).toMatchObject({
-      type: "CHART",
-      chart: {
-        chartType: "bars",
-        xAxisFieldId: "rh-empleado",
-        yAxisSeries: [{ typeCalc: "SUM", fieldCalc: "rh-horas", axisType: "PRIMARY" }],
-      },
-    });
-    expect(JSON.parse(output.read())).toEqual({
-      data: { displayId: "display-1", widgetId: "widget-3" },
-      meta: { command: "displays widgets create" },
-    });
-  });
-
-  it("builds KANBAN viewState fieldMapping, cardConfig and aggregation from flags", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1", widgetId: "widget-k1" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "kanban",
-      "--field",
-      "name-uuid",
-      "--column-field",
-      "status-uuid",
-      "--swimlane-field",
-      "owner-uuid",
-      "--card-title-field",
-      "name-uuid",
-      "--card-category3-field",
-      "amount-uuid",
-      "--aggregation-method",
-      "sum",
-      "--aggregation-field",
-      "amount-uuid",
-      "--view-state",
-      '{"showNoValueColumn":true,"hideEmptyColumns":false}',
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body))).toMatchObject({
-      type: "KANBAN",
-      view: {
-        fields: ["name-uuid"],
-        viewAdditionalProperties: {
-          viewState: {
-            showNoValueColumn: true,
-            hideEmptyColumns: false,
-            fieldMapping: {
-              columnField: "status-uuid",
-              swimlaneField: "owner-uuid",
-              cardConfig: { titleField: "name-uuid", category3Field: "amount-uuid" },
-              aggregationConfig: { method: "sum", fieldId: "amount-uuid" },
-            },
-          },
-        },
-      },
-    });
-  });
-
-  it("builds TIMELINE viewState fieldMapping with category4 from flags", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1", widgetId: "widget-t1" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "timeline",
-      "--start-date-field",
-      "start-uuid",
-      "--end-date-field",
-      "end-uuid",
-      "--label-field",
-      "name-uuid",
-      "--card-category4-field",
-      "amount-uuid",
-      "--view-state",
-      '{"granularity":"month","sidebarWidth":300}',
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body))).toMatchObject({
-      type: "TIMELINE",
-      view: {
-        viewAdditionalProperties: {
-          viewState: {
-            granularity: "month",
-            sidebarWidth: 300,
-            fieldMapping: {
-              startDateField: "start-uuid",
-              endDateField: "end-uuid",
-              labelField: "name-uuid",
-              cardConfig: { category4Field: "amount-uuid" },
-            },
-          },
-        },
-      },
-    });
-  });
-
-  it("builds HIERARCHY hierarchyConfig from columns, root and child flags", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1", widgetId: "widget-h1" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "hierarchy",
-      "--hierarchy-label",
-      "Name",
-      "--hierarchy-info",
-      "col-info-status:Status",
-      "--hierarchy-number",
-      "col-num-amount:Total amount:sum",
-      "--hierarchy-root-name",
-      "Customers",
-      "--hierarchy-root-label-field",
-      "name-uuid",
-      "--hierarchy-root-info",
-      "col-info-status:status-uuid",
-      "--hierarchy-root-number",
-      "col-num-amount:amount-uuid",
-      "--hierarchy-child",
-      '{"name":"Projects","schemaId":"projects-uuid","childFieldId":"child-uuid","labelFieldId":"project-name-uuid","infoMappings":[],"numberMappings":[{"columnId":"col-num-amount","fieldId":"project-amount-uuid"}]}',
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body))).toMatchObject({
-      type: "HIERARCHY",
-      view: {
-        hierarchyConfig: {
-          columns: {
-            label: "Name",
-            infos: [{ id: "col-info-status", name: "Status" }],
-            numbers: [{ id: "col-num-amount", name: "Total amount", aggregation: "SUM" }],
-          },
-          rootLevel: {
-            name: "Customers",
-            labelFieldId: "name-uuid",
-            infoMappings: [{ columnId: "col-info-status", fieldId: "status-uuid" }],
-            numberMappings: [{ columnId: "col-num-amount", fieldId: "amount-uuid" }],
-          },
-          childLevels: [
-            {
-              name: "Projects",
-              schemaId: "projects-uuid",
-              childFieldId: "child-uuid",
-              labelFieldId: "project-name-uuid",
-              infoMappings: [],
-              numberMappings: [{ columnId: "col-num-amount", fieldId: "project-amount-uuid" }],
-            },
-          ],
-        },
-      },
-    });
-  });
-
-  it("deep merges KANBAN flags over view state coming from --raw", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1", widgetId: "widget-k2" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "kanban",
-      "--raw",
-      '{"view":{"viewAdditionalProperties":{"viewState":{"columnOrder":["a","b"],"fieldMapping":{"columnField":"old-uuid","cardConfig":{"titleField":"name-uuid"}}}}}}',
-      "--column-field",
-      "status-uuid",
-      "--card-category1-field",
-      "status-uuid",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body))).toMatchObject({
-      type: "KANBAN",
-      view: {
-        viewAdditionalProperties: {
-          viewState: {
-            columnOrder: ["a", "b"],
-            fieldMapping: {
-              columnField: "status-uuid",
-              cardConfig: { titleField: "name-uuid", category1Field: "status-uuid" },
-            },
-          },
-        },
-      },
-    });
-  });
-
-  it("rejects --hierarchy-number with an invalid aggregation", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--json",
-        "displays",
-        "widgets",
-        "create",
-        "display-1",
-        "--type",
-        "hierarchy",
-        "--hierarchy-number",
-        "col-num-amount:Total:BOGUS",
-      ]),
-    ).rejects.toThrow(/aggregation/i);
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("translates --lock-* flags into behavior.lockedFields", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1", widgetId: "widget-l1" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "table",
-      "--origin-resource",
-      "schema-1",
-      "--lock-field",
-      "contact-name",
-      "--lock-condition",
-      "status:invoice-number:is_empty",
-      "--lock-condition",
-      "status:amount:gte:500",
-      "--lock-message-before",
-      "status:Status locks until the invoice number is set.",
-      "--lock-message-after",
-      "status:Status is locked because the invoice number is missing.",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body))).toMatchObject({
-      type: "TABLE_OR_SUBTABLE",
-      behavior: {
-        lockedFields: [
-          {
-            field: { fieldId: "contact-name" },
-            conditions: [],
-          },
-          {
-            field: { fieldId: "status" },
-            conditions: [
-              {
-                origin: { fieldId: "invoice-number" },
-                comparisonOperator: "IS_EMPTY",
-                values: [],
-              },
-              {
-                origin: { fieldId: "amount" },
-                comparisonOperator: "GREATER_OR_EQUAL",
-                values: ["500"],
-              },
-            ],
-            messageBeforeLock: "Status locks until the invoice number is set.",
-            messageAfterLock: "Status is locked because the invoice number is missing.",
-          },
-        ],
-      },
-    });
-  });
-
-  it("clears locked fields with --clear-locked-fields", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1", widgetId: "widget-l2" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "update",
-      "display-1",
-      "widget-l2",
-      "--clear-locked-fields",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(init?.method).toBe("PATCH");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      behavior: { lockedFields: [] },
-    });
-  });
-
-  it("rejects --clear-locked-fields combined with --lock-* flags", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--json",
-        "displays",
-        "widgets",
-        "update",
-        "display-1",
-        "widget-l3",
-        "--clear-locked-fields",
-        "--lock-field",
-        "status",
-      ]),
-    ).rejects.toThrow(/not both/i);
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("rejects a --lock-condition without an expression", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const errorSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    // Option arg parser errors are handled by commander, which prints the
-    // InvalidArgumentError message to stderr and exits with code 1 (same
-    // behavior as an invalid --filter expression).
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--json",
-        "displays",
-        "widgets",
-        "create",
-        "display-1",
-        "--type",
-        "table",
-        "--lock-condition",
-        "status",
-      ]),
-    ).rejects.toThrow(/process.exit/);
-    expect(errorSpy.mock.calls.flat().join("\n")).toMatch(/lockedField/i);
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("translates --filter into the structured display filter contract", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1", widgetId: "widget-f1" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "table",
-      "--origin-resource",
-      "schema-1",
-      "--filter",
-      "edad:gt:30",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body))).toMatchObject({
-      type: "TABLE_OR_SUBTABLE",
-      query: {
-        filters: [
-          {
-            origin: { fieldId: "edad" },
-            comparisonOperator: "GREATER",
-            values: ["30"],
-          },
-        ],
-      },
-    });
-  });
-
-  it("maps the `in` comparator to ANY_OF with a list of values", async () => {
-    const configPath = createApiConfig();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ widgetId: "widget-f2" }));
-    const program = buildProgram({ configPath });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "table",
-      "--filter",
-      "status:in:1,2,3",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body)).query.filters).toEqual([
-      {
-        origin: { fieldId: "status" },
-        comparisonOperator: "ANY_OF",
-        values: ["1", "2", "3"],
-      },
-    ]);
-  });
-
-  it("maps the `is_not_empty` comparator with empty values array", async () => {
-    const configPath = createApiConfig();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ widgetId: "widget-f3" }));
-    const program = buildProgram({ configPath });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "table",
-      "--filter",
-      "email:is_not_empty",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body)).query.filters).toEqual([
-      {
-        origin: { fieldId: "email" },
-        comparisonOperator: "IS_NOT_EMPTY",
-        values: [],
-      },
-    ]);
-  });
-
-  it("accumulates multiple --filter flags in order", async () => {
-    const configPath = createApiConfig();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ widgetId: "widget-f4" }));
-    const program = buildProgram({ configPath });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "table",
-      "--filter",
-      "status:eq:2",
-      "--filter",
-      "amount:gte:500",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body)).query.filters).toEqual([
-      { origin: { fieldId: "status" }, comparisonOperator: "EQUAL", values: ["2"] },
-      { origin: { fieldId: "amount" }, comparisonOperator: "GREATER_OR_EQUAL", values: ["500"] },
-    ]);
-  });
-
-  it("rejects --filter with an unsupported comparator before issuing a request", async () => {
-    const configPath = createApiConfig();
-    const fetchMock = createFetchMock();
-    const program = buildProgram({ configPath });
-    const stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--json",
-        "displays",
-        "widgets",
-        "create",
-        "display-1",
-        "--type",
-        "table",
-        "--filter",
-        "edad:invalido:30",
-      ]),
-    ).rejects.toThrow();
-
-    expect(fetchMock).not.toHaveBeenCalled();
-    expect(stderrSpy.mock.calls.map(([chunk]) => String(chunk)).join("")).toMatch(/Unsupported comparator/);
-    stderrSpy.mockRestore();
-  });
-
-  it("preserves --raw query.filters when only --field is passed (no --filter)", async () => {
-    const configPath = createApiConfig();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ widgetId: "widget-f6" }));
-    const program = buildProgram({ configPath });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "widgets",
-      "create",
-      "display-1",
-      "--type",
-      "table",
-      "--field",
-      "foo",
-      "--raw",
-      '{"query":{"filters":[{"origin":{"fieldId":"status"},"comparisonOperator":"EQUAL","values":["2"]}]}}',
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body))).toMatchObject({
-      view: { fields: ["foo"] },
-      query: {
-        filters: [
-          { origin: { fieldId: "status" }, comparisonOperator: "EQUAL", values: ["2"] },
-        ],
-      },
-    });
-  });
-
-  it("translates --filter for variable mutations into the structured filter contract", async () => {
-    const configPath = createApiConfig();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ variableId: "var-1" }));
-    const program = buildProgram({ configPath });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "variables",
-      "create",
-      "display-1",
-      "--type",
-      "reference",
-      "--name",
-      "Activos",
-      "--filter",
-      "estado:eq:activo",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(JSON.parse(String(init?.body))).toMatchObject({
-      type: "reference",
-      name: "Activos",
-      filters: [
-        {
-          origin: { fieldId: "estado" },
-          comparisonOperator: "EQUAL",
-          values: ["activo"],
-        },
-      ],
-    });
-  });
-
-  it("blocks destructive display commands in read-only mode", async () => {
-    const configPath = createApiConfig();
-    const fetchMock = createFetchMock();
-    const program = buildProgram({ configPath });
-
-    await expect(
-      program.parseAsync(["node", "zinkee", "--read-only", "displays", "delete", "display-1"]),
-    ).rejects.toThrowError('Command "displays delete" is not allowed in read-only mode.');
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("creates a display folder with just a name", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({ id: "folder-1", name: "Executive Dashboards", isRoot: false, displayCount: 0 }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "folders",
-      "create",
-      "--name",
-      "Executive Dashboards",
-    ]);
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://api.zinkee.test/api/v2/display-folders");
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(init?.method).toBe("POST");
-    expect(JSON.parse(String(init?.body))).toEqual({ name: "Executive Dashboards" });
-  });
-
-  it("moves a display into a folder resolved by name", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse([{ id: "folder-1", name: "Executive Dashboards", isRoot: false, displayCount: 2 }]),
-    );
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({ id: "folder-1", name: "Executive Dashboards", isRoot: false }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "folders",
-      "move",
-      "0f6f062f-1478-4df2-96a1-c495d037d260",
-      "--to",
-      "Executive Dashboards",
-    ]);
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://api.zinkee.test/api/v2/display-folders");
-    expect(fetchMock.mock.calls[1]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/display-folders/displays:move",
-    );
-    const moveInit = fetchMock.mock.calls[1]?.[1];
-    expect(moveInit?.method).toBe("POST");
-    expect(JSON.parse(String(moveInit?.body))).toEqual({
-      displayId: "0f6f062f-1478-4df2-96a1-c495d037d260",
-      targetFolderId: "folder-1",
-    });
-  });
-
-  it("blocks destructive display folder commands in read-only mode", async () => {
-    const configPath = createApiConfig();
-    const fetchMock = createFetchMock();
-    const program = buildProgram({ configPath });
-
-    await expect(
-      program.parseAsync(["node", "zinkee", "--read-only", "displays", "folders", "delete", "folder-1"]),
-    ).rejects.toThrowError('Command "displays folders delete" is not allowed in read-only mode.');
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("wraps a flag-built cross widget filter configuration in an array", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "cross-widget-filter",
-      "set",
-      "display-1",
-      "--source-widget",
-      "w-source",
-      "--source-field",
-      "f-source",
-      "--target",
-      "w-target:f-target",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(fetchMock.mock.calls[0]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/displays/display-1/cross-widget-filter",
-    );
-    expect(init?.method).toBe("PUT");
-    expect(JSON.parse(String(init?.body))).toEqual([
-      {
-        source: { widgetId: "w-source", fieldId: "f-source" },
-        targets: [{ widgetId: "w-target", fieldId: "f-target" }],
-      },
-    ]);
-  });
-
-  it("sends the raw array of cross widget filter configurations verbatim", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ displayId: "display-1" }));
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    const rawArray = [
-      { source: { widgetId: "w1", fieldId: "f1" }, targets: [{ widgetId: "t1", fieldId: "f1" }] },
-      { source: { widgetId: "w2", fieldId: "f2" }, targets: [{ widgetId: "t2", fieldId: "f2" }] },
-    ];
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "displays",
-      "cross-widget-filter",
-      "set",
-      "display-1",
-      "--raw",
-      JSON.stringify(rawArray),
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(init?.method).toBe("PUT");
-    expect(JSON.parse(String(init?.body))).toEqual(rawArray);
-  });
-});