@lotics/cli 0.71.0 → 0.74.0

package/dist/package_commands.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/package_commands.test.js

@@ -0,0 +1,303 @@
+import { describe, it, expect } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import { parseAppPackageContract, validateAppPackageContract, } from "@lotics/shared/schemas/app_packages";
+import { starterContract, readPackageProject, writePackageManifest, sanitizePackageJsonForSource, stagePackageSource, parseResolveFlags, assertDevWorkspace, draftPackageProjectFromApp, parseAdoptBindingFile, formatExtractReport, } from "./package_commands.js";
+describe("starterContract", () => {
+    it("scaffolds a structurally + referentially valid contract", () => {
+        const raw = starterContract("Acme CRM");
+        // Structurally valid against the canonical contract schema.
+        const contract = parseAppPackageContract(raw);
+        // Cross-references (query from_entity, etc.) resolve — zero violations, so the
+        // scaffold publishes without the server's contract validator rejecting it.
+        expect(validateAppPackageContract(contract)).toEqual([]);
+    });
+    it("uses the package name as the entity label", () => {
+        const contract = parseAppPackageContract(starterContract("Widgets"));
+        expect(contract.entities[0].label).toBe("Widgets");
+        expect(contract.config[0].default).toBe("Widgets");
+    });
+});
+describe("package manifest round-trip", () => {
+    function makeProject() {
+        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-pkg-test-"));
+        fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({
+            name: "acme-crm",
+            version: "0.0.1",
+            lotics: {
+                package: { id: null, name: "Acme CRM", description: null, version: null, dev: {} },
+            },
+        }, null, 2) + "\n");
+        return dir;
+    }
+    it("reads the package manifest off package.json#lotics.package", () => {
+        const dir = makeProject();
+        try {
+            const { manifest } = readPackageProject(dir);
+            expect(manifest).toEqual({
+                id: null,
+                name: "Acme CRM",
+                description: null,
+                version: null,
+                dev: {},
+            });
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("persists publish + dev-installation pins and reads them back", () => {
+        const dir = makeProject();
+        try {
+            const project = readPackageProject(dir);
+            project.manifest.id = "apg_test";
+            project.manifest.version = 3;
+            project.manifest.dev["wsp_dev"] = { app_id: "app_dev", version: 3 };
+            writePackageManifest(dir, project);
+            const reread = readPackageProject(dir);
+            expect(reread.manifest.id).toBe("apg_test");
+            expect(reread.manifest.version).toBe(3);
+            expect(reread.manifest.dev).toEqual({ wsp_dev: { app_id: "app_dev", version: 3 } });
+            // Non-lotics package.json fields survive the manifest write.
+            expect(reread.pkgJson.name).toBe("acme-crm");
+            expect(reread.pkgJson.version).toBe("0.0.1");
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("writes the manifest atomically, leaving no temp file behind", () => {
+        const dir = makeProject();
+        try {
+            const project = readPackageProject(dir);
+            project.manifest.id = "apg_atomic";
+            writePackageManifest(dir, project);
+            // The atomic write renames a temp file into place; nothing stray remains.
+            const leftovers = fs.readdirSync(dir).filter((f) => f.startsWith("package.json."));
+            expect(leftovers).toEqual([]);
+            expect(readPackageProject(dir).manifest.id).toBe("apg_atomic");
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("sanitizePackageJsonForSource", () => {
+    it("strips the author-local lotics.package.dev map", () => {
+        const sanitized = sanitizePackageJsonForSource({
+            name: "acme-crm",
+            version: "0.0.1",
+            lotics: {
+                package: {
+                    id: "apg_x",
+                    name: "Acme CRM",
+                    description: "d",
+                    version: 4,
+                    dev: { wsp_dev: { app_id: "app_dev", version: 4 } },
+                },
+            },
+        });
+        const lotics = sanitized.lotics;
+        // The private dev bookkeeping is gone…
+        expect("dev" in lotics.package).toBe(false);
+        // …while the package identity + other fields survive untouched.
+        expect(lotics.package).toEqual({
+            id: "apg_x",
+            name: "Acme CRM",
+            description: "d",
+            version: 4,
+        });
+        expect(sanitized.name).toBe("acme-crm");
+        expect(sanitized.version).toBe("0.0.1");
+    });
+    it("does not mutate the input package.json", () => {
+        const input = {
+            name: "acme-crm",
+            lotics: { package: { id: "apg_x", name: "Acme CRM", dev: { wsp_dev: { app_id: "a", version: 1 } } } },
+        };
+        sanitizePackageJsonForSource(input);
+        expect(input.lotics.package.dev).toEqual({ wsp_dev: { app_id: "a", version: 1 } });
+    });
+});
+describe("assertDevWorkspace", () => {
+    it("passes a dev workspace", () => {
+        expect(() => assertDevWorkspace({ id: "wsp_d", name: "Dev", is_dev: true })).not.toThrow();
+    });
+    it("fails loud on a non-dev workspace", () => {
+        expect(() => assertDevWorkspace({ id: "wsp_p", name: "Prod", is_dev: false })).toThrow(/not a dev workspace/);
+    });
+    it("fails closed when is_dev is absent (server doesn't serialize it)", () => {
+        expect(() => assertDevWorkspace({ id: "wsp_u", name: "Unknown" })).toThrow(/not a dev workspace/);
+    });
+    it("rejects a directory that is not a package project", () => {
+        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-pkg-test-"));
+        try {
+            fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name: "plain-app" }));
+            expect(() => readPackageProject(dir)).toThrow(/not a package project/);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("parseResolveFlags", () => {
+    it("maps 'recreate' and ids to their resolution shapes", () => {
+        expect(parseResolveFlags(["fields.deal.stage=recreate", "templates.quote=dtl_abc"])).toEqual({
+            "fields.deal.stage": "recreate",
+            "templates.quote": { bind_to: "dtl_abc" },
+        });
+    });
+    it("maps modified-core consents 'revert' and 'keep' as literals", () => {
+        expect(parseResolveFlags(["queries.tasks=revert", "workflows.notify=keep"])).toEqual({
+            "queries.tasks": "revert",
+            "workflows.notify": "keep",
+        });
+    });
+    it("rejects entries without a key=value shape", () => {
+        expect(() => parseResolveFlags(["fields.deal.stage"])).toThrow(/Invalid --resolve/);
+        expect(() => parseResolveFlags(["=recreate"])).toThrow(/Invalid --resolve/);
+        expect(() => parseResolveFlags(["fields.deal.stage="])).toThrow(/Invalid --resolve/);
+    });
+});
+describe("draftPackageProjectFromApp", () => {
+    it("strips the app manifest and grafts an unpublished package manifest", () => {
+        const project = draftPackageProjectFromApp({
+            name: "acme-crm",
+            version: "0.0.1",
+            dependencies: { "@lotics/app-sdk": "^1.0.0" },
+            lotics: {
+                app_id: "app_x",
+                workspace_id: "wsp_y",
+                current_version_id: "apv_z",
+                workflows: { notify: { workflow_id: "wfl_1" } },
+            },
+        }, { name: "Acme CRM", description: null });
+        // The app manifest (app_id/workspace_id/workflows) is gone entirely…
+        expect("lotics" in project.pkgJson).toBe(false);
+        // …the package manifest is fresh + unpublished…
+        expect(project.manifest).toEqual({
+            id: null,
+            name: "Acme CRM",
+            description: null,
+            version: null,
+            dev: {},
+        });
+        // …and non-lotics fields survive verbatim.
+        expect(project.pkgJson.name).toBe("acme-crm");
+        expect(project.pkgJson.version).toBe("0.0.1");
+        expect(project.pkgJson.dependencies).toEqual({ "@lotics/app-sdk": "^1.0.0" });
+    });
+    it("round-trips through writePackageManifest to a valid package project on disk", () => {
+        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-pkg-test-"));
+        try {
+            writePackageManifest(dir, draftPackageProjectFromApp({ name: "acme-crm", lotics: { app_id: "app_x", workspace_id: "wsp_y" } }, { name: "Acme CRM", description: "A CRM" }));
+            // readPackageProject only accepts a real package project (lotics.package).
+            const { manifest, pkgJson } = readPackageProject(dir);
+            expect(manifest).toEqual({
+                id: null,
+                name: "Acme CRM",
+                description: "A CRM",
+                version: null,
+                dev: {},
+            });
+            // The old app manifest keys never made it to disk.
+            const lotics = pkgJson.lotics;
+            expect("app_id" in lotics).toBe(false);
+            expect("workspace_id" in lotics).toBe(false);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("does not mutate the input package.json", () => {
+        const input = { name: "acme-crm", lotics: { app_id: "app_x", workspace_id: "wsp_y" } };
+        draftPackageProjectFromApp(input, { name: "Acme CRM", description: null });
+        expect(input.lotics).toEqual({ app_id: "app_x", workspace_id: "wsp_y" });
+    });
+});
+describe("parseAdoptBindingFile", () => {
+    const validPin = {
+        app_id: "app_x",
+        workspace_id: "wsp_y",
+        binding: { entities: { item: "tbl_1" }, fields: {}, options: {}, templates: {}, roles: {}, workflows: {} },
+    };
+    it("accepts a pin whose app_id matches the app being adopted", () => {
+        const pin = parseAdoptBindingFile(validPin, "app_x");
+        expect(pin.app_id).toBe("app_x");
+        expect(pin.workspace_id).toBe("wsp_y");
+        expect(pin.binding.entities).toEqual({ item: "tbl_1" });
+    });
+    it("REFUSES a pin recorded for a different app", () => {
+        expect(() => parseAdoptBindingFile(validPin, "app_OTHER")).toThrow(/records app app_x, but you are adopting app_OTHER/);
+    });
+    it("rejects a malformed pin", () => {
+        expect(() => parseAdoptBindingFile({ app_id: "app_x" }, "app_x")).toThrow(/Malformed/);
+        expect(() => parseAdoptBindingFile(null, "app_x")).toThrow(/Malformed/);
+        expect(() => parseAdoptBindingFile({ app_id: "app_x", workspace_id: "wsp_y" }, "app_x")).toThrow(/Malformed/);
+    });
+});
+describe("formatExtractReport", () => {
+    it("groups findings errors → warnings → info and formats each line", () => {
+        const { lines, hasError } = formatExtractReport([
+            { severity: "info", area: "queries.items", message: "inverted cleanly" },
+            { severity: "error", area: "fields.deal.stage", message: "button field is not portable" },
+            { severity: "warning", area: "workflows.notify", message: "legacy key retained" },
+            { severity: "error", area: "queries.deals", message: "round-trip mismatch" },
+        ]);
+        expect(lines).toEqual([
+            "  [error] fields.deal.stage: button field is not portable",
+            "  [error] queries.deals: round-trip mismatch",
+            "  [warning] workflows.notify: legacy key retained",
+            "  [info] queries.items: inverted cleanly",
+        ]);
+        expect(hasError).toBe(true);
+    });
+    it("reports no error when only warnings/info are present", () => {
+        const { lines, hasError } = formatExtractReport([
+            { severity: "warning", area: "a", message: "w" },
+            { severity: "info", area: "b", message: "i" },
+        ]);
+        expect(lines).toEqual(["  [warning] a: w", "  [info] b: i"]);
+        expect(hasError).toBe(false);
+    });
+    it("handles an empty report", () => {
+        expect(formatExtractReport([])).toEqual({ lines: [], hasError: false });
+    });
+});
+describe("stagePackageSource", () => {
+    it("keeps nested dist-named dirs, drops top-level excludes, sanitizes package.json", () => {
+        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-stage-test-"));
+        const stage = fs.mkdtempSync(path.join(tmpdir(), "lotics-stage-out-"));
+        try {
+            fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({
+                name: "pkg",
+                lotics: { package: { id: "apg_x", name: "pkg", version: 3, dev: { wsp_a: "app_1" } } },
+            }));
+            fs.mkdirSync(path.join(dir, "src"));
+            fs.writeFileSync(path.join(dir, "src", "main.tsx"), "export {}");
+            // A nested dir NAMED dist must ship — only the top-level dist is a build output.
+            fs.mkdirSync(path.join(dir, "templates", "dist"), { recursive: true });
+            fs.writeFileSync(path.join(dir, "templates", "dist", "quote.xlsx"), "bytes");
+            fs.mkdirSync(path.join(dir, "dist"));
+            fs.writeFileSync(path.join(dir, "dist", "index.js"), "built");
+            fs.mkdirSync(path.join(dir, "node_modules", "x"), { recursive: true });
+            fs.writeFileSync(path.join(dir, "node_modules", "x", "i.js"), "dep");
+            fs.writeFileSync(path.join(dir, "tsconfig.tsbuildinfo"), "{}");
+            stagePackageSource(dir, stage);
+            expect(fs.existsSync(path.join(stage, "src", "main.tsx"))).toBe(true);
+            expect(fs.existsSync(path.join(stage, "templates", "dist", "quote.xlsx"))).toBe(true);
+            expect(fs.existsSync(path.join(stage, "dist"))).toBe(false);
+            expect(fs.existsSync(path.join(stage, "node_modules"))).toBe(false);
+            expect(fs.existsSync(path.join(stage, "tsconfig.tsbuildinfo"))).toBe(false);
+            // The staged package.json is the sanitized one — dev pins stripped.
+            const staged = JSON.parse(fs.readFileSync(path.join(stage, "package.json"), "utf-8"));
+            expect(staged.lotics.package.dev).toBeUndefined();
+            expect(staged.lotics.package.id).toBe("apg_x");
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+            fs.rmSync(stage, { recursive: true, force: true });
+        }
+    });
+});