@launchfile/macos-dev 0.2.0 → 0.4.0

package/dist/__tests__/env-writer.test.js

@@ -1,201 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { buildResolverContext, computeAppProperties, resolveComponentEnv, generateSecrets, } from "../env-writer.js";
-const NO_APP = {};
-describe("buildResolverContext", () => {
-    it("builds context from resources, ports, secrets, and app properties", () => {
-        const resources = {
-            postgres: {
-                url: "postgresql://user:pass@localhost:5432/mydb",
-                host: "localhost",
-                port: 5432,
-                user: "user",
-                password: "pass",
-                name: "mydb",
-            },
-        };
-        const ports = { backend: 3000, frontend: 3001 };
-        const secrets = { "jwt-secret": "abc123" };
-        const app = { name: "my-app", host: "localhost", port: 3000, url: "http://localhost:3000" };
-        const ctx = buildResolverContext(resources, ports, secrets, app);
-        expect(ctx.components?.backend).toEqual({
-            url: "http://localhost:3000",
-            host: "localhost",
-            port: 3000,
-        });
-        expect(ctx.resources?.postgres?.url).toBe("postgresql://user:pass@localhost:5432/mydb");
-        expect(ctx.secrets?.["jwt-secret"]).toBe("abc123");
-        expect(ctx.app?.url).toBe("http://localhost:3000");
-        expect(ctx.app?.name).toBe("my-app");
-    });
-});
-describe("computeAppProperties (D-33)", () => {
-    const baseLaunch = (overrides) => ({
-        name: "my-app",
-        components: {},
-        ...overrides,
-    });
-    it("uses the first exposed component's port for $app.port and $app.url", () => {
-        const launch = baseLaunch({
-            components: {
-                default: {
-                    provides: [{ protocol: "http", port: 3000, exposed: true }],
-                },
-            },
-        });
-        const app = computeAppProperties(launch, { default: 10042 });
-        expect(app.name).toBe("my-app");
-        expect(app.host).toBe("localhost");
-        expect(app.port).toBe(10042);
-        expect(app.url).toBe("http://localhost:10042");
-    });
-    it("picks the first exposed component in declaration order for multi-component apps", () => {
-        const launch = baseLaunch({
-            components: {
-                api: {
-                    provides: [{ protocol: "http", port: 4000, exposed: true }],
-                },
-                worker: {
-                    provides: [],
-                },
-                ui: {
-                    provides: [{ protocol: "http", port: 5000, exposed: true }],
-                },
-            },
-        });
-        const app = computeAppProperties(launch, { api: 10043, ui: 10044 });
-        // Picks "api" because it's first in declaration order with exposed: true.
-        expect(app.port).toBe(10043);
-        expect(app.url).toBe("http://localhost:10043");
-    });
-    it("returns port 0 and empty url when no component is exposed", () => {
-        const launch = baseLaunch({
-            components: {
-                worker: {
-                    provides: [],
-                },
-            },
-        });
-        const app = computeAppProperties(launch, {});
-        expect(app.port).toBe(0);
-        expect(app.url).toBe("");
-        expect(app.name).toBe("my-app");
-    });
-    // End-to-end: a component env var that uses $app.url resolves to the
-    // computed app URL. This is the contract that makes Firefly III's
-    // `APP_URL: default: $app.url` actually work end-to-end on macos-dev.
-    it("$app.url in component env defaults resolves to the computed URL", () => {
-        const launch = baseLaunch({
-            components: {
-                default: {
-                    provides: [{ protocol: "http", port: 3000, exposed: true }],
-                    env: { PUBLIC_URL: { default: "$app.url" } },
-                },
-            },
-        });
-        const app = computeAppProperties(launch, { default: 10042 });
-        const ctx = buildResolverContext({}, { default: 10042 }, {}, app);
-        const env = resolveComponentEnv(launch.components.default, ctx, {});
-        expect(env.PUBLIC_URL).toBe("http://localhost:10042");
-    });
-});
-describe("resolveComponentEnv", () => {
-    it("resolves set_env from requires", () => {
-        const component = {
-            requires: [
-                {
-                    type: "postgres",
-                    set_env: {
-                        DATABASE_URL: "$url",
-                        DB_HOST: "$host",
-                    },
-                },
-            ],
-        };
-        const resourceMap = {
-            postgres: {
-                url: "postgresql://user:pass@localhost:5432/mydb",
-                host: "localhost",
-                port: 5432,
-            },
-        };
-        const context = buildResolverContext(resourceMap, {}, {}, NO_APP);
-        const env = resolveComponentEnv(component, context, resourceMap);
-        expect(env.DATABASE_URL).toBe("postgresql://user:pass@localhost:5432/mydb");
-        expect(env.DB_HOST).toBe("localhost");
-    });
-    it("resolves component-level env defaults", () => {
-        const component = {
-            env: {
-                PORT: { default: "8080" },
-                LOG_LEVEL: { default: "info" },
-            },
-        };
-        const context = buildResolverContext({}, {}, {}, NO_APP);
-        const env = resolveComponentEnv(component, context, {});
-        expect(env.PORT).toBe("8080");
-        expect(env.LOG_LEVEL).toBe("info");
-    });
-    it("resolves cross-component references", () => {
-        const component = {
-            env: {
-                BACKEND_URL: { default: "$components.backend.url" },
-            },
-        };
-        const context = buildResolverContext({}, { backend: 3000 }, {}, NO_APP);
-        const env = resolveComponentEnv(component, context, {});
-        expect(env.BACKEND_URL).toBe("http://localhost:3000");
-    });
-    it("resolves secrets references", () => {
-        const component = {
-            env: {
-                SECRET_KEY: { default: "$secrets.my-key" },
-            },
-        };
-        const context = buildResolverContext({}, {}, { "my-key": "super-secret" }, NO_APP);
-        const env = resolveComponentEnv(component, context, {});
-        expect(env.SECRET_KEY).toBe("super-secret");
-    });
-    it("set_env takes precedence over component env", () => {
-        const component = {
-            requires: [
-                {
-                    type: "postgres",
-                    set_env: { DATABASE_URL: "$url" },
-                },
-            ],
-            env: {
-                DATABASE_URL: { default: "fallback" },
-            },
-        };
-        const resourceMap = {
-            postgres: {
-                url: "postgresql://real-url",
-                host: "localhost",
-                port: 5432,
-            },
-        };
-        const context = buildResolverContext(resourceMap, {}, {}, NO_APP);
-        const env = resolveComponentEnv(component, context, resourceMap);
-        expect(env.DATABASE_URL).toBe("postgresql://real-url");
-    });
-});
-describe("generateSecrets", () => {
-    it("generates new secrets", async () => {
-        const defs = {
-            "jwt-secret": { generator: "secret" },
-            "app-uuid": { generator: "uuid" },
-        };
-        const secrets = await generateSecrets(defs, {});
-        expect(secrets["jwt-secret"]).toBeTruthy();
-        expect(secrets["app-uuid"]).toMatch(/^[0-9a-f-]+$/);
-    });
-    it("reuses existing secrets", async () => {
-        const defs = {
-            "jwt-secret": { generator: "secret" },
-        };
-        const existing = { "jwt-secret": "keep-this" };
-        const secrets = await generateSecrets(defs, existing);
-        expect(secrets["jwt-secret"]).toBe("keep-this");
-    });
-});
-//# sourceMappingURL=env-writer.test.js.map

