zinkee 0.1.0

package/src/commands/config.ts

@@ -0,0 +1,150 @@
+import type { Writable } from "node:stream";
+
+import { Command } from "commander";
+
+import {
+  defaultConfigPath,
+  readConfig,
+  redactConfig,
+  resolveProfile,
+} from "../config.js";
+import { CliError } from "../utils/errors.js";
+import { buildJsonSuccess, printTable } from "../utils/output.js";
+
+interface CommandIo {
+  write(chunk: string): unknown;
+}
+
+export interface RegisterConfigCommandsOptions {
+  configPath?: string;
+  stdout?: CommandIo;
+}
+
+interface GlobalOptions {
+  json?: boolean;
+}
+
+function getCommandIo(stdout: CommandIo | undefined): CommandIo {
+  return stdout ?? (process.stdout as Writable);
+}
+
+function writeLine(stdout: CommandIo, value: string): void {
+  stdout.write(`${value}\n`);
+}
+
+function getGlobalOptions(command: Command): GlobalOptions {
+  return command.optsWithGlobals<GlobalOptions>();
+}
+
+function emitJson(
+  stdout: CommandIo,
+  commandName: string,
+  data: unknown,
+  configPath: string,
+): void {
+  writeLine(
+    stdout,
+    JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath })),
+  );
+}
+
+function toConfigurationError(filePath: string, error: unknown): never {
+  if (error instanceof CliError) {
+    throw error;
+  }
+
+  if (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    error.code === "ENOENT"
+  ) {
+    throw new CliError("configuration_error", `Config file not found at ${filePath}.`);
+  }
+
+  if (error instanceof Error) {
+    throw new CliError("configuration_error", error.message);
+  }
+
+  throw error;
+}
+
+export function registerConfigCommands(
+  program: Command,
+  options: RegisterConfigCommandsOptions = {},
+): void {
+  const filePath = options.configPath ?? defaultConfigPath;
+  const stdout = getCommandIo(options.stdout);
+  const config = program.command("config").description("Inspect local CLI config");
+
+  config
+    .command("path")
+    .description("Show the effective config file path")
+    .action(function action(this: Command) {
+      const data = { path: filePath };
+
+      if (getGlobalOptions(this).json) {
+        emitJson(stdout, "config path", data, filePath);
+        return;
+      }
+
+      writeLine(stdout, filePath);
+    });
+
+  config
+    .command("show")
+    .description("Show the local config with secrets redacted")
+    .action(function action(this: Command) {
+      try {
+        const data = redactConfig(readConfig(filePath));
+
+        if (getGlobalOptions(this).json) {
+          emitJson(stdout, "config show", data, filePath);
+          return;
+        }
+
+        writeLine(stdout, `Default profile: ${data.defaultProfile ?? "(none)"}`);
+        printTable(
+          Object.entries(data.profiles).map(([name, profile]) => ({
+            name,
+            default: data.defaultProfile === name ? "yes" : "",
+            baseUrl:
+              typeof profile.baseUrl === "string"
+                ? profile.baseUrl
+                : "",
+            apiKey:
+              typeof profile.apiKey === "string"
+                ? profile.apiKey
+                : "",
+          })),
+          ["name", "default", "baseUrl", "apiKey"],
+          stdout,
+        );
+      } catch (error) {
+        toConfigurationError(filePath, error);
+      }
+    });
+
+  config
+    .command("validate")
+    .description("Validate that the local config can resolve a profile")
+    .action(function action(this: Command) {
+      try {
+        const parsed = readConfig(filePath);
+        const profile = resolveProfile(parsed);
+        const data = {
+          valid: true,
+          profile: profile.name,
+        };
+
+        if (getGlobalOptions(this).json) {
+          emitJson(stdout, "config validate", data, filePath);
+          return;
+        }
+
+        writeLine(stdout, `Config is valid. Resolved profile "${profile.name}".`);
+      } catch (error) {
+        toConfigurationError(filePath, error);
+      }
+    });
+}

package/src/commands/displays.test.ts

@@ -0,0 +1,266 @@
+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 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",
+      "bar",
+    ]);
+
+    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: "bar" },
+    });
+    expect(JSON.parse(output.read())).toEqual({
+      data: { displayId: "display-1", widgetId: "widget-1" },
+      meta: { command: "displays widgets create" },
+    });
+  });
+
+  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("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();
+  });
+});