puls-dev 0.2.6 → 0.2.8

package/dist/providers/do/app.test.js

@@ -0,0 +1,268 @@
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import { AppPlatformBuilder } from "./app.js";
+import { Config } from "../../core/config.js";
+describe("AppPlatformBuilder Unit Tests", () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                do: { token: "fake-do-token", defaultRegion: "nyc3" },
+            },
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? "GET";
+            const body = init?.body ? JSON.parse(init.body) : undefined;
+            const headers = init?.headers;
+            fetchCalls.push({ url, method, body, headers });
+            const matchKey = Object.keys(mockResponses)
+                .filter((key) => {
+                const [mMethod, mPath] = key.split(" ");
+                return method === mMethod && url.includes(mPath);
+            })
+                .sort((a, b) => b.split(" ")[1].length - a.split(" ")[1].length)[0];
+            if (matchKey) {
+                const resp = mockResponses[matchKey];
+                return {
+                    ok: resp.status >= 200 && resp.status < 300,
+                    status: resp.status,
+                    json: async () => resp.body,
+                    text: async () => JSON.stringify(resp.body),
+                };
+            }
+            return {
+                ok: false,
+                status: 404,
+                json: async () => ({ message: "Not found" }),
+                text: async () => "Not found",
+            };
+        };
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    test("gracefully handles discovery when App does not exist", async () => {
+        mockResponses["GET /apps"] = {
+            status: 200,
+            body: { apps: [] },
+        };
+        const builder = new AppPlatformBuilder("my-app");
+        const discoveryResult = await builder.discoveryPromise;
+        assert.strictEqual(discoveryResult, null);
+        assert.strictEqual(fetchCalls.length, 1);
+        assert.strictEqual(fetchCalls[0].method, "GET");
+        assert.ok(fetchCalls[0].url.includes("/apps"));
+    });
+    test("discovers App successfully when it exists", async () => {
+        mockResponses["GET /apps"] = {
+            status: 200,
+            body: {
+                apps: [
+                    {
+                        id: "app-123",
+                        spec: { name: "my-app" },
+                        live_url: "https://my-app.ondigitalocean.app",
+                    },
+                ],
+            },
+        };
+        const builder = new AppPlatformBuilder("my-app");
+        const discoveryResult = await builder.discoveryPromise;
+        assert.ok(discoveryResult);
+        assert.strictEqual(discoveryResult.id, "app-123");
+        const id = await builder.out.id.get();
+        const liveUrl = await builder.out.liveUrl.get();
+        assert.strictEqual(id, "app-123");
+        assert.strictEqual(liveUrl, "https://my-app.ondigitalocean.app");
+    });
+    test("performs clean dry-run planning without making write requests", async () => {
+        Config.set({
+            dryRun: true,
+            providers: { do: { token: "fake-token" } },
+        });
+        mockResponses["GET /apps"] = {
+            status: 200,
+            body: { apps: [] },
+        };
+        const builder = new AppPlatformBuilder("my-dry-app")
+            .spec({
+            region: "nyc",
+            services: [
+                {
+                    name: "web",
+                    instance_size_slug: "apps-s-1vcpu-1gb",
+                },
+            ],
+        });
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, "my-dry-app");
+        assert.strictEqual(result.id, "PENDING");
+        // Discover should run, but no creations/updates
+        const writeCalls = fetchCalls.filter((c) => c.method !== "GET");
+        assert.strictEqual(writeCalls.length, 0);
+        const liveUrl = await builder.out.liveUrl.get();
+        assert.strictEqual(liveUrl, "https://my-dry-app.ondigitalocean.app");
+    });
+    test("deploys new App and awaits status: active with live url", async () => {
+        mockResponses["GET /apps"] = {
+            status: 200,
+            body: { apps: [] },
+        };
+        mockResponses["POST /apps"] = {
+            status: 202,
+            body: { app: { id: "new-app-id", live_url: "" } },
+        };
+        let pollCount = 0;
+        mockResponses["GET /apps/new-app-id"] = {
+            status: 200,
+            get body() {
+                pollCount++;
+                if (pollCount === 1) {
+                    return { app: { id: "new-app-id", live_url: "" } };
+                }
+                return {
+                    app: {
+                        id: "new-app-id",
+                        live_url: "https://new-app.ondigitalocean.app",
+                    },
+                };
+            },
+        };
+        const builder = new AppPlatformBuilder("my-new-app")
+            .spec({
+            region: "nyc",
+            services: [
+                {
+                    name: "api",
+                    github: { repo: "user/repo", branch: "main" },
+                },
+            ],
+        });
+        // Instantly check status
+        builder.waitFor = async (label, condition) => {
+            let done = false;
+            while (!done) {
+                done = await condition();
+            }
+        };
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.id, "new-app-id");
+        assert.strictEqual(result.liveUrl, "https://new-app.ondigitalocean.app");
+        const liveUrl = await builder.out.liveUrl.get();
+        assert.strictEqual(liveUrl, "https://new-app.ondigitalocean.app");
+        const postCall = fetchCalls.find((c) => c.method === "POST" && c.url.includes("/apps"));
+        assert.ok(postCall);
+        assert.deepStrictEqual(postCall.body, {
+            spec: {
+                name: "my-new-app",
+                region: "nyc",
+                services: [
+                    {
+                        name: "api",
+                        github: { repo: "user/repo", branch: "main" },
+                    },
+                ],
+            },
+        });
+    });
+    test("updates spec on existing app if configuration differs", async () => {
+        mockResponses["GET /apps"] = {
+            status: 200,
+            body: {
+                apps: [
+                    {
+                        id: "app-existing-id",
+                        spec: {
+                            name: "my-existing-app",
+                            region: "nyc",
+                        },
+                        live_url: "https://my-existing-app.ondigitalocean.app",
+                    },
+                ],
+            },
+        };
+        mockResponses["PUT /apps/app-existing-id"] = {
+            status: 200,
+            body: {
+                app: {
+                    id: "app-existing-id",
+                    spec: {
+                        name: "my-existing-app",
+                        region: "ams",
+                    },
+                    live_url: "https://my-existing-app.ondigitalocean.app",
+                },
+            },
+        };
+        const builder = new AppPlatformBuilder("my-existing-app")
+            .spec({
+            region: "ams", // differs from existing "nyc"
+        });
+        const result = await builder.deploy();
+        assert.ok(result);
+        const putCall = fetchCalls.find((c) => c.method === "PUT" && c.url.includes("/apps/app-existing-id"));
+        assert.ok(putCall);
+        assert.deepStrictEqual(putCall.body, {
+            spec: {
+                name: "my-existing-app",
+                region: "ams",
+            },
+        });
+    });
+    test("skips deploy on existing app if spec matches exactly", async () => {
+        mockResponses["GET /apps"] = {
+            status: 200,
+            body: {
+                apps: [
+                    {
+                        id: "app-existing-id",
+                        spec: {
+                            name: "my-existing-app",
+                            region: "nyc",
+                        },
+                        live_url: "https://my-existing-app.ondigitalocean.app",
+                    },
+                ],
+            },
+        };
+        const builder = new AppPlatformBuilder("my-existing-app")
+            .spec({
+            region: "nyc", // matches exactly
+        });
+        const result = await builder.deploy();
+        assert.ok(result);
+        // Verify no PUT writes
+        const putCall = fetchCalls.find((c) => c.method === "PUT");
+        assert.ok(!putCall);
+    });
+    test("destroys App successfully", async () => {
+        mockResponses["GET /apps"] = {
+            status: 200,
+            body: {
+                apps: [
+                    { id: "app-123", spec: { name: "my-app-del" } },
+                ],
+            },
+        };
+        mockResponses["DELETE /apps/app-123"] = {
+            status: 204,
+            body: {},
+        };
+        const builder = new AppPlatformBuilder("my-app-del");
+        await builder.discoveryPromise;
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: "my-app-del" });
+        const deleteCall = fetchCalls.find((c) => c.method === "DELETE");
+        assert.ok(deleteCall);
+        assert.ok(deleteCall.url.endsWith("/apps/app-123"));
+    });
+});

