zinkee 0.1.44 → 0.1.46

package/src/commands/comments.test.ts

@@ -1,214 +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-comments-"));
-  const filePath = join(dir, "config.toml");
-  writeFileSync(filePath, contents, "utf8");
-  return filePath;
-}
-
-function createApiConfig(): string {
-  return createTempConfig(`
-default_profile = "prod"
-
-[profiles.prod]
-api_key = "comments-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("comments commands", () => {
-  it("registers the comments command group", () => {
-    const program = buildProgram();
-
-    expect(program.commands.some((command) => command.name() === "comments")).toBe(true);
-  });
-
-  it("lists comments for a record", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse([
-        {
-          id: "comment-1",
-          text: "Hello",
-        },
-      ]),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "comments",
-      "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/comments",
-    );
-    expect(JSON.parse(output.read())).toEqual({
-      data: [
-        {
-          id: "comment-1",
-          text: "Hello",
-        },
-      ],
-      meta: {
-        command: "comments list",
-      },
-    });
-  });
-
-  it("creates comments with text-first input", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        id: "comment-1",
-        text: "Hello world",
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "comments",
-      "create",
-      "contacts",
-      "550E8400-E29B-41D4-A716-446655440001",
-      "--text",
-      "Hello world",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/schemas/contacts/records/550e8400-e29b-41d4-a716-446655440001/comments",
-    );
-    expect(init?.method).toBe("POST");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      content: [
-        {
-          type: "TEXT",
-          value: "Hello world",
-        },
-      ],
-    });
-  });
-
-  it("accepts raw-file comment payloads without requiring text", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const rawFile = join(
-      mkdtempSync(join(tmpdir(), "zinkee-comment-create-")),
-      "comment.json",
-    );
-    writeFileSync(
-      rawFile,
-      JSON.stringify({
-        kind: "rich",
-        blocks: [{ type: "paragraph", text: "Hello" }],
-      }),
-      "utf8",
-    );
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        id: "comment-2",
-      }),
-    );
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "comments",
-      "create",
-      "contacts",
-      "record-1",
-      "--raw-file",
-      rawFile,
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-
-    expect(JSON.parse(String(init?.body))).toEqual({
-      kind: "rich",
-      blocks: [{ type: "paragraph", text: "Hello" }],
-    });
-  });
-
-  it("blocks comment creation 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",
-        "comments",
-        "create",
-        "contacts",
-        "record-1",
-        "--text",
-        "Hello world",
-      ]),
-    ).rejects.toThrowError('Command "comments create" is not allowed in read-only mode.');
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-});

package/src/commands/comments.ts

@@ -1,303 +0,0 @@
-import { readFileSync } from "node:fs";
-import type { Writable } from "node:stream";
-
-import { Command, InvalidArgumentError } from "commander";
-
-import {
-  CommentsApi,
-  type CreateCommentInput,
-} from "../api/comments.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 RegisterCommentsCommandsOptions {
-  configPath?: string;
-  stdout?: CommandIo;
-}
-
-interface GlobalOptions extends RuntimeOverrides {}
-
-interface CommentCreateCommandOptions {
-  text?: string;
-  raw?: string;
-  rawFile?: string;
-}
-
-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 createCommentsApi(
-  command: Command,
-  filePath: string,
-): { api: CommentsApi; 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 CommentsApi(
-        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,
-  commandMode: "write" | "destructive",
-): void {
-  if (readOnly) {
-    throw new CliError(
-      "command_not_allowed_in_read_only_mode",
-      `Command "${commandName}" is not allowed in read-only mode.`,
-      {
-        commandMode,
-        executionMode: "read-only",
-      },
-    );
-  }
-}
-
-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 parseRawJsonObject(input: string, sourceLabel: string): JsonObject {
-  let parsed: unknown;
-
-  try {
-    parsed = JSON.parse(input);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Invalid JSON.";
-    throw new CliError(
-      "invalid_cli_usage",
-      `Failed to parse JSON from ${sourceLabel}: ${message}`,
-    );
-  }
-
-  if (!isJsonObject(parsed)) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Expected ${sourceLabel} to contain a JSON object.`,
-    );
-  }
-
-  return parsed;
-}
-
-function readRawObject(
-  raw: string | undefined,
-  rawFile: string | undefined,
-): JsonObject {
-  if (raw && rawFile) {
-    throw new CliError(
-      "invalid_cli_usage",
-      'Provide either "--raw" or "--raw-file", not both.',
-    );
-  }
-
-  if (raw) {
-    return parseRawJsonObject(raw, "--raw");
-  }
-
-  if (rawFile) {
-    let contents: string;
-
-    try {
-      contents = readFileSync(rawFile, "utf8");
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unable to read file.";
-      throw new CliError(
-        "invalid_cli_usage",
-        `Failed to read raw payload from ${rawFile}: ${message}`,
-      );
-    }
-
-    return parseRawJsonObject(contents, `--raw-file ${rawFile}`);
-  }
-
-  return {};
-}
-
-function isEmptyObject(value: object): boolean {
-  return Object.keys(value).length === 0;
-}
-
-function buildCommentCreateInput(options: CommentCreateCommandOptions): CreateCommentInput {
-  const input: CreateCommentInput = {
-    ...readRawObject(options.raw, options.rawFile),
-  };
-
-  if (options.text !== undefined) {
-    input.content = [
-      {
-        type: "TEXT",
-        value: options.text,
-      },
-    ];
-  }
-
-  if (isEmptyObject(input)) {
-    throw new CliError(
-      "invalid_cli_usage",
-      'Provide comment content via "--text", "--raw", or "--raw-file".',
-    );
-  }
-
-  return input;
-}
-
-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 registerCommentsCommands(
-  program: Command,
-  options: RegisterCommentsCommandsOptions = {},
-): void {
-  const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo(options.stdout);
-  const comments = program.command("comments").description("Manage record comments");
-
-  comments
-    .command("list")
-    .description("List comments 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 } = createCommentsApi(this, filePath);
-      const data = await api.listComments(schema, record.value);
-
-      if (json) {
-        emitJson(stdout, "comments list", data, filePath);
-        return;
-      }
-
-      emitTable(stdout, data);
-    });
-
-  comments
-    .command("create")
-    .description("Create a comment on a record")
-    .argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector)
-    .argument("<record>", "record uuid or slug", parseUuidOrSlugSelector)
-    .option("--text <text>", "comment text")
-    .option("--raw <json>", "raw JSON object payload")
-    .option("--raw-file <path>", "path to a raw JSON object payload")
-    .action(async function action(
-      this: Command,
-      schema: NormalizedUuidOrSlug,
-      record: NormalizedUuidOrSlug,
-      commandOptions: CommentCreateCommandOptions,
-    ) {
-      const { api, json, readOnly } = createCommentsApi(this, filePath);
-      ensureWritable("comments create", readOnly, "write");
-
-      const data = await api.createComment(
-        schema,
-        record.value,
-        buildCommentCreateInput(commandOptions),
-      );
-
-      if (json) {
-        emitJson(stdout, "comments create", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Created comment "${String(data.id ?? "unknown")}".`);
-    });
-}

package/src/commands/config.test.ts

@@ -1,81 +0,0 @@
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { describe, expect, it } from "vitest";
-
-import { buildProgram } from "../index.js";
-
-function createTempConfig(contents: string): string {
-  const dir = mkdtempSync(join(tmpdir(), "zinkee-config-"));
-  const filePath = join(dir, "config.toml");
-  writeFileSync(filePath, contents, "utf8");
-  return filePath;
-}
-
-function createStdoutBuffer() {
-  let output = "";
-
-  return {
-    stdout: {
-      write(chunk: string) {
-        output += chunk;
-        return true;
-      },
-    },
-    read() {
-      return output;
-    },
-  };
-}
-
-describe("config commands", () => {
-  it("registers the config command group", () => {
-    const program = buildProgram();
-
-    expect(program.commands.some((command) => command.name() === "config")).toBe(true);
-  });
-
-  it("redacts secrets in config show output", async () => {
-    const configPath = createTempConfig(`
-default_profile = "prod"
-
-[profiles.prod]
-api_key = "super-secret-1234"
-base_url = "https://api.zinkee.test"
-`);
-    const output = createStdoutBuffer();
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync(["node", "zinkee", "config", "show"]);
-
-    expect(output.read()).toContain("Default profile: prod");
-    expect(output.read()).toContain("apiKey");
-    expect(output.read()).toContain("********1234");
-    expect(output.read()).not.toContain("super-secret-1234");
-  });
-
-  it("returns a JSON envelope for config validate", async () => {
-    const configPath = createTempConfig(`
-default_profile = "prod"
-
-[profiles.prod]
-api_key = "token-1234"
-`);
-    const output = createStdoutBuffer();
-    const program = buildProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync(["node", "zinkee", "--json", "config", "validate"]);
-
-    expect(JSON.parse(output.read())).toEqual({
-      data: {
-        valid: true,
-        profile: "prod",
-      },
-      meta: {
-        command: "config validate",
-        configPath,
-      },
-    });
-  });
-});