puls-dev 0.2.8 → 0.3.0

package/dist/core/checker.js

@@ -123,6 +123,53 @@ function renderAws(inv) {
         ]);
     }
 }
+function renderGcp(inv) {
+    if (inv.vms.length > 0) {
+        printSection(`GCP Compute VMs  ·  ${inv.vms.length}`, inv.vms, [
+            { header: "Name", width: 24, render: (v) => v.name },
+            { header: "Zone", width: 15, render: (v) => v.zone },
+            { header: "Machine Type", width: 14, render: (v) => v.machineType },
+            { header: "Status", width: 8, render: (v) => v.status },
+            { header: "IP", width: 15, render: (v) => v.ip },
+        ]);
+    }
+    if (inv.rdsInstances.length > 0) {
+        printSection(`GCP Cloud SQL  ·  ${inv.rdsInstances.length}`, inv.rdsInstances, [
+            { header: "Name", width: 24, render: (i) => i.name },
+            { header: "Engine", width: 18, render: (i) => i.engine },
+            { header: "Tier", width: 12, render: (i) => i.tier },
+            { header: "Status", width: 10, render: (i) => i.status },
+        ]);
+    }
+    if (inv.distributions.length > 0) {
+        printSection(`GCP Cloud Run  ·  ${inv.distributions.length}`, inv.distributions, [
+            { header: "Service", width: 24, render: (s) => s.name },
+            { header: "Region", width: 12, render: (s) => s.region },
+            { header: "URL", width: 42, render: (s) => s.url },
+        ]);
+    }
+    if (inv.hostedZones.length > 0) {
+        printSection(`GCP Cloud DNS  ·  ${inv.hostedZones.length}`, inv.hostedZones, [
+            { header: "Zone", width: 24, render: (z) => z.name },
+            { header: "DNS Name", width: 32, render: (z) => z.dnsName },
+        ]);
+    }
+}
+function renderFirebase(inv) {
+    if (inv.hostingSites.length > 0) {
+        printSection(`Firebase Hosting  ·  ${inv.hostingSites.length}`, inv.hostingSites, [
+            { header: "Site ID", width: 32, render: (s) => s.site },
+        ]);
+    }
+    if (inv.functions.length > 0) {
+        printSection(`Firebase Functions  ·  ${inv.functions.length}`, inv.functions, [
+            { header: "Function", width: 24, render: (f) => f.name },
+            { header: "Region", width: 12, render: (f) => f.region },
+            { header: "Entry Point", width: 18, render: (f) => f.entryPoint },
+            { header: "Runtime", width: 10, render: (f) => f.runtime },
+        ]);
+    }
+}
 // ─── Checker ──────────────────────────────────────────────────────────────────
 export class Checker {
     async check() {
@@ -161,6 +208,26 @@ export class Checker {
                 errors.push({ provider: "aws", message: err.message });
             }));
         }
+        if (cfg.providers.gcp?.serviceAccountPath || process.env.GCP_SA) {
+            tasks.push(import("../providers/gcp/list.js")
+                .then((m) => m.listGcpResources())
+                .then((inv) => {
+                result.gcp = inv;
+            })
+                .catch((err) => {
+                errors.push({ provider: "gcp", message: err.message });
+            }));
+        }
+        if (cfg.providers.firebase?.serviceAccountPath || process.env.FIREBASE_SA) {
+            tasks.push(import("../providers/firebase/list.js")
+                .then((m) => m.listFirebaseResources())
+                .then((inv) => {
+                result.firebase = inv;
+            })
+                .catch((err) => {
+                errors.push({ provider: "firebase", message: err.message });
+            }));
+        }
         await Promise.all(tasks);
         if (result.proxmox)
             renderProxmox(result.proxmox);