package/dist/providers/do/database.d.ts

@@ -0,0 +1,44 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+export declare class DatabaseBuilder extends BaseBuilder {
+    readonly out: {
+        host: Output<string>;
+        port: Output<number>;
+        uri: Output<string>;
+        user: Output<string>;
+        password: Output<string>;
+        id: Output<string>;
+    };
+    private _engine;
+    private _version;
+    private _size;
+    private _region;
+    private _nodes;
+    private _vpcUuid?;
+    private _firewallRules;
+    constructor(name: string);
+    engine(type: "pg" | "mysql" | "redis" | "mongodb" | "valkey" | "kafka"): this;
+    version(v: string): this;
+    size(slug: string): this;
+    region(r: string): this;
+    nodes(num: number): this;
+    vpc(uuid: string): this;
+    allowIp(cidr: string): this;
+    allowDroplet(dropletId: string): this;
+    allowTag(tagName: string): this;
+    private discoverCluster;
+    deploy(): Promise<{
+        name: string;
+        id: any;
+        status: any;
+    } | {
+        name: string;
+        id: string;
+        status?: undefined;
+    }>;
+    destroy(): Promise<{
+        destroyed: boolean;
+    } | {
+        destroyed: string;
+    }>;
+}

package/dist/providers/do/database.js

