zinkee 0.1.43 → 0.1.45

package/src/commands/formulas.test.ts

@@ -1,194 +0,0 @@
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { Command } from "commander";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { registerFormulasCommands } from "./formulas.js";
-
-function createConfig(): string {
-  const dir = mkdtempSync(join(tmpdir(), "zinkee-formulas-"));
-  const filePath = join(dir, "config.toml");
-  writeFileSync(
-    filePath,
-    `default_profile = "test"\n\n[profiles.test]\napi_key = "token"\nbase_url = "https://api.zinkee.test"\n`,
-    "utf8",
-  );
-  return filePath;
-}
-
-function createStdoutBuffer() {
-  let output = "";
-  return {
-    stdout: {
-      write(chunk: string) {
-        output += chunk;
-        return true;
-      },
-    },
-    read: () => output,
-  };
-}
-
-function buildProgram(options: { configPath: string; stdout: { write(chunk: string): unknown } }): Command {
-  const program = new Command();
-  program
-    .name("zinkee")
-    .enablePositionalOptions()
-    .option("--read-only")
-    .option("--json");
-  registerFormulasCommands(program, options);
-  return program;
-}
-
-function queuedResponse(scope: "FIELD" | "SCHEMA" | "WORKSPACE", eventsQueued = 1): Response {
-  return new Response(
-    JSON.stringify({
-      requestId: "request-1",
-      scope,
-      formulaCount: eventsQueued,
-      skippedFormulaCount: 0,
-      eventsQueued,
-      status: "QUEUED",
-    }),
-    { status: 202, headers: { "content-type": "application/json" } },
-  );
-}
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.restoreAllMocks();
-});
-
-describe("formulas commands", () => {
-  it("registers the formulas command group", () => {
-    const output = createStdoutBuffer();
-    const program = buildProgram({ configPath: createConfig(), stdout: output.stdout });
-
-    expect(program.commands.some((command) => command.name() === "formulas")).toBe(true);
-  });
-
-  it("queues one field by slug and emits the JSON envelope", async () => {
-    const fetchMock = vi.fn<typeof fetch>().mockResolvedValue(queuedResponse("FIELD"));
-    vi.stubGlobal("fetch", fetchMock);
-    const configPath = createConfig();
-    const output = createStdoutBuffer();
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "formulas",
-      "recompute",
-      "field",
-      "invoices",
-      "total",
-    ]);
-
-    const [, init] = fetchMock.mock.calls[0]!;
-    expect(JSON.parse(String(init?.body))).toEqual({
-      scope: "FIELD",
-      schema: "invoices",
-      field: "total",
-    });
-    expect(JSON.parse(output.read())).toEqual({
-      data: {
-        requestId: "request-1",
-        scope: "FIELD",
-        formulaCount: 1,
-        skippedFormulaCount: 0,
-        eventsQueued: 1,
-        status: "QUEUED",
-      },
-      meta: { command: "formulas recompute field", configPath },
-    });
-  });
-
-  it.each([
-    ["schema", ["invoices"]],
-    ["workspace", []],
-  ])("requires --yes before the %s request", async (scope, args) => {
-    const fetchMock = vi.fn<typeof fetch>();
-    vi.stubGlobal("fetch", fetchMock);
-    const output = createStdoutBuffer();
-    const program = buildProgram({ configPath: createConfig(), stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "formulas",
-        "recompute",
-        scope,
-        ...args,
-      ]),
-    ).rejects.toThrow("requires --yes");
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("queues every schema formula after confirmation", async () => {
-    const fetchMock = vi.fn<typeof fetch>().mockResolvedValue(queuedResponse("SCHEMA", 3));
-    vi.stubGlobal("fetch", fetchMock);
-    const output = createStdoutBuffer();
-    const program = buildProgram({ configPath: createConfig(), stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "formulas",
-      "recompute",
-      "schema",
-      "invoices",
-      "--yes",
-    ]);
-
-    expect(output.read()).toContain("Queued 3 formula recalculation event(s)");
-    expect(output.read()).not.toContain("completed");
-  });
-
-  it("queues the workspace payload after confirmation", async () => {
-    const fetchMock = vi.fn<typeof fetch>().mockResolvedValue(queuedResponse("WORKSPACE", 5));
-    vi.stubGlobal("fetch", fetchMock);
-    const output = createStdoutBuffer();
-    const program = buildProgram({ configPath: createConfig(), stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "formulas",
-      "recompute",
-      "workspace",
-      "--yes",
-    ]);
-
-    const [, init] = fetchMock.mock.calls[0]!;
-    expect(JSON.parse(String(init?.body))).toEqual({ scope: "WORKSPACE" });
-  });
-
-  it.each([
-    ["field", ["invoices", "total"]],
-    ["schema", ["invoices", "--yes"]],
-    ["workspace", ["--yes"]],
-  ])("blocks %s in read-only mode before any network request", async (scope, args) => {
-    const fetchMock = vi.fn<typeof fetch>();
-    vi.stubGlobal("fetch", fetchMock);
-    const output = createStdoutBuffer();
-    const program = buildProgram({ configPath: createConfig(), stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--read-only",
-        "formulas",
-        "recompute",
-        scope,
-        ...args,
-      ]),
-    ).rejects.toThrow("not allowed in read-only mode");
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-});