@@ -168,6 +235,10 @@ export class Checker {
             renderDo(result.do);
         if (result.aws)
             renderAws(result.aws);
+        if (result.gcp)
+            renderGcp(result.gcp);
+        if (result.firebase)
+            renderFirebase(result.firebase);
         for (const e of errors) {
             console.warn(`\n  [!] ${e.provider}: ${e.message}`);
         }

package/dist/core/config.d.ts

@@ -1,5 +1,8 @@
+import "dotenv/config";
 export interface GlobalConfig {
     dryRun?: boolean;
+    parallel?: boolean;
+    offline?: boolean;
     providers: {
         do?: {
             token: string;
@@ -37,6 +40,8 @@ declare class ConfigManager {
     set(newConfig: Partial<GlobalConfig>): void;
     get(): GlobalConfig;
     isGlobalDryRun(): boolean;
+    isParallelActive(): boolean;
+    isOfflineMode(): boolean;
 }
 export declare const Config: ConfigManager;
 export {};

package/dist/core/config.js

@@ -1,9 +1,14 @@
+import "dotenv/config";
 class ConfigManager {
     config = {
         providers: {},
     };
     set(newConfig) {
-        this.config = { ...this.config, ...newConfig };
+        this.config = {
+            ...this.config,
+            ...newConfig,
+            providers: { ...this.config.providers, ...newConfig.providers },
+        };
     }
     get() {
         return this.config;
@@ -11,5 +16,11 @@ class ConfigManager {
     isGlobalDryRun() {
         return this.config.dryRun ?? false;
     }
+    isParallelActive() {
+        return this.config.parallel ?? false;
+    }
+    isOfflineMode() {
+        return this.config.offline ?? false;
+    }
 }
 export const Config = new ConfigManager();

package/dist/core/context.d.ts

@@ -0,0 +1,14 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export interface HostEntry {
+    name: string;
+    ip: string;
+    user: string;
+    sshKey?: string;
+    provider: string;
+}
+export interface ResourceContext {
+    abortSignal?: AbortSignal;
+    hosts?: HostEntry[];
+    stackName?: string;
+}
+export declare const resourceContextStorage: AsyncLocalStorage<ResourceContext>;

package/dist/core/context.js

@@ -0,0 +1,2 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export const resourceContextStorage = new AsyncLocalStorage();

package/dist/core/decorators.d.ts

@@ -4,6 +4,8 @@ type ProviderOpts = {
     region?: string;
     regions?: string[];
     dryRun?: boolean;
+    parallel?: boolean;
+    offline?: boolean;
     firebase?: string;
     proxmox?: {
         url: string;

package/dist/core/decorators.js

@@ -5,27 +5,21 @@ import { Stack } from "./stack.js";
 function applyConfig(opts) {
     if (opts.dryRun !== undefined)
         Config.set({ dryRun: opts.dryRun });
+    if (opts.parallel !== undefined)
+        Config.set({ parallel: opts.parallel });
+    if (opts.offline !== undefined)
+        Config.set({ offline: opts.offline });
     if (opts.token)
-        Config.set({
-            providers: { ...Config.get().providers, do: { token: opts.token } },
-        });
+        Config.set({ providers: { do: { token: opts.token } } });
     if (opts.region)
-        Config.set({
-            providers: { ...Config.get().providers, aws: { region: opts.region } },
-        });
+        Config.set({ providers: { aws: { region: opts.region } } });
     if (opts.proxmox)
-        Config.set({
-            providers: { ...Config.get().providers, proxmox: opts.proxmox },
-        });
+        Config.set({ providers: { proxmox: opts.proxmox } });
     if (opts.firebase) {
         const sa = JSON.parse(readFileSync(opts.firebase, "utf8"));
         Config.set({
             providers: {
-                ...Config.get().providers,
-                firebase: {
-                    projectId: sa.project_id,
-                    serviceAccountPath: opts.firebase,
-                },
+                firebase: { projectId: sa.project_id, serviceAccountPath: opts.firebase },
             },
         });
     }

package/dist/core/group.test.d.ts

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

package/dist/core/group.test.js

@@ -0,0 +1,94 @@
+import { test, describe } from "node:test";
+import assert from "node:assert";
+import { BaseBuilder, createBuilderArray } from "./resource.js";
+import { Stack } from "./stack.js";
+import { Config } from "./config.js";
+class MockResourceBuilder extends BaseBuilder {
+    val = 0;
+    strVal = "";
+    deployCount = 0;
+    destroyCount = 0;
+    constructor(name) {
+        super(name);
+    }
+    setVal(n) {
+        // Overloaded to support array assignment in proxy test
+        if (typeof n === "number") {
+            this.val = n;
+        }
+        return this;
+    }
+    setStr(s) {
+        if (typeof s === "string") {
+            this.strVal = s;
+        }
+        return this;
+    }
+    async deploy() {
+        this.deployCount++;
+        return { name: this.name, val: this.val, strVal: this.strVal };
+    }
+    async destroy() {
+        this.destroyCount++;
+        return { destroyedName: this.name };
+    }
+}
+describe("Resource Builder Groups Unit Tests", () => {
+    test("createBuilderArray proxies and chains methods", () => {
+        const b1 = new MockResourceBuilder("r1");
+        const b2 = new MockResourceBuilder("r2");
+        const group = createBuilderArray([b1, b2]);
+        // Test method chaining and uniform distribution
+        group.setVal(42).setStr("hello");
+        assert.strictEqual(b1.val, 42);
+        assert.strictEqual(b2.val, 42);
+        assert.strictEqual(b1.strVal, "hello");
+        assert.strictEqual(b2.strVal, "hello");
+    });
+    test("createBuilderArray distributes array arguments by index", () => {
+        const b1 = new MockResourceBuilder("r1");
+        const b2 = new MockResourceBuilder("r2");
+        const group = createBuilderArray([b1, b2]);
+        // Test index-based distribution
+        group.setVal([10, 20]).setStr(["first", "second"]);
+        // In MockResourceBuilder, calling setVal with [10, 20] gets distributed by proxy:
+        // b1 gets setVal(10) -> val = 10
+        // b2 gets setVal(20) -> val = 20
+        assert.strictEqual(b1.val, 10);
+        assert.strictEqual(b2.val, 20);
+        assert.strictEqual(b1.strVal, "first");
+        assert.strictEqual(b2.strVal, "second");
+    });
+    test("Stack deploy gathers array builders and structures outputs as array", async () => {
+        Config.set({ dryRun: false });
+        const b1 = new MockResourceBuilder("s1");
+        const b2 = new MockResourceBuilder("s2");
+        class ArrayStack extends Stack {
+            servers = createBuilderArray([b1, b2]).setVal([100, 200]);
+        }
+        const stack = new ArrayStack();
+        const result = await stack.deploy();
+        assert.strictEqual(b1.deployCount, 1);
+        assert.strictEqual(b2.deployCount, 1);
+        assert.ok(Array.isArray(result.servers));
+        assert.strictEqual(result.servers.length, 2);
+        assert.deepStrictEqual(result.servers[0], { name: "s1", val: 100, strVal: "" });
+        assert.deepStrictEqual(result.servers[1], { name: "s2", val: 200, strVal: "" });
+    });
+    test("Stack destroy gathers array builders and structures outputs as array", async () => {
+        Config.set({ dryRun: false });
+        const b1 = new MockResourceBuilder("s1");
+        const b2 = new MockResourceBuilder("s2");
+        class ArrayStack extends Stack {
+            servers = createBuilderArray([b1, b2]);
+        }
+        const stack = new ArrayStack();
+        const result = await stack.destroy();
+        assert.strictEqual(b1.destroyCount, 1);
+        assert.strictEqual(b2.destroyCount, 1);
+        assert.ok(Array.isArray(result.servers));
+        assert.strictEqual(result.servers.length, 2);
+        assert.deepStrictEqual(result.servers[0], { destroyedName: "s1" });
+        assert.deepStrictEqual(result.servers[1], { destroyedName: "s2" });
+    });
+});

package/dist/core/parallel.test.d.ts

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

package/dist/core/parallel.test.js

@@ -0,0 +1,215 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { test, describe, beforeEach } from "node:test";
+import assert from "node:assert";
+import { Stack } from "./stack.js";
+import { Deploy } from "./decorators.js";
+import { BaseBuilder } from "./resource.js";
+import { Config } from "./config.js";
+import { Output } from "./output.js";
+// Helper delay
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class DelayResource extends BaseBuilder {
+    delayMs;
+    executionLogs;
+    out = {
+        val: new Output(),
+    };
+    constructor(name, delayMs, executionLogs) {
+        super(name);
+        this.delayMs = delayMs;
+        this.executionLogs = executionLogs;
+    }
+    async deploy() {
+        this.executionLogs.push(`start:${this.name}`);
+        await delay(this.delayMs);
+        this.executionLogs.push(`end:${this.name}`);
+        this.out.val.resolve(this.name);
+        return { name: this.name };
+    }
+    async destroy() {
+        this.executionLogs.push(`destroy:${this.name}`);
+        await delay(this.delayMs);
+        return { name: this.name, destroyed: true };
+    }
+}
+class FailResource extends BaseBuilder {
+    async deploy() {
+        throw new Error("Failed to deploy!");
+    }
+}
+describe("Parallel Resource Deployment Unit Tests", () => {
+    let logs = [];
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            parallel: false,
+            providers: {},
+        });
+        logs = [];
+    });
+    test("runs sequential deployments by default (verifies base case)", async () => {
+        class SeqStack extends Stack {
+            r1 = new DelayResource("r1", 30, logs);
+            r2 = new DelayResource("r2", 30, logs);
+        }
+        const start = Date.now();
+        const stack = new SeqStack();
+        await stack.deploy();
+        const duration = Date.now() - start;
+        // In sequential, execution is r1 start -> r1 end -> r2 start -> r2 end
+        assert.deepStrictEqual(logs, [
+            "start:r1",
+            "end:r1",
+            "start:r2",
+            "end:r2"
+        ]);
+        assert.ok(duration >= 60, `Sequential should take at least 60ms, took ${duration}ms`);
+    });
+    test("runs parallel deployments concurrently when opted in", async () => {
+        // Enable parallel globally for the stack run
+        Config.set({
+            dryRun: false,
+            parallel: true,
+            providers: {},
+        });
+        class ParStack extends Stack {
+            r1 = new DelayResource("r1", 40, logs);
+            r2 = new DelayResource("r2", 40, logs);
+        }
+        const start = Date.now();
+        const stack = new ParStack();
+        await stack.deploy();
+        const duration = Date.now() - start;
+        // In parallel, both start before either finishes:
+        // start:r1 and start:r2 will both be printed first.
+        assert.strictEqual(logs[0].startsWith("start:"), true);
+        assert.strictEqual(logs[1].startsWith("start:"), true);
+        assert.ok(logs.includes("end:r1"));
+        assert.ok(logs.includes("end:r2"));
+        // Total duration should be closer to 40ms than 80ms
+        assert.ok(duration < 75, `Parallel should take less than 75ms (sum), took ${duration}ms`);
+    });
+    test("respects explicit dependsOn() ordering in parallel mode", async () => {
+        Config.set({
+            dryRun: false,
+            parallel: true,
+            providers: {},
+        });
+        class DependencyStack extends Stack {
+            // r1 depends on r2
+            r1 = new DelayResource("r1", 20, logs);
+            r2 = new DelayResource("r2", 20, logs);
+            constructor() {
+                super();
+                this.r1.dependsOn(this.r2);
+            }
+        }
+        const stack = new DependencyStack();
+        await stack.deploy();
+        // Since r1 depends on r2, r2 must fully complete before r1 starts
+        const r2StartIndex = logs.indexOf("start:r2");
+        const r2EndIndex = logs.indexOf("end:r2");
+        const r1StartIndex = logs.indexOf("start:r1");
+        assert.ok(r2StartIndex < r2EndIndex);
+        assert.ok(r2EndIndex < r1StartIndex);
+    });
+    test("respects implicit Output waiting in parallel mode", async () => {
+        Config.set({
+            dryRun: false,
+            parallel: true,
+            providers: {},
+        });
+        class OutputAwaitingResource extends BaseBuilder {
+            dependentVal;
+            executionLogs;
+            constructor(name, dependentVal, executionLogs) {
+                super(name);
+                this.dependentVal = dependentVal;
+                this.executionLogs = executionLogs;
+            }
+            async deploy() {
+                this.executionLogs.push(`start:${this.name}`);
+                // Blocks on the Output of the other resource!
+                const val = await this.dependentVal.get();
+                this.executionLogs.push(`end:${this.name}:${val}`);
+                return { name: this.name };
+            }
+        }
+        class OutputStack extends Stack {
+            r1 = new DelayResource("r1", 30, logs);
+            // r2 depends implicitly on r1's output
+            r2 = new OutputAwaitingResource("r2", this.r1.out.val, logs);
+        }
+        const stack = new OutputStack();
+        await stack.deploy();
+        // r2 starts in parallel, but it cannot end until r1 finishes and resolves the output
+        const r2StartIndex = logs.indexOf("start:r2");
+        const r1EndIndex = logs.indexOf("end:r1");
+        const r2EndIndex = logs.findIndex(line => line.startsWith("end:r2"));
+        assert.ok(r2StartIndex >= 0);
+        assert.ok(r1EndIndex >= 0);
+        assert.ok(r1EndIndex < r2EndIndex, `r1 end (${r1EndIndex}) must be before r2 end (${r2EndIndex})`);
+        assert.ok(logs.includes("end:r2:r1"));
+    });
+    test("runs parallel teardowns in reverse topological order on @Destroy", async () => {
+        Config.set({
+            dryRun: false,
+            parallel: true,
+            providers: {},
+        });
+        class TeardownStack extends Stack {
+            r1 = new DelayResource("r1", 20, logs);
+            r2 = new DelayResource("r2", 20, logs);
+            constructor() {
+                super();
+                // r2 depends on r1 during deploy (so r1 deploys first).
+                // Teardown should destroy r2 first, then r1!
+                this.r2.dependsOn(this.r1);
+            }
+        }
+        const stack = new TeardownStack();
+        await stack.destroy();
+        const r2DestroyIndex = logs.indexOf("destroy:r2");
+        const r1DestroyIndex = logs.indexOf("destroy:r1");
+        // r2 depends on r1, so r2 must be fully destroyed BEFORE r1 begins destruction
+        assert.ok(r2DestroyIndex < r1DestroyIndex, `r2 destroy (${r2DestroyIndex}) must be before r1 destroy (${r1DestroyIndex})`);
+    });
+    test("halts execution of dependent resources if a dependency fails", async () => {
+        Config.set({
+            dryRun: false,
+            parallel: true,
+            providers: {},
+        });
+        class FailStack extends Stack {
+            r1 = new FailResource("r1");
+            r2 = new DelayResource("r2", 30, logs);
+            constructor() {
+                super();
+                this.r2.dependsOn(this.r1);
+            }
+        }
+        const stack = new FailStack();
+        await assert.rejects(async () => {
+            await stack.deploy();
+        }, /Failed to deploy!/);
+        // r2 should never have started because its dependency r1 failed!
+        assert.strictEqual(logs.includes("start:r2"), false);
+    });
+    test("decorator option propagation sets configuration values", async () => {
+        // Clear parallel flag
+        Config.set({ parallel: false });
+        // We define a decorated simple stack
+        let SimpleDecoStack = class SimpleDecoStack extends Stack {
+        };
+        SimpleDecoStack = __decorate([
+            Deploy({ parallel: true })
+        ], SimpleDecoStack);
+        // Verify decorator correctly updated global configuration to true
+        assert.strictEqual(Config.isParallelActive(), true);
+    });
+});

package/dist/core/production.test.d.ts

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