@@ -0,0 +1,208 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { getDoApi } from "./api.js";
+import { Output } from "../../core/output.js";
+export class DatabaseBuilder extends BaseBuilder {
+    out = {
+        host: new Output(),
+        port: new Output(),
+        uri: new Output(),
+        user: new Output(),
+        password: new Output(),
+        id: new Output(),
+    };
+    _engine = "pg";
+    _version = "15";
+    _size = "db-s-1vcpu-1gb";
+    _region = "nyc3";
+    _nodes = 1;
+    _vpcUuid;
+    _firewallRules = [];
+    constructor(name) {
+        super(name);
+        this.discoveryPromise = this.discoverCluster(name);
+    }
+    engine(type) {
+        this._engine = type;
+        return this;
+    }
+    version(v) {
+        this._version = v;
+        return this;
+    }
+    size(slug) {
+        this._size = slug;
+        return this;
+    }
+    region(r) {
+        this._region = r;
+        this.discoveryPromise = this.discoverCluster(this.name);
+        return this;
+    }
+    nodes(num) {
+        this._nodes = num;
+        return this;
+    }
+    vpc(uuid) {
+        this._vpcUuid = uuid;
+        return this;
+    }
+    allowIp(cidr) {
+        this._firewallRules.push({ type: "ip_addr", value: cidr });
+        return this;
+    }
+    allowDroplet(dropletId) {
+        this._firewallRules.push({ type: "droplet", value: dropletId });
+        return this;
+    }
+    allowTag(tagName) {
+        this._firewallRules.push({ type: "tag", value: tagName });
+        return this;
+    }
+    async discoverCluster(name) {
+        try {
+            const api = getDoApi();
+            const res = await api.get("/databases");
+            const match = (res.databases ?? []).find((db) => db.name === name);
+            if (match) {
+                // Resolve connection outputs immediately
+                const conn = match.private_connection ?? match.connection;
+                if (conn) {
+                    this.out.host.resolve(conn.host);
+                    this.out.port.resolve(conn.port);
+                    this.out.uri.resolve(conn.uri);
+                    this.out.user.resolve(conn.user);
+                    this.out.password.resolve(conn.password);
+                }
+                this.out.id.resolve(match.id);
+            }
+            return match ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getDoApi();
+        console.log(`\n🗄️  Finalizing DigitalOcean Database Cluster "${this.name}"...`);
+        if (existing) {
+            console.log(`   ✅ Database Cluster "${this.name}" already exists (id=${existing.id}, status=${existing.status}).`);
+            const conn = existing.private_connection ?? existing.connection;
+            if (conn) {
+                this.out.host.resolve(conn.host);
+                this.out.port.resolve(conn.port);
+                this.out.uri.resolve(conn.uri);
+                this.out.user.resolve(conn.user);
+                this.out.password.resolve(conn.password);
+            }
+            this.out.id.resolve(existing.id);
+            // Handle firewall rules updates
+            if (this._firewallRules.length > 0) {
+                if (dryRun) {
+                    console.log(`   📝 [PLAN] Update Database Firewall Rules (replace list):`);
+                    for (const rule of this._firewallRules) {
+                        console.log(`      └─ Rule: ${rule.type}:${rule.value}`);
+                    }
+                }
+                else {
+                    await api.put(`/databases/${existing.id}/firewall`, {
+                        rules: this._firewallRules,
+                    });
+                    console.log(`   ✅ Database Firewall Rules updated successfully.`);
+                }
+            }
+            return {
+                name: this.name,
+                id: existing.id,
+                status: existing.status,
+            };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Create DigitalOcean Database Cluster "${this.name}" (${this._region})`);
+            console.log(`      └─ Engine: ${this._engine} (version: ${this._version})`);
+            console.log(`      └─ Size: ${this._size} | Nodes: ${this._nodes}`);
+            if (this._vpcUuid) {
+                console.log(`      └─ VPC Network: ${this._vpcUuid}`);
+            }
+            if (this._firewallRules.length > 0) {
+                console.log(`      └─ Firewall Rules to apply:`);
+                for (const rule of this._firewallRules) {
+                    console.log(`         └─ ${rule.type}:${rule.value}`);
+                }
+            }
+            this.out.host.resolve("127.0.0.1");
+            this.out.port.resolve(5432);
+            this.out.uri.resolve("postgresql://db:pass@127.0.0.1:5432/db");
+            this.out.user.resolve("db");
+            this.out.password.resolve("pass");
+            this.out.id.resolve("PENDING");
+            return { name: this.name, id: "PENDING" };
+        }
+        // Create the database cluster
+        console.log(`🚀 Creating DigitalOcean Database Cluster "${this.name}" (takes several minutes)...`);
+        const body = {
+            name: this.name,
+            engine: this._engine,
+            version: this._version,
+            region: this._region,
+            size: this._size,
+            num_nodes: this._nodes,
+        };
+        if (this._vpcUuid) {
+            body.private_network_uuid = this._vpcUuid;
+        }
+        const createRes = await api.post("/databases", body);
+        const dbCluster = createRes.database;
+        console.log(`🚀 Database Cluster created with ID: ${dbCluster.id}`);
+        // Wait for the database cluster to become active
+        await this.waitFor(`Database Cluster "${this.name}" to become active`, async () => {
+            const check = await api.get(`/databases/${dbCluster.id}`);
+            if (check.database && check.database.status === "online") {
+                const conn = check.database.private_connection ?? check.database.connection;
+                if (conn) {
+                    this.out.host.resolve(conn.host);
+                    this.out.port.resolve(conn.port);
+                    this.out.uri.resolve(conn.uri);
+                    this.out.user.resolve(conn.user);
+                    this.out.password.resolve(conn.password);
+                }
+                this.out.id.resolve(check.database.id);
+                return true;
+            }
+            return false;
+        }, { intervalMs: 15_000, timeoutMs: 900_000 });
+        // Apply database firewall rules (trusted sources) if specified
+        if (this._firewallRules.length > 0) {
+            console.log(`   🔏 Applying Database Firewall Rules...`);
+            await api.put(`/databases/${dbCluster.id}/firewall`, {
+                rules: this._firewallRules,
+            });
+            console.log(`   ✅ Database Firewall Rules applied.`);
+        }
+        console.log(`🚀 Database available.`);
+        return {
+            name: this.name,
+            id: dbCluster.id,
+            status: "online",
+        };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getDoApi();
+        console.log(`\n🗑️  Destroying DigitalOcean Database Cluster "${this.name}"...`);
+        if (!existing) {
+            console.log(`   ─  Database Cluster "${this.name}" not found`);
+            return { destroyed: false };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete Database Cluster "${this.name}" (id=${existing.id})`);
+            return { destroyed: this.name };
+        }
+        console.log(`   🔄 Deleting Database Cluster "${this.name}" (id=${existing.id})...`);
+        await api.delete(`/databases/${existing.id}`);
+        console.log(`   🗑️  Removed Database Cluster "${this.name}"`);
+        return { destroyed: this.name };
+    }
+}

package/dist/providers/do/database.test.d.ts

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