package/src/commands/formulas.ts

@@ -1,243 +0,0 @@
-import type { Writable } from "node:stream";
-
-import { Command, InvalidArgumentError } from "commander";
-
-import {
-  FormulasApi,
-  type FormulaRecomputeInput,
-  type FormulaRecomputeResponse,
-} from "../api/formulas.js";
-import { ApiClient } from "../client.js";
-import { defaultConfigPath, readRuntimeConfig } from "../config.js";
-import {
-  normalizeUuidOrSlug,
-  type NormalizedUuidOrSlug,
-} from "../parsers/selectors.js";
-import { resolveRuntimeContext } from "../runtime-context.js";
-import type { RuntimeOverrides } from "../types.js";
-import { CliError } from "../utils/errors.js";
-import { buildJsonSuccess } from "../utils/output.js";
-
-interface CommandIo {
-  write(chunk: string): unknown;
-}
-
-export interface RegisterFormulasCommandsOptions {
-  configPath?: string;
-  stdout?: CommandIo;
-}
-
-interface GlobalOptions extends RuntimeOverrides {}
-
-interface ConfirmedCommandOptions {
-  yes?: 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 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;
-}
-
-function createFormulasApi(
-  command: Command,
-  filePath: string,
-): { api: FormulasApi; json: boolean; readOnly: boolean } {
-  try {
-    const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions(command));
-
-    if (!runtime.baseUrl) {
-      throw new CliError(
-        "configuration_error",
-        `Resolved profile "${runtime.profile}" is missing a base URL.`,
-      );
-    }
-
-    return {
-      api: new FormulasApi(
-        new ApiClient({
-          baseUrl: runtime.baseUrl,
-          apiKey: runtime.apiKey,
-        }),
-      ),
-      json: runtime.json,
-      readOnly: runtime.readOnly,
-    };
-  } catch (error) {
-    toConfigurationError(filePath, error);
-  }
-}
-
-function ensureWritable(commandName: string, readOnly: boolean): void {
-  if (readOnly) {
-    throw new CliError(
-      "command_not_allowed_in_read_only_mode",
-      `Command "${commandName}" is not allowed in read-only mode.`,
-      {
-        commandMode: "write",
-        executionMode: "read-only",
-      },
-    );
-  }
-}
-
-function ensureConfirmed(commandName: string, confirmed: boolean | undefined): void {
-  if (!confirmed) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Command "${commandName}" requires --yes because it may enqueue a large recalculation.`,
-    );
-  }
-}
-
-function parseUuidOrSlugSelector(input: string): NormalizedUuidOrSlug {
-  try {
-    return normalizeUuidOrSlug(input);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError(message);
-  }
-}
-
-function emitResult(
-  stdout: CommandIo,
-  commandName: string,
-  result: FormulaRecomputeResponse,
-  configPath: string,
-  json: boolean,
-): void {
-  if (json) {
-    writeLine(
-      stdout,
-      JSON.stringify(buildJsonSuccess(result, { command: commandName, configPath })),
-    );
-    return;
-  }
-
-  writeLine(
-    stdout,
-    `Queued ${result.eventsQueued} formula recalculation event(s) for ${result.scope.toLowerCase()} scope (request ${result.requestId}).`,
-  );
-}
-
-async function recompute(
-  command: Command,
-  commandName: string,
-  input: FormulaRecomputeInput,
-  options: RegisterFormulasCommandsOptions,
-  requireConfirmation: boolean,
-  confirmed?: boolean,
-): Promise<void> {
-  const configPath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo(options.stdout);
-  const { api, json, readOnly } = createFormulasApi(command, configPath);
-
-  ensureWritable(commandName, readOnly);
-  if (requireConfirmation) {
-    ensureConfirmed(commandName, confirmed);
-  }
-
-  const result = await api.recompute(input);
-  emitResult(stdout, commandName, result, configPath, json);
-}
-
-export function registerFormulasCommands(
-  program: Command,
-  options: RegisterFormulasCommandsOptions = {},
-): void {
-  const formulas = program
-    .command("formulas")
-    .description("Recalculate formula values");
-  const recomputeCommand = formulas
-    .command("recompute")
-    .description("Queue a full formula recalculation");
-
-  recomputeCommand
-    .command("field")
-    .description("Queue recalculation of one formula column")
-    .argument("<schema>", "schema UUID or slug", parseUuidOrSlugSelector)
-    .argument("<field>", "formula field UUID or slug", parseUuidOrSlugSelector)
-    .action(
-      async function action(
-        this: Command,
-        schema: NormalizedUuidOrSlug,
-        field: NormalizedUuidOrSlug,
-      ) {
-        await recompute(
-          this,
-          "formulas recompute field",
-          { scope: "FIELD", schema, field },
-          options,
-          false,
-        );
-      },
-    );
-
-  recomputeCommand
-    .command("schema")
-    .description("Queue recalculation of all active formulas in one schema")
-    .argument("<schema>", "schema UUID or slug", parseUuidOrSlugSelector)
-    .option("--yes", "confirm the potentially expensive recalculation")
-    .action(
-      async function action(
-        this: Command,
-        schema: NormalizedUuidOrSlug,
-        commandOptions: ConfirmedCommandOptions,
-      ) {
-        await recompute(
-          this,
-          "formulas recompute schema",
-          { scope: "SCHEMA", schema },
-          options,
-          true,
-          commandOptions.yes,
-        );
-      },
-    );
-
-  recomputeCommand
-    .command("workspace")
-    .description("Queue recalculation of all active formulas in the workspace")
-    .option("--yes", "confirm the potentially expensive recalculation")
-    .action(async function action(
-      this: Command,
-      commandOptions: ConfirmedCommandOptions,
-    ) {
-      await recompute(
-        this,
-        "formulas recompute workspace",
-        { scope: "WORKSPACE" },
-        options,
-        true,
-        commandOptions.yes,
-      );
-    });
-}

package/src/commands/logs.test.ts

@@ -1,123 +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-logs-"));
-  const filePath = join(dir, "config.toml");
-  writeFileSync(filePath, contents, "utf8");
-  return filePath;
-}
-
-function createApiConfig(): string {
-  return createTempConfig(`
-default_profile = "prod"
-
-[profiles.prod]
-api_key = "logs-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("logs commands", () => {
-  it("registers the logs command group", () => {
-    const program = buildProgram();
-
-    expect(program.commands.some((command) => command.name() === "logs")).toBe(true);
-  });
-
-  it("lists logs for a record and lowercases the record uuid in the path", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse([
-        {
-          recordId: "550e8400-e29b-41d4-a716-446655440001",
-          timestamp: "2026-04-22T10:00:00Z",
-          changeField: "",
-          change: {
-            beforeValue: null,
-            afterValue: null,
-            author: "developer@zinkee.com",
-            operation: "CREATE",
-          },
-        },
-      ]),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "logs",
-      "list",
-      "contacts",
-      "550E8400-E29B-41D4-A716-446655440001",
-    ]);
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/schemas/contacts/records/550e8400-e29b-41d4-a716-446655440001/logs",
-    );
-    expect(fetchMock.mock.calls[0]?.[1]?.method ?? "GET").toBe("GET");
-    expect(JSON.parse(output.read())).toEqual({
-      data: [
-        {
-          recordId: "550e8400-e29b-41d4-a716-446655440001",
-          timestamp: "2026-04-22T10:00:00Z",
-          changeField: "",
-          change: {
-            beforeValue: null,
-            afterValue: null,
-            author: "developer@zinkee.com",
-            operation: "CREATE",
-          },
-        },
-      ],
-      meta: {
-        command: "logs list",
-      },
-    });
-  });
-});

