@lizard-build/cli 0.1.0 → 0.3.30

package/test/unit/resolve.test.ts

@@ -0,0 +1,124 @@
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+let tmpDir: string;
+let originalCwd: string;
+let originalLizardHome: string | undefined;
+
+beforeEach(() => {
+  originalCwd = process.cwd();
+  originalLizardHome = process.env.LIZARD_HOME;
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "lizard-resolve-test-"));
+  process.env.LIZARD_HOME = tmpDir;
+  process.chdir(tmpDir);
+});
+
+afterEach(() => {
+  process.chdir(originalCwd);
+  if (originalLizardHome === undefined) delete process.env.LIZARD_HOME;
+  else process.env.LIZARD_HOME = originalLizardHome;
+  vi.restoreAllMocks();
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+  vi.resetModules();
+});
+
+async function withMockedApi(getHandler: (path: string) => unknown) {
+  vi.resetModules();
+  const calls: string[] = [];
+  vi.doMock("../../src/lib/api.js", async () => {
+    const actual = await vi.importActual<typeof import("../../src/lib/api.js")>(
+      "../../src/lib/api.js",
+    );
+    return {
+      ...actual,
+      api: {
+        get: (p: string) => {
+          calls.push(p);
+          return Promise.resolve(getHandler(p));
+        },
+        post: () => Promise.reject(new Error("unexpected POST")),
+        put: () => Promise.reject(new Error("unexpected PUT")),
+        patch: () => Promise.reject(new Error("unexpected PATCH")),
+        delete: () => Promise.reject(new Error("unexpected DELETE")),
+      },
+    };
+  });
+  const resolve = await import("../../src/lib/resolve.js");
+  const config = await import("../../src/lib/config.js");
+  return { resolve, config, calls };
+}
+
+function writeLink(homeDir: string, link: Record<string, unknown>) {
+  // Key under process.cwd() — macOS symlinks /var → /private/var so the
+  // disk-stored path must match what getProjectLink() will lookup.
+  const cwdKey = process.cwd();
+  fs.mkdirSync(path.join(homeDir, ".lizard"), { recursive: true });
+  fs.writeFileSync(
+    path.join(homeDir, ".lizard", "config.json"),
+    JSON.stringify({ projects: { [cwdKey]: link } }),
+  );
+}
+
+describe("resolveProjectScope", () => {
+  test("uses workspaceId from the link when present", async () => {
+    writeLink(tmpDir, {
+      projectId: "proj_1",
+      workspaceId: "ws_already",
+      workspaceName: "team",
+    });
+
+    const { resolve, calls } = await withMockedApi(() => null);
+    const { projectId, scope } = await resolve.resolveProjectScope();
+
+    expect(projectId).toBe("proj_1");
+    expect(scope.workspaceId).toBe("ws_already");
+    // No need to fetch the project — workspaceId was already on disk.
+    expect(calls.filter((c) => c.startsWith("/api/projects/proj_1"))).toHaveLength(0);
+  });
+
+  test("lazy-fills workspaceId when missing and updates the link on disk", async () => {
+    writeLink(tmpDir, { projectId: "proj_legacy", projectName: "old" });
+
+    const { resolve, config, calls } = await withMockedApi((p) =>
+      p === "/api/projects/proj_legacy"
+        ? { workspaceId: "ws_fetched", workspaceName: "fetched-ws" }
+        : null,
+    );
+
+    const { scope } = await resolve.resolveProjectScope();
+    expect(scope.workspaceId).toBe("ws_fetched");
+    expect(calls).toContain("/api/projects/proj_legacy");
+
+    const linkAfter = config.getProjectLink(process.cwd());
+    expect(linkAfter?.workspaceId).toBe("ws_fetched");
+    expect(linkAfter?.workspaceName).toBe("fetched-ws");
+  });
+
+  test("returns null scope when the lookup fails", async () => {
+    writeLink(tmpDir, { projectId: "proj_unknown" });
+    const { resolve } = await withMockedApi(() => {
+      throw new Error("404");
+    });
+
+    const { scope } = await resolve.resolveProjectScope();
+    expect(scope.workspaceId).toBeFalsy();
+  });
+});
+
+describe("getScope", () => {
+  test("returns normalized scope from a resolved context", async () => {
+    vi.resetModules();
+    const { getScope } = await import("../../src/lib/resolve.js");
+    expect(
+      getScope({
+        projectId: "x",
+        workspaceId: "ws_1",
+      }),
+    ).toEqual({ workspaceId: "ws_1" });
+    expect(getScope({ projectId: "x" })).toEqual({
+      workspaceId: null,
+    });
+  });
+});