package/dist/__tests__/lockfile-detect.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=lockfile-detect.test.d.ts.map

package/dist/__tests__/lockfile-detect.test.js

@@ -1,75 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { detectPackageManager } from "../lockfile-detect.js";
-import { mkdtemp, writeFile, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-describe("detectPackageManager", () => {
-    it("returns null for empty directory", async () => {
-        const dir = await mkdtemp(join(tmpdir(), "lf-test-"));
-        try {
-            const pm = await detectPackageManager(dir);
-            expect(pm).toBeNull();
-        }
-        finally {
-            await rm(dir, { recursive: true });
-        }
-    });
-    it("detects bun from bun.lockb", async () => {
-        const dir = await mkdtemp(join(tmpdir(), "lf-test-"));
-        try {
-            await writeFile(join(dir, "bun.lockb"), "");
-            const pm = await detectPackageManager(dir);
-            expect(pm?.name).toBe("bun");
-            expect(pm?.installCommand).toBe("bun install");
-        }
-        finally {
-            await rm(dir, { recursive: true });
-        }
-    });
-    it("detects yarn from yarn.lock", async () => {
-        const dir = await mkdtemp(join(tmpdir(), "lf-test-"));
-        try {
-            await writeFile(join(dir, "yarn.lock"), "");
-            const pm = await detectPackageManager(dir);
-            expect(pm?.name).toBe("yarn");
-        }
-        finally {
-            await rm(dir, { recursive: true });
-        }
-    });
-    it("detects pnpm from pnpm-lock.yaml", async () => {
-        const dir = await mkdtemp(join(tmpdir(), "lf-test-"));
-        try {
-            await writeFile(join(dir, "pnpm-lock.yaml"), "");
-            const pm = await detectPackageManager(dir);
-            expect(pm?.name).toBe("pnpm");
-        }
-        finally {
-            await rm(dir, { recursive: true });
-        }
-    });
-    it("detects bundler from Gemfile.lock", async () => {
-        const dir = await mkdtemp(join(tmpdir(), "lf-test-"));
-        try {
-            await writeFile(join(dir, "Gemfile.lock"), "");
-            const pm = await detectPackageManager(dir);
-            expect(pm?.name).toBe("bundler");
-        }
-        finally {
-            await rm(dir, { recursive: true });
-        }
-    });
-    it("prefers bun over yarn when both present", async () => {
-        const dir = await mkdtemp(join(tmpdir(), "lf-test-"));
-        try {
-            await writeFile(join(dir, "bun.lockb"), "");
-            await writeFile(join(dir, "yarn.lock"), "");
-            const pm = await detectPackageManager(dir);
-            expect(pm?.name).toBe("bun");
-        }
-        finally {
-            await rm(dir, { recursive: true });
-        }
-    });
-});
-//# sourceMappingURL=lockfile-detect.test.js.map

package/dist/__tests__/port-allocator.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=port-allocator.test.d.ts.map

package/dist/__tests__/port-allocator.test.js

@@ -1,53 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { allocatePort, allocatePorts } from "../port-allocator.js";
-describe("allocatePort", () => {
-    it("returns a port in the expected range", async () => {
-        const port = await allocatePort("test-app", new Set());
-        expect(port).toBeGreaterThanOrEqual(10_000);
-        expect(port).toBeLessThan(20_000);
-    });
-    it("is deterministic for the same key", async () => {
-        const port1 = await allocatePort("my-app", new Set());
-        const port2 = await allocatePort("my-app", new Set());
-        expect(port1).toBe(port2);
-    });
-    it("avoids ports already in use", async () => {
-        const port1 = await allocatePort("collision-test", new Set());
-        const port2 = await allocatePort("collision-test", new Set([port1]));
-        expect(port2).not.toBe(port1);
-    });
-    it("produces different ports for different keys", async () => {
-        const port1 = await allocatePort("app-a", new Set());
-        const port2 = await allocatePort("app-b", new Set());
-        // Not guaranteed but overwhelmingly likely for different inputs
-        expect(port1).not.toBe(port2);
-    });
-});
-describe("allocatePorts", () => {
-    it("allocates ports for all components", async () => {
-        const components = {
-            backend: { provides: [{ port: 3000 }] },
-            frontend: { provides: [{ port: 3001 }] },
-        };
-        const ports = await allocatePorts(components, "test-app");
-        expect(ports.backend).toBeDefined();
-        expect(ports.frontend).toBeDefined();
-        expect(ports.backend).not.toBe(ports.frontend);
-    });
-    it("prefers the declared port if free", async () => {
-        const components = {
-            api: { provides: [{ port: 4567 }] },
-        };
-        const ports = await allocatePorts(components, "test-app");
-        expect(ports.api).toBe(4567);
-    });
-    it("reuses saved ports when available", async () => {
-        const components = {
-            api: { provides: [{ port: 3000 }] },
-        };
-        const saved = { api: 9876 };
-        const ports = await allocatePorts(components, "test-app", saved);
-        expect(ports.api).toBe(9876);
-    });
-});
-//# sourceMappingURL=port-allocator.test.js.map

package/dist/__tests__/secret-generator.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=secret-generator.test.d.ts.map

package/dist/__tests__/secret-generator.test.js

@@ -1,26 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { generateValue, generatePassword } from "../secret-generator.js";
-describe("generateValue", () => {
-    it("generates a base64url secret", async () => {
-        const value = await generateValue("secret");
-        expect(value).toMatch(/^[A-Za-z0-9_-]+$/);
-        expect(value.length).toBeGreaterThan(20);
-    });
-    it("generates a UUID", async () => {
-        const value = await generateValue("uuid");
-        expect(value).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
-    });
-    it("generates unique values each time", async () => {
-        const a = await generateValue("secret");
-        const b = await generateValue("secret");
-        expect(a).not.toBe(b);
-    });
-});
-describe("generatePassword", () => {
-    it("generates a URL-safe password", () => {
-        const pw = generatePassword();
-        expect(pw).toMatch(/^[A-Za-z0-9_-]+$/);
-        expect(pw.length).toBeGreaterThan(10);
-    });
-});
-//# sourceMappingURL=secret-generator.test.js.map

package/dist/__tests__/state.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=state.test.d.ts.map

package/dist/__tests__/state.test.js

@@ -1,30 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { initState, hashLaunchfile } from "../state.js";
-describe("initState", () => {
-    it("creates a state with correct app name", () => {
-        const state = initState("my-app", "name: my-app");
-        expect(state.appName).toBe("my-app");
-        expect(state.version).toBe(1);
-        expect(state.resources).toEqual({});
-        expect(state.secrets).toEqual({});
-        expect(state.ports).toEqual({});
-    });
-    it("hashes launchfile content", () => {
-        const state = initState("app", "some yaml content");
-        expect(state.launchfileHash).toBeTruthy();
-        expect(state.launchfileHash.length).toBe(16);
-    });
-});
-describe("hashLaunchfile", () => {
-    it("is deterministic", () => {
-        const a = hashLaunchfile("hello");
-        const b = hashLaunchfile("hello");
-        expect(a).toBe(b);
-    });
-    it("differs for different content", () => {
-        const a = hashLaunchfile("hello");
-        const b = hashLaunchfile("world");
-        expect(a).not.toBe(b);
-    });
-});
-//# sourceMappingURL=state.test.js.map