package/src/commands/logs.ts

@@ -1,159 +0,0 @@
-import type { Writable } from "node:stream";
-
-import { Command, InvalidArgumentError } from "commander";
-
-import { LogsApi } from "../api/logs.js";
-import { ApiClient } from "../client.js";
-import { defaultConfigPath, readRuntimeConfig } from "../config.js";
-import {
-  normalizeUuidOrSlug,
-  type NormalizedUuidOrSlug,
-} from "../parsers/selectors.js";
-import { resolveRuntimeContext } from "../runtime-context.js";
-import type { JsonObject, RuntimeOverrides } from "../types.js";
-import { CliError } from "../utils/errors.js";
-import { buildJsonSuccess, printTable } from "../utils/output.js";
-
-interface CommandIo {
-  write(chunk: string): unknown;
-}
-
-export interface RegisterLogsCommandsOptions {
-  configPath?: string;
-  stdout?: CommandIo;
-}
-
-interface GlobalOptions extends RuntimeOverrides {}
-
-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,
-  ..._extra: unknown[]
-): void {
-  writeLine(
-    stdout,
-    JSON.stringify(buildJsonSuccess(data, { command: commandName })),
-  );
-}
-
-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;
-}
-
-function createLogsApi(
-  command: Command,
-  filePath: string,
-): { api: LogsApi; json: boolean } {
-  try {
-    const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions(command));
-
-    if (!runtime.baseUrl) {
-      throw new CliError(
-        "configuration_error",
-        `Resolved profile "${runtime.profile}" is missing a base URL.`,
-      );
-    }
-
-    return {
-      api: new LogsApi(
-        new ApiClient({
-          baseUrl: runtime.baseUrl,
-          apiKey: runtime.apiKey,
-        }),
-      ),
-      json: runtime.json,
-    };
-  } catch (error) {
-    toConfigurationError(filePath, error);
-  }
-}
-
-function parseUuidOrSlugSelector(input: string): NormalizedUuidOrSlug {
-  try {
-    return normalizeUuidOrSlug(input);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError(message);
-  }
-}
-
-function isJsonObject(value: unknown): value is JsonObject {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function toTableRows(data: unknown): Record<string, unknown>[] {
-  if (Array.isArray(data)) {
-    return data.map((entry) => (isJsonObject(entry) ? entry : { value: entry }));
-  }
-
-  if (isJsonObject(data)) {
-    return [data];
-  }
-
-  return [{ value: data }];
-}
-
-function emitTable(stdout: CommandIo, data: unknown): void {
-  printTable(toTableRows(data), undefined, stdout);
-}
-
-export function registerLogsCommands(
-  program: Command,
-  options: RegisterLogsCommandsOptions = {},
-): void {
-  const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo(options.stdout);
-  const logs = program.command("logs").description("Inspect record change logs");
-
-  logs
-    .command("list")
-    .description("List change logs for a record")
-    .argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector)
-    .argument("<record>", "record uuid or slug", parseUuidOrSlugSelector)
-    .action(async function action(
-      this: Command,
-      schema: NormalizedUuidOrSlug,
-      record: NormalizedUuidOrSlug,
-    ) {
-      const { api, json } = createLogsApi(this, filePath);
-      const data = await api.listLogs(schema, record.value);
-
-      if (json) {
-        emitJson(stdout, "logs list", data, filePath);
-        return;
-      }
-
-      emitTable(stdout, data);
-    });
-}