package/test/unit/service-set.test.ts

@@ -0,0 +1,355 @@
+import { describe, test, expect } from "vitest";
+import {
+  flattenPatch,
+  validateSetPath,
+  validateName,
+  parseValue,
+  setDeep,
+  SERVICE_FIELDS,
+} from "../../src/commands/service-set.js";
+
+const ID = "app_123";
+const NAME = "api";
+const NAMES = new Map([[ID, NAME]]);
+
+// ── flattenPatch: canonical flat shape ─────────────────────────────────────
+
+describe("flattenPatch — flat canonical shape", () => {
+  test("flat cfg fields land 1:1 on the wire", () => {
+    const body = flattenPatch(
+      {
+        services: {
+          [ID]: {
+            buildCommand: "npm run build",
+            startCommand: "node dist/index.js",
+            preDeployCommand: "npm run migrate",
+            healthcheckPath: "/health",
+            healthcheckTimeoutMs: 5000,
+            sourceType: "github",
+            repoUrl: "https://github.com/acme/api",
+            branch: "main",
+            rootDirectory: "apps/api",
+            watchPatterns: ["apps/api/**"],
+            dockerfilePath: "apps/api/Dockerfile",
+          },
+        },
+      },
+      NAMES,
+    );
+    expect(body).toEqual({
+      services: [
+        {
+          id: ID,
+          buildCommand: "npm run build",
+          startCommand: "node dist/index.js",
+          preDeployCommand: "npm run migrate",
+          healthcheckPath: "/health",
+          healthcheckTimeoutMs: 5000,
+          sourceType: "github",
+          repoUrl: "https://github.com/acme/api",
+          branch: "main",
+          rootDirectory: "apps/api",
+          watchPatterns: ["apps/api/**"],
+          dockerfilePath: "apps/api/Dockerfile",
+        },
+      ],
+    });
+  });
+
+  test("empty cfg yields service entry with id only (no implicit name)", () => {
+    const body = flattenPatch({ services: { [ID]: {} } }, NAMES);
+    expect(body.services).toEqual([{ id: ID }]);
+    expect(body.services[0]).not.toHaveProperty("name");
+  });
+
+  test("each canonical field is independently round-trippable", () => {
+    for (const f of SERVICE_FIELDS) {
+      if (f === "name") continue;
+      const cfg: Record<string, unknown> = {};
+      cfg[f] = f === "healthcheckTimeoutMs" ? 1234 : f === "watchPatterns" ? ["x"] : "v";
+      const body = flattenPatch({ services: { [ID]: cfg } }, NAMES);
+      expect(body.services[0]).toMatchObject({ id: ID, [f]: cfg[f] });
+    }
+  });
+});
+
+// ── flattenPatch: legacy dotted prefixes are gone ──────────────────────────
+
+describe("flattenPatch — legacy prefixed paths throw", () => {
+  test.each([
+    ["build", { buildCommand: "npm run build" }],
+    ["deploy", { startCommand: "node dist/index.js" }],
+    ["source", { type: "github" }],
+  ])("nested '%s' block is rejected as unknown field", (prefix, inner) => {
+    expect(() =>
+      flattenPatch({ services: { [ID]: { [prefix]: inner } } }, NAMES),
+    ).toThrow(/Unknown field '\w+' in service "api"/);
+  });
+
+  test("rejects arbitrary opaque keys with hint to --help", () => {
+    expect(() =>
+      flattenPatch({ services: { [ID]: { foo: "bar" } } }, NAMES),
+    ).toThrow(/Unknown field 'foo'.*service set --help/s);
+  });
+});
+
+// ── rename ─────────────────────────────────────────────────────────────────
+
+describe("flattenPatch — rename", () => {
+  test("emits 'name' only when it differs from current", () => {
+    const body = flattenPatch(
+      { services: { [ID]: { name: "api-v2" } } },
+      NAMES,
+    );
+    expect(body.services).toEqual([{ id: ID, name: "api-v2" }]);
+  });
+
+  test("equal name is dropped (no fake audit-log churn)", () => {
+    const body = flattenPatch(
+      { services: { [ID]: { name: NAME, buildCommand: "x" } } },
+      NAMES,
+    );
+    expect(body.services[0]).not.toHaveProperty("name");
+    expect(body.services[0]).toMatchObject({ id: ID, buildCommand: "x" });
+  });
+
+  test("invalid new name throws before send", () => {
+    expect(() =>
+      flattenPatch({ services: { [ID]: { name: "Foo Bar" } } }, NAMES),
+    ).toThrow(/Invalid 'name'.*lowercase/);
+    expect(() =>
+      flattenPatch({ services: { [ID]: { name: "-leadinghyphen" } } }, NAMES),
+    ).toThrow(/Invalid 'name'/);
+    expect(() =>
+      flattenPatch({ services: { [ID]: { name: "x".repeat(41) } } }, NAMES),
+    ).toThrow(/40 characters or fewer/);
+  });
+
+  test("unknown service id throws with clear message", () => {
+    expect(() =>
+      flattenPatch(
+        { services: { ["app_does_not_exist"]: { buildCommand: "x" } } },
+        NAMES,
+      ),
+    ).toThrow(/no longer exists/);
+  });
+});
+
+// ── variables / secrets namespaces ─────────────────────────────────────────
+
+describe("flattenPatch — variables and secrets", () => {
+  test("variables.<KEY>=v lands in secrets.services[<name>]", () => {
+    const body = flattenPatch(
+      { services: { [ID]: { variables: { PORT: "3000" } } } },
+      NAMES,
+    );
+    expect(body.services[0]).toEqual({ id: ID });
+    expect(body.secrets).toEqual({ services: { [NAME]: { PORT: "3000" } } });
+  });
+
+  test("variables.<KEY>.value template form unwraps to its string", () => {
+    const body = flattenPatch(
+      {
+        services: {
+          [ID]: {
+            variables: { DB_URL: { value: "${{ postgres.DATABASE_URL }}" } },
+          },
+        },
+      },
+      NAMES,
+    );
+    expect(body.secrets!.services[NAME].DB_URL).toBe(
+      "${{ postgres.DATABASE_URL }}",
+    );
+  });
+
+  test("variables.<KEY>=null deletes (passed through as null)", () => {
+    const body = flattenPatch(
+      { services: { [ID]: { variables: { OLD: null } } } },
+      NAMES,
+    );
+    expect(body.secrets!.services[NAME]).toEqual({ OLD: null });
+  });
+
+  test("top-level sharedVariables → secrets.shared", () => {
+    const body = flattenPatch(
+      {
+        services: { [ID]: {} },
+        sharedVariables: { LOG_LEVEL: "debug" },
+      },
+      NAMES,
+    );
+    expect(body.secrets!.shared).toEqual({ LOG_LEVEL: "debug" });
+  });
+
+  test("explicit top-level secrets.services and secrets.shared pass through and merge", () => {
+    const body = flattenPatch(
+      {
+        services: { [ID]: { variables: { A: "1" } } },
+        secrets: {
+          services: { [NAME]: { B: "2" } },
+          shared: { GLOBAL: "g" },
+        },
+      },
+      NAMES,
+    );
+    expect(body.secrets!.services[NAME]).toEqual({ A: "1", B: "2" });
+    expect(body.secrets!.shared).toEqual({ GLOBAL: "g" });
+  });
+});
+
+// ── rename + secrets: CLI keys per-service secrets by pre-rename name ─────
+
+describe("flattenPatch — rename combined with secrets", () => {
+  // The backend's secrets.services lookup uses a pre-rename snapshot of the
+  // apps table, so per-service secret keys must match the pre-rename name.
+  // The CLI keys variables/envVars by `currentName` (= pre-rename) on its
+  // own, so this combination produces a body the backend accepts.
+  test("rename + variables.X — variables stay keyed by pre-rename name", () => {
+    const body = flattenPatch(
+      { services: { [ID]: { name: "api-v2", variables: { K: "v" } } } },
+      NAMES,
+    );
+    expect(body.services).toEqual([{ id: ID, name: "api-v2" }]);
+    expect(body.secrets).toEqual({ services: { [NAME]: { K: "v" } } });
+  });
+
+  test("rename + explicit secrets.services keyed by old name passes through", () => {
+    const body = flattenPatch(
+      {
+        services: { [ID]: { name: "api-v2" } },
+        secrets: { services: { [NAME]: { K: "v" } } },
+      },
+      NAMES,
+    );
+    expect(body.services).toEqual([{ id: ID, name: "api-v2" }]);
+    expect(body.secrets!.services[NAME]).toEqual({ K: "v" });
+  });
+});
+
+// ── --set path validation ──────────────────────────────────────────────────
+
+describe("validateSetPath", () => {
+  test.each(SERVICE_FIELDS)("accepts canonical field '%s'", (f) => {
+    expect(() => validateSetPath(f)).not.toThrow();
+  });
+
+  test.each([
+    "variables.PORT",
+    "variables.DB_URL.value",
+    "variables.A_LONG_KEY_123",
+  ])("accepts variables form '%s'", (path) => {
+    expect(() => validateSetPath(path)).not.toThrow();
+  });
+
+  test.each([
+    "build.buildCommand",
+    "deploy.startCommand",
+    "deploy.buildCommand",
+    "deploy.preDeployCommand",
+    "source.type",
+    "source.repoUrl",
+    "source.branch",
+  ])("rejects legacy prefixed path '%s'", (path) => {
+    expect(() => validateSetPath(path)).toThrow(/Unknown --set field/);
+  });
+
+  test("rejects arbitrary typos with --help hint", () => {
+    expect(() => validateSetPath("buld.buildCommand")).toThrow(
+      /Unknown --set field.*service set --help/s,
+    );
+    expect(() => validateSetPath("foo")).toThrow(/Unknown --set field/);
+  });
+
+  test("rejects malformed variables paths", () => {
+    expect(() => validateSetPath("variables")).toThrow(/Unknown --set field/);
+    expect(() => validateSetPath("variables.")).toThrow(/Invalid --set path/);
+    expect(() => validateSetPath("variables.K.notvalue")).toThrow(
+      /Invalid --set path/,
+    );
+    expect(() => validateSetPath("variables.K.value.extra")).toThrow(
+      /Invalid --set path/,
+    );
+  });
+});
+
+// ── validateName mirror of backend ─────────────────────────────────────────
+
+describe("validateName", () => {
+  test.each(["api", "api-v2", "x", "a1", "my-cool-service-99"])(
+    "accepts valid name '%s'",
+    (n) => {
+      expect(validateName(n)).toBeNull();
+    },
+  );
+
+  test.each([
+    ["", /required/],
+    ["x".repeat(41), /40 characters or fewer/],
+    ["Api", /lowercase/],
+    ["-api", /lowercase/],
+    ["api-", /lowercase/],
+    ["api_v2", /lowercase/],
+    ["api/v2", /lowercase/],
+    ["api v2", /lowercase/],
+  ])("rejects '%s' with reason matching %s", (n, re) => {
+    const msg = validateName(n);
+    expect(msg).not.toBeNull();
+    expect(msg!).toMatch(re);
+  });
+});
+
+// ── parseValue ──────────────────────────────────────────────────────────────
+
+describe("parseValue", () => {
+  test("healthcheckTimeoutMs coerces to number", () => {
+    expect(parseValue("healthcheckTimeoutMs", "5000")).toBe(5000);
+    expect(() => parseValue("healthcheckTimeoutMs", "fast")).toThrow(
+      /expects a number/,
+    );
+  });
+
+  test("watchPatterns: JSON array form", () => {
+    expect(parseValue("watchPatterns", '["src/**","apps/api/**"]')).toEqual([
+      "src/**",
+      "apps/api/**",
+    ]);
+  });
+
+  test("watchPatterns: comma-separated form", () => {
+    expect(parseValue("watchPatterns", "src/**, apps/api/**, ")).toEqual([
+      "src/**",
+      "apps/api/**",
+    ]);
+  });
+
+  test("plain string field passes through as-is (preserves whitespace)", () => {
+    expect(parseValue("startCommand", "node dist/index.js")).toBe(
+      "node dist/index.js",
+    );
+  });
+
+  test("JSON-shaped string is parsed when valid, kept raw on parse fail", () => {
+    expect(parseValue("repoUrl", '{"a":1}')).toEqual({ a: 1 });
+    expect(parseValue("repoUrl", "{not json}")).toBe("{not json}");
+  });
+});
+
+// ── setDeep ─────────────────────────────────────────────────────────────────
+
+describe("setDeep", () => {
+  test("writes a flat key", () => {
+    const o: any = {};
+    setDeep(o, "buildCommand", "foo");
+    expect(o).toEqual({ buildCommand: "foo" });
+  });
+
+  test("creates nested objects as needed", () => {
+    const o: any = {};
+    setDeep(o, "variables.PORT", "3000");
+    setDeep(o, "variables.DB_URL.value", "x");
+    expect(o).toEqual({
+      variables: { PORT: "3000", DB_URL: { value: "x" } },
+    });
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    singleThread: true,
+    testTimeout: 10 * 60 * 1000,
+    hookTimeout: 30_000,
+    reporter: "verbose",
+  },
+});

package/dist/commands/connect.d.ts

@@ -1,2 +0,0 @@
-import { Command } from "commander";
-export declare function registerConnect(program: Command): void;

package/dist/commands/connect.js

@@ -1,117 +0,0 @@
-import { execSync } from "node:child_process";
-import chalk from "chalk";
-import * as p from "@clack/prompts";
-import { api } from "../lib/api.js";
-import { resolveProjectId } from "../lib/config.js";
-import { info, isJSONMode, printJSON, isTTY } from "../lib/format.js";
-const CLIENT_COMMANDS = {
-    postgres: "psql",
-    mysql: "mysql",
-    mongodb: "mongosh",
-    redis: "redis-cli",
-};
-export function registerConnect(program) {
-    program
-        .command("connect")
-        .argument("[service]", "Service type or ID (postgres, redis, etc.)")
-        .description("Connect to a managed service")
-        .option("--url", "Print connection string without connecting")
-        .action(async (service, opts) => {
-        const projectId = resolveProjectId(program.opts().project);
-        // Get addons
-        const addons = await api.get(`/api/projects/${projectId}/addons`);
-        if (addons.length === 0) {
-            throw new Error("No managed services in this project. Use `lizard add`.");
-        }
-        let addon;
-        if (service) {
-            // Match by type or ID
-            addon =
-                addons.find((a) => a.addonType === service) ||
-                    addons.find((a) => a.id === service) ||
-                    addons.find((a) => a.name === service);
-        }
-        else if (addons.length === 1) {
-            addon = addons[0];
-        }
-        else {
-            if (!isTTY()) {
-                throw new Error("Multiple services found. Specify one: " +
-                    addons.map((a) => a.addonType || a.name).join(", "));
-            }
-            const selected = await p.select({
-                message: "Select service to connect to",
-                options: addons.map((a) => ({
-                    value: a.id,
-                    label: a.name || a.addonType,
-                    hint: a.addonType,
-                })),
-            });
-            if (p.isCancel(selected))
-                process.exit(5);
-            addon = addons.find((a) => a.id === selected);
-        }
-        if (!addon) {
-            throw new Error(`Service "${service}" not found`);
-        }
-        if (addon.status !== "running") {
-            throw new Error(`Service is ${addon.status}, not running`);
-        }
-        // Build connection string from secrets
-        const secrets = await api.get(`/api/projects/${projectId}/secrets`);
-        const connString = findConnectionString(addon.addonType, secrets);
-        if (opts.url || isJSONMode()) {
-            if (isJSONMode()) {
-                printJSON({ type: addon.addonType, connectionString: connString });
-            }
-            else {
-                console.log(connString || "Connection string not found in secrets");
-            }
-            return;
-        }
-        if (!connString) {
-            throw new Error("Connection string not found in project secrets. Check `lizard secret list --show`.");
-        }
-        // Connect using native client
-        const clientCmd = CLIENT_COMMANDS[addon.addonType];
-        if (!clientCmd) {
-            info(`Connection string: ${connString}`);
-            return;
-        }
-        info(chalk.dim(`Connecting via ${clientCmd}...\n`));
-        try {
-            if (addon.addonType === "postgres") {
-                execSync(`${clientCmd} "${connString}"`, { stdio: "inherit" });
-            }
-            else if (addon.addonType === "redis") {
-                // redis-cli -u redis://...
-                execSync(`${clientCmd} -u "${connString}"`, { stdio: "inherit" });
-            }
-            else if (addon.addonType === "mysql") {
-                execSync(`${clientCmd} "${connString}"`, { stdio: "inherit" });
-            }
-            else if (addon.addonType === "mongodb") {
-                execSync(`${clientCmd} "${connString}"`, { stdio: "inherit" });
-            }
-        }
-        catch (err) {
-            process.exit(err.status || 1);
-        }
-    });
-}
-function findConnectionString(type, secrets) {
-    const envKeys = {
-        postgres: ["DATABASE_URL", "POSTGRES_URL", "PG_URL"],
-        mysql: ["MYSQL_URL", "DATABASE_URL"],
-        mongodb: ["MONGODB_URL", "MONGO_URL"],
-        redis: ["REDIS_URL"],
-    };
-    const keys = envKeys[type] || [];
-    for (const key of keys) {
-        const s = secrets.find((s) => s.key === key);
-        if (s)
-            return s.value;
-    }
-    return null;
-}
-//# sourceMappingURL=connect.js.map

package/dist/commands/connect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"connect.js","sourceRoot":"","sources":["../../src/commands/connect.ts"],"names":[],"mappings":"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"}

package/dist/commands/context.d.ts

@@ -1,2 +0,0 @@
-import { Command } from "commander";
-export declare function registerContext(program: Command): void;