zinkee 0.1.44 → 0.1.45

package/src/config.ts

@@ -1,294 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-import { parseTOML, stringifyTOML } from "confbox/toml";
-
-import type { AppConfig, ProfileConfig, RuntimeOverrides, ResolvedProfile } from "./types.js";
-
-export const defaultConfigPath = join(homedir(), ".config", "zinkee", "config.toml");
-export const redactedSecretMask = "********";
-export const ENV_API_KEY = "ZINKEE_API_KEY";
-export const ENV_BASE_URL = "ZINKEE_API_BASE_URL";
-export const ENV_PROFILE = "ZINKEE_PROFILE";
-export const DEFAULT_PRODUCTION_BASE_URL = "https://api-z2.zinkee.com";
-
-export class ProfileResolutionError extends Error {
-  override name = "ProfileResolutionError";
-
-  constructor(message: string) {
-    super(message);
-  }
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function toStringValue(value: unknown): string | undefined {
-  return typeof value === "string" ? value : undefined;
-}
-
-function toNonEmptyString(value: string | undefined): string | undefined {
-  const normalized = value?.trim();
-  return normalized ? normalized : undefined;
-}
-
-function parseProfileConfig(value: unknown): ProfileConfig {
-  const profile: ProfileConfig = {};
-
-  if (!isRecord(value)) {
-    return profile;
-  }
-
-  for (const [key, rawValue] of Object.entries(value)) {
-    if (key === "api_key") {
-      profile.apiKey = toStringValue(rawValue);
-      continue;
-    }
-
-    if (key === "base_url") {
-      profile.baseUrl = toStringValue(rawValue);
-      continue;
-    }
-
-    profile[key] = rawValue;
-  }
-
-  return profile;
-}
-
-export function parseConfig(toml: string): AppConfig {
-  const parsed = parseTOML<unknown>(toml);
-  const config: AppConfig = { profiles: {} };
-
-  if (!isRecord(parsed)) {
-    return config;
-  }
-
-  for (const [key, value] of Object.entries(parsed)) {
-    if (key === "default_profile") {
-      config.defaultProfile = toStringValue(value);
-      continue;
-    }
-
-    if (key === "profiles") {
-      if (!isRecord(value)) {
-        continue;
-      }
-
-      for (const [profileName, profileValue] of Object.entries(value)) {
-        config.profiles[profileName] = parseProfileConfig(profileValue);
-      }
-
-      continue;
-    }
-
-    config[key] = value;
-  }
-
-  return config;
-}
-
-export function readConfig(filePath: string = defaultConfigPath): AppConfig {
-  return parseConfig(readFileSync(filePath, "utf8"));
-}
-
-export function readConfigIfExists(filePath: string = defaultConfigPath): AppConfig | undefined {
-  try {
-    return readConfig(filePath);
-  } catch (error) {
-    if (
-      typeof error === "object" &&
-      error !== null &&
-      "code" in error &&
-      error.code === "ENOENT"
-    ) {
-      return undefined;
-    }
-
-    throw error;
-  }
-}
-
-export function readRuntimeConfig(filePath: string = defaultConfigPath): AppConfig {
-  return readConfigIfExists(filePath) ?? { profiles: {} };
-}
-
-function serializeProfileConfig(profile: ProfileConfig): Record<string, unknown> {
-  const serialized: Record<string, unknown> = {};
-
-  for (const [key, value] of Object.entries(profile)) {
-    if (value === undefined) {
-      continue;
-    }
-
-    if (key === "apiKey") {
-      serialized.api_key = value;
-      continue;
-    }
-
-    if (key === "baseUrl") {
-      serialized.base_url = value;
-      continue;
-    }
-
-    serialized[key] = value;
-  }
-
-  return serialized;
-}
-
-export function serializeConfig(config: AppConfig): string {
-  const serialized: Record<string, unknown> = {};
-
-  if (config.defaultProfile !== undefined) {
-    serialized.default_profile = config.defaultProfile;
-  }
-
-  for (const [key, value] of Object.entries(config)) {
-    if (key === "defaultProfile" || key === "profiles" || value === undefined) {
-      continue;
-    }
-
-    serialized[key] = value;
-  }
-
-  const serializedProfiles = Object.fromEntries(
-    Object.entries(config.profiles).map(([name, profile]) => [name, serializeProfileConfig(profile)]),
-  );
-
-  if (Object.keys(serializedProfiles).length > 0) {
-    serialized.profiles = serializedProfiles;
-  }
-
-  return stringifyTOML(serialized).trimEnd().concat("\n");
-}
-
-export function writeConfig(config: AppConfig, filePath: string = defaultConfigPath): void {
-  mkdirSync(dirname(filePath), { recursive: true });
-  writeFileSync(filePath, serializeConfig(config), "utf8");
-}
-
-export function setProfileConfig(
-  config: AppConfig,
-  profileName: string,
-  updates: Partial<ProfileConfig>,
-): AppConfig {
-  return {
-    ...config,
-    profiles: {
-      ...config.profiles,
-      [profileName]: {
-        ...config.profiles[profileName],
-        ...updates,
-      },
-    },
-  };
-}
-
-export function removeProfileConfig(config: AppConfig, profileName: string): AppConfig {
-  const nextProfiles = { ...config.profiles };
-  delete nextProfiles[profileName];
-
-  return {
-    ...config,
-    defaultProfile:
-      config.defaultProfile === profileName
-        ? undefined
-        : config.defaultProfile,
-    profiles: nextProfiles,
-  };
-}
-
-export function setDefaultProfile(config: AppConfig, profileName: string): AppConfig {
-  return {
-    ...config,
-    defaultProfile: profileName,
-  };
-}
-
-export function redactSecret(value: string | undefined): string | undefined {
-  if (value === undefined) {
-    return undefined;
-  }
-
-  if (value.length <= 4) {
-    return redactedSecretMask;
-  }
-
-  return `${redactedSecretMask}${value.slice(-4)}`;
-}
-
-export function redactProfile(profile: ProfileConfig): ProfileConfig {
-  return {
-    ...profile,
-    apiKey: redactSecret(profile.apiKey),
-  };
-}
-
-export function redactConfig(config: AppConfig): AppConfig {
-  return {
-    ...config,
-    profiles: Object.fromEntries(
-      Object.entries(config.profiles).map(([name, profile]) => [name, redactProfile(profile)]),
-    ),
-  };
-}
-
-export function resolveProfile(
-  config: AppConfig,
-  overrides: Pick<RuntimeOverrides, "profile" | "baseUrl" | "apiKey"> = {},
-): ResolvedProfile {
-  const profileName = overrides.profile ?? config.defaultProfile;
-  if (profileName) {
-    const profile = config.profiles[profileName];
-
-    if (!profile) {
-      const label = overrides.profile ? "Profile" : "Default profile";
-      throw new ProfileResolutionError(`${label} "${profileName}" not found in config.`);
-    }
-
-    return {
-      ...profile,
-      name: profileName,
-      baseUrl: overrides.baseUrl ?? profile.baseUrl,
-      apiKey: overrides.apiKey ?? profile.apiKey,
-    };
-  }
-
-  throw new ProfileResolutionError("No profile could be resolved from config.");
-}
-
-export function validateBaseUrl(value: string, source: string = "Base URL"): string {
-  let parsed: URL;
-
-  try {
-    parsed = new URL(value);
-  } catch {
-    throw new ProfileResolutionError(`${source} must be an absolute http(s) URL.`);
-  }
-
-  if (!["http:", "https:"].includes(parsed.protocol) || !parsed.host) {
-    throw new ProfileResolutionError(`${source} must be an absolute http(s) URL.`);
-  }
-
-  return value.replace(/\/+$/, "");
-}
-
-export function readEnvApiKey(env: NodeJS.ProcessEnv = process.env): string | undefined {
-  return toNonEmptyString(env[ENV_API_KEY]);
-}
-
-export function readEnvBaseUrl(env: NodeJS.ProcessEnv = process.env): string | undefined {
-  const baseUrl = toNonEmptyString(env[ENV_BASE_URL]);
-  if (!baseUrl) {
-    return undefined;
-  }
-
-  return validateBaseUrl(baseUrl, `Environment variable ${ENV_BASE_URL}`);
-}
-
-export function readEnvProfile(env: NodeJS.ProcessEnv = process.env): string | undefined {
-  return toNonEmptyString(env[ENV_PROFILE]);
-}

package/src/index.test.ts

@@ -1,217 +0,0 @@
-import { mkdtempSync, rmSync, symlinkSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import { extractExampleRequest, showExamples } from "./cli-examples.js";
-import { isExecutedAsEntry } from "./cli-runner.js";
-import { buildProgram } from "./program.js";
-
-const tempDirs: string[] = [];
-
-describe("project bootstrap", () => {
-  afterEach(() => {
-    while (tempDirs.length > 0) {
-      rmSync(tempDirs.pop()!, { force: true, recursive: true });
-    }
-  });
-
-  it("loads the CLI entry module", async () => {
-    const mod = await import("./index.js");
-
-    expect(mod).toBeTruthy();
-    expect(mod.buildProgram).toBeTypeOf("function");
-  });
-
-  it("registers the global --example option", () => {
-    const program = buildProgram();
-
-    expect(program.options.some((option) => option.long === "--example")).toBe(true);
-  });
-
-  it("extracts example requests before commander parsing", () => {
-    expect(
-      extractExampleRequest(["node", "zinkee", "--json", "--example", "records", "query"]),
-    ).toEqual({
-      commandName: "records query",
-      filters: {},
-      json: true,
-    });
-  });
-
-  it("extracts typed schema field examples without treating schema args as part of the command", () => {
-    expect(
-      extractExampleRequest([
-        "node",
-        "zinkee",
-        "--profile",
-        "local",
-        "--example",
-        "schemas",
-        "fields",
-        "create",
-        "contacts",
-        "--type",
-        "option",
-      ]),
-    ).toEqual({
-      commandName: "schemas fields create",
-      filters: {
-        type: "option",
-      },
-      json: false,
-    });
-  });
-
-  it("extracts example requests when --example appears at the end of argv", () => {
-    expect(
-      extractExampleRequest(["node", "zinkee", "schemas", "list", "--example"]),
-    ).toEqual({
-      commandName: "schemas list",
-      filters: {},
-      json: false,
-    });
-  });
-
-  it("extracts example filters when --example appears after the filter flags", () => {
-    expect(
-      extractExampleRequest([
-        "node",
-        "zinkee",
-        "schemas",
-        "fields",
-        "create",
-        "contacts",
-        "--type",
-        "option",
-        "--example",
-      ]),
-    ).toEqual({
-      commandName: "schemas fields create",
-      filters: { type: "option" },
-      json: false,
-    });
-  });
-
-  it("extracts example requests regardless of --example position", () => {
-    expect(
-      extractExampleRequest([
-        "node",
-        "zinkee",
-        "schemas",
-        "list",
-        "--profile",
-        "staging",
-        "--example",
-        "--json",
-      ]),
-    ).toEqual({
-      commandName: "schemas list",
-      filters: {},
-      json: true,
-    });
-  });
-
-  it("rejects a command group by listing all its subcommands", () => {
-    let message = "";
-    try {
-      extractExampleRequest(["node", "zinkee", "--example", "schemas"]);
-    } catch (error) {
-      message = (error as Error).message;
-    }
-
-    expect(message).toContain('"schemas" is a command group');
-    expect(message).toContain("zinkee --example schemas list");
-    expect(message).toContain("zinkee --example schemas get");
-    expect(message).toContain("zinkee --example schemas fields create");
-  });
-
-  it("reports an unknown command after --example", () => {
-    expect(() =>
-      extractExampleRequest(["node", "zinkee", "--example", "frobnicate"]),
-    ).toThrowError('Unknown command "frobnicate".');
-  });
-
-  it("still asks for a command when --example has no operand", () => {
-    expect(() => extractExampleRequest(["node", "zinkee", "--example"])).toThrowError(
-      'Provide a command after "--example".',
-    );
-  });
-
-  it("shows field examples filtered by type", async () => {
-    let output = "";
-
-    await showExamples(
-      "schemas fields create",
-      false,
-      {
-        write(chunk: string) {
-          output += chunk;
-          return true;
-        },
-      },
-      { type: "option" },
-    );
-
-    expect(output).toContain('zinkee --json schemas fields create contacts --raw');
-    expect(output).toContain('"type":"OptionField"');
-    expect(output).not.toContain('"type":"TextField"');
-    expect(output).toContain("Option field (select dropdown)");
-  });
-
-  it("shows every backend number variant, including currency formatting", async () => {
-    let output = "";
-
-    await showExamples(
-      "schemas fields create",
-      false,
-      {
-        write(chunk: string) {
-          output += chunk;
-          return true;
-        },
-      },
-      { type: "number" },
-    );
-
-    expect(output).toContain('"slug":"quantity"');
-    expect(output).toContain('"slug":"amount-eur"');
-    expect(output).toContain('"slug":"amount-usd"');
-    expect(output).toContain('"defaultValue":"0"');
-    expect(output).toContain('"symbolEnabled":true');
-    expect(output).toContain('"symbolPosition":"before"');
-    expect(output).toContain('"symbolPosition":"right"');
-    expect(output).toContain('"format":"percentage"');
-    expect(output).toContain('"durationFormat":"HH:MM"');
-  });
-
-  it("shows automation examples with descriptions and equivalent payloads", async () => {
-    let output = "";
-
-    await showExamples("automations create", false, {
-      write(chunk: string) {
-        output += chunk;
-        return true;
-      },
-    });
-
-    expect(output).toContain("Create a scheduled automation");
-    expect(output).toContain("Equivalent JSON payload:");
-    expect(output).toContain('"type": "scheduled"');
-    expect(output).toContain('"cronExpression": "0 15 10 * * 1"');
-  });
-
-  it("treats symlinked executables as the CLI entrypoint", () => {
-    const tempDir = mkdtempSync(join(tmpdir(), "zinkee-entry-"));
-    const realEntry = join(tempDir, "real-entry.js");
-    const linkedEntry = join(tempDir, "zinkee");
-    tempDirs.push(tempDir);
-
-    symlinkSync(fileURLToPath(import.meta.url), realEntry);
-    symlinkSync(realEntry, linkedEntry);
-
-    expect(isExecutedAsEntry(linkedEntry, pathToFileURL(realEntry).href)).toBe(true);
-  });
-});

package/src/index.ts

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-
-import { runCli, isExecutedAsEntry } from "./cli-runner.js";
-export { buildProgram, type BuildProgramOptions } from "./program.js";
-
-if (isExecutedAsEntry(process.argv[1], import.meta.url)) {
-  await runCli(process.argv);
-}

package/src/parsers/expressions.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { parseExpression } from "./expressions.js";
-
-describe("parseExpression", () => {
-  describe("scalar comparators", () => {
-    it.each([
-      ["eq", "status eq active", "status", "active"],
-      ["neq", "status neq archived", "status", "archived"],
-      ["gt", "amount gt 1000", "amount", "1000"],
-      ["gte", "amount gte 500", "amount", "500"],
-      ["lt", "amount lt 100", "amount", "100"],
-      ["lte", "due-date lte 2026-12-31T23:59:59Z", "due-date", "2026-12-31T23:59:59Z"],
-      ["contains", "contact-name contains Lovelace", "contact-name", "Lovelace"],
-    ])("parses %s expressions", (comparator, input, field, value) => {
-      expect(parseExpression(input)).toEqual({
-        field,
-        comparator,
-        value,
-        raw: input,
-      });
-    });
-
-    it("preserves spaces inside contains values", () => {
-      expect(parseExpression("email contains @acme.com")).toEqual({
-        field: "email",
-        comparator: "contains",
-        value: "@acme.com",
-        raw: "email contains @acme.com",
-      });
-    });
-  });
-
-  describe("unary comparators", () => {
-    it.each([
-      ["is_empty", "due-date is_empty", "due-date"],
-      ["is_not_empty", "contact-email is_not_empty", "contact-email"],
-    ])("parses %s expressions without a value", (comparator, input, field) => {
-      expect(parseExpression(input)).toEqual({
-        field,
-        comparator,
-        value: null,
-        raw: input,
-      });
-    });
-  });
-
-  describe("list comparators", () => {
-    it("parses in expressions with a comma-separated value", () => {
-      expect(parseExpression("ownerId in a,b,c")).toEqual({
-        field: "ownerId",
-        comparator: "in",
-        value: ["a", "b", "c"],
-        raw: "ownerId in a,b,c",
-      });
-    });
-  });
-
-  describe("delimiters", () => {
-    it("parses colon-delimited expressions", () => {
-      expect(parseExpression("amount:gt:1000")).toEqual({
-        field: "amount",
-        comparator: "gt",
-        value: "1000",
-        raw: "amount:gt:1000",
-      });
-    });
-  });
-
-  describe("errors", () => {
-    it("rejects unknown comparators", () => {
-      expect(() => parseExpression("status ne archived")).toThrow(
-        'Unsupported comparator "ne" in expression "status ne archived".',
-      );
-    });
-
-    it("rejects scalar comparators without a value", () => {
-      expect(() => parseExpression("status eq")).toThrow(
-        'Comparator "eq" requires a value.',
-      );
-    });
-
-    it("rejects unary comparators that carry a value", () => {
-      expect(() => parseExpression("due-date is_empty 2026-01-01")).toThrow(
-        'Comparator "is_empty" does not accept a value.',
-      );
-    });
-
-    it("rejects in expressions with no values", () => {
-      expect(() => parseExpression("ownerId in")).toThrow(
-        'Comparator "in" requires at least one value.',
-      );
-    });
-  });
-});