puls-dev 0.3.5 → 0.3.7

package/dist/providers/cloudflare/kv.js

@@ -0,0 +1,69 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+import { getCloudflareApi, getCloudflareAccountId } from "./api.js";
+export class KVBuilder extends BaseBuilder {
+    title;
+    out = {
+        id: new Output(),
+    };
+    resolvedId = null;
+    constructor(title) {
+        super(title);
+        this.title = title;
+        this.discoveryPromise = this.discoverNamespace(title);
+    }
+    async discoverNamespace(title) {
+        try {
+            const api = getCloudflareApi();
+            const accountId = getCloudflareAccountId();
+            const res = await api.get(`/accounts/${accountId}/workers/namespaces?per_page=100`);
+            return (res.result ?? []).find((n) => n.title === title) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getCloudflareApi();
+        const accountId = getCloudflareAccountId();
+        console.log(`\n📦 Finalizing Cloudflare KV Namespace "${this.title}"...`);
+        if (existing) {
+            this.resolvedId = existing.id;
+            this.out.id.resolve(existing.id);
+            console.log(`   ✅ KV Namespace "${this.title}" already exists (id=${existing.id})`);
+            return { title: this.title, id: this.resolvedId };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Create KV Namespace "${this.title}"`);
+            this.out.id.resolve("PENDING");
+            return { title: this.title, id: "PENDING" };
+        }
+        const res = await api.post(`/accounts/${accountId}/workers/namespaces`, {
+            title: this.title,
+        });
+        this.resolvedId = res.result.id;
+        this.out.id.resolve(this.resolvedId);
+        console.log(`🚀 Created KV Namespace "${this.title}" (id=${this.resolvedId})`);
+        return { title: this.title, id: this.resolvedId };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getCloudflareApi();
+        const accountId = getCloudflareAccountId();
+        console.log(`\n🗑️  Destroying Cloudflare KV Namespace "${this.title}"...`);
+        if (!existing) {
+            console.log(`   ─  KV Namespace "${this.title}" not found`);
+            return { destroyed: false };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete KV Namespace "${this.title}" (id=${existing.id})`);
+            return { destroyed: this.title };
+        }
+        await api.delete(`/accounts/${accountId}/workers/namespaces/${existing.id}`);
+        console.log(`   🗑️  Removed KV Namespace "${this.title}" (id=${existing.id})`);
+        return { destroyed: this.title };
+    }
+}

package/dist/providers/cloudflare/kv.test.d.ts

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

package/dist/providers/cloudflare/kv.test.js

@@ -0,0 +1,134 @@
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import { KVBuilder } from "./kv.js";
+import { Config } from "../../core/config.js";
+describe("KVBuilder Unit Tests", () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? "GET";
+            let body;
+            if (init?.body) {
+                if (typeof init.body === "string") {
+                    try {
+                        body = JSON.parse(init.body);
+                    }
+                    catch {
+                        body = init.body;
+                    }
+                }
+                else {
+                    body = init.body;
+                }
+            }
+            const headers = init?.headers;
+            fetchCalls.push({ url, method, body, headers });
+            const matchKey = Object.keys(mockResponses).find(key => {
+                const [mMethod, mPath] = key.split(" ");
+                return method === mMethod && url.endsWith(mPath);
+            });
+            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 () => ({ errors: [{ message: "Not found" }] }),
+                text: async () => "Not found",
+            };
+        };
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    test("discovers namespace successfully if it already exists", async () => {
+        mockResponses["GET /accounts/fake-cf-account/workers/namespaces?per_page=100"] = {
+            status: 200,
+            body: {
+                result: [
+                    { id: "kv-123", title: "my-namespace" }
+                ]
+            }
+        };
+        const builder = new KVBuilder("my-namespace");
+        const result = await builder.deploy();
+        assert.strictEqual(result.id, "kv-123");
+        assert.strictEqual(builder.resolvedId, "kv-123");
+        // Deploying again shouldn't send post
+        const deployAgainResult = await builder.deploy();
+        assert.strictEqual(deployAgainResult.id, "kv-123");
+        const posts = fetchCalls.filter(c => c.method === "POST");
+        assert.strictEqual(posts.length, 0);
+    });
+    test("creates namespace if it does not exist", async () => {
+        mockResponses["GET /accounts/fake-cf-account/workers/namespaces?per_page=100"] = {
+            status: 200,
+            body: { result: [] }
+        };
+        mockResponses["POST /accounts/fake-cf-account/workers/namespaces"] = {
+            status: 200,
+            body: { result: { id: "kv-created-456" } }
+        };
+        const builder = new KVBuilder("my-namespace");
+        const result = await builder.deploy();
+        assert.strictEqual(result.id, "kv-created-456");
+        assert.strictEqual(builder.resolvedId, "kv-created-456");
+        const postCall = fetchCalls.find(c => c.method === "POST");
+        assert.ok(postCall);
+        assert.deepStrictEqual(postCall.body, { title: "my-namespace" });
+    });
+    test("does not call fetch during dryRun deploy", async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        mockResponses["GET /accounts/fake-cf-account/workers/namespaces?per_page=100"] = {
+            status: 200,
+            body: { result: [] }
+        };
+        const builder = new KVBuilder("my-namespace");
+        const result = await builder.deploy();
+        assert.strictEqual(result.id, "PENDING");
+        const posts = fetchCalls.filter(c => c.method === "POST");
+        assert.strictEqual(posts.length, 0);
+    });
+    test("destroys namespace successfully if exists", async () => {
+        mockResponses["GET /accounts/fake-cf-account/workers/namespaces?per_page=100"] = {
+            status: 200,
+            body: {
+                result: [
+                    { id: "kv-123", title: "my-namespace" }
+                ]
+            }
+        };
+        mockResponses["DELETE /accounts/fake-cf-account/workers/namespaces/kv-123"] = {
+            status: 200,
+            body: { success: true }
+        };
+        const builder = new KVBuilder("my-namespace");
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: "my-namespace" });
+        const deleteCall = fetchCalls.find(c => c.method === "DELETE");
+        assert.ok(deleteCall);
+    });
+});

package/dist/providers/cloudflare/r2.d.ts

@@ -0,0 +1,14 @@
+import { BaseBuilder } from "../../core/resource.js";
+export declare class R2Builder extends BaseBuilder {
+    bucketName: string;
+    constructor(bucketName: string);
+    private discoverBucket;
+    deploy(): Promise<{
+        bucket: string;
+    }>;
+    destroy(): Promise<{
+        destroyed: boolean;
+    } | {
+        destroyed: string;
+    }>;
+}

package/dist/providers/cloudflare/r2.js

@@ -0,0 +1,57 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { getCloudflareApi, getCloudflareAccountId } from "./api.js";
+export class R2Builder extends BaseBuilder {
+    bucketName;
+    constructor(bucketName) {
+        super(bucketName);
+        this.bucketName = bucketName;
+        this.discoveryPromise = this.discoverBucket(bucketName);
+    }
+    async discoverBucket(name) {
+        try {
+            const api = getCloudflareApi();
+            const accountId = getCloudflareAccountId();
+            const res = await api.get(`/accounts/${accountId}/r2/buckets`);
+            return (res.result?.buckets ?? []).find((b) => b.name === name) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getCloudflareApi();
+        const accountId = getCloudflareAccountId();
+        console.log(`\n🪣  Finalizing Cloudflare R2 Bucket "${this.bucketName}"...`);
+        if (existing) {
+            console.log(`   ✅ R2 Bucket "${this.bucketName}" already exists`);
+            return { bucket: this.bucketName };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Create R2 Bucket "${this.bucketName}"`);
+            return { bucket: this.bucketName };
+        }
+        await api.put(`/accounts/${accountId}/r2/buckets/${this.bucketName}`, {});
+        console.log(`🚀 Created R2 Bucket "${this.bucketName}"`);
+        return { bucket: this.bucketName };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getCloudflareApi();
+        const accountId = getCloudflareAccountId();
+        console.log(`\n🗑️  Destroying Cloudflare R2 Bucket "${this.bucketName}"...`);
+        if (!existing) {
+            console.log(`   ─  R2 Bucket "${this.bucketName}" not found`);
+            return { destroyed: false };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete R2 Bucket "${this.bucketName}"`);
+            return { destroyed: this.bucketName };
+        }
+        await api.delete(`/accounts/${accountId}/r2/buckets/${this.bucketName}`);
+        console.log(`   🗑️  Removed R2 Bucket "${this.bucketName}"`);
+        return { destroyed: this.bucketName };
+    }
+}

package/dist/providers/cloudflare/r2.test.d.ts

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

package/dist/providers/cloudflare/r2.test.js

@@ -0,0 +1,132 @@
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import { R2Builder } from "./r2.js";
+import { Config } from "../../core/config.js";
+describe("R2Builder Unit Tests", () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? "GET";
+            let body;
+            if (init?.body) {
+                if (typeof init.body === "string") {
+                    try {
+                        body = JSON.parse(init.body);
+                    }
+                    catch {
+                        body = init.body;
+                    }
+                }
+                else {
+                    body = init.body;
+                }
+            }
+            const headers = init?.headers;
+            fetchCalls.push({ url, method, body, headers });
+            const matchKey = Object.keys(mockResponses).find(key => {
+                const [mMethod, mPath] = key.split(" ");
+                return method === mMethod && url.endsWith(mPath);
+            });
+            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 () => ({ errors: [{ message: "Not found" }] }),
+                text: async () => "Not found",
+            };
+        };
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    test("discovers bucket successfully if it already exists", async () => {
+        mockResponses["GET /accounts/fake-cf-account/r2/buckets"] = {
+            status: 200,
+            body: {
+                result: {
+                    buckets: [
+                        { name: "my-bucket" }
+                    ]
+                }
+            }
+        };
+        const builder = new R2Builder("my-bucket");
+        const result = await builder.deploy();
+        assert.deepStrictEqual(result, { bucket: "my-bucket" });
+        const puts = fetchCalls.filter(c => c.method === "PUT");
+        assert.strictEqual(puts.length, 0);
+    });
+    test("creates bucket if it does not exist", async () => {
+        mockResponses["GET /accounts/fake-cf-account/r2/buckets"] = {
+            status: 200,
+            body: { result: { buckets: [] } }
+        };
+        mockResponses["PUT /accounts/fake-cf-account/r2/buckets/my-bucket"] = {
+            status: 200,
+            body: {}
+        };
+        const builder = new R2Builder("my-bucket");
+        const result = await builder.deploy();
+        assert.deepStrictEqual(result, { bucket: "my-bucket" });
+        const putCall = fetchCalls.find(c => c.method === "PUT");
+        assert.ok(putCall);
+    });
+    test("does not call fetch during dryRun deploy", async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        mockResponses["GET /accounts/fake-cf-account/r2/buckets"] = {
+            status: 200,
+            body: { result: { buckets: [] } }
+        };
+        const builder = new R2Builder("my-bucket");
+        const result = await builder.deploy();
+        assert.deepStrictEqual(result, { bucket: "my-bucket" });
+        const puts = fetchCalls.filter(c => c.method === "PUT");
+        assert.strictEqual(puts.length, 0);
+    });
+    test("destroys bucket successfully if exists", async () => {
+        mockResponses["GET /accounts/fake-cf-account/r2/buckets"] = {
+            status: 200,
+            body: {
+                result: {
+                    buckets: [
+                        { name: "my-bucket" }
+                    ]
+                }
+            }
+        };
+        mockResponses["DELETE /accounts/fake-cf-account/r2/buckets/my-bucket"] = {
+            status: 200,
+            body: {}
+        };
+        const builder = new R2Builder("my-bucket");
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: "my-bucket" });
+        const deleteCall = fetchCalls.find(c => c.method === "DELETE");
+        assert.ok(deleteCall);
+    });
+});

package/dist/providers/cloudflare/worker.d.ts

@@ -0,0 +1,28 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+import { KVBuilder } from "./kv.js";
+import { R2Builder } from "./r2.js";
+export declare class WorkerBuilder extends BaseBuilder {
+    scriptName: string;
+    private _scriptPath?;
+    private _routes;
+    private _kvs;
+    private _r2s;
+    private _envs;
+    constructor(scriptName: string);
+    script(filePath: string): this;
+    route(pattern: string): this;
+    kv(bindingName: string, kvNamespace: KVBuilder): this;
+    r2(bindingName: string, r2Bucket: R2Builder): this;
+    env(bindingName: string, value: string | Output<string>): this;
+    deploy(): Promise<{
+        scriptName: string;
+        routes?: undefined;
+    } | {
+        scriptName: string;
+        routes: string[];
+    }>;
+    destroy(): Promise<{
+        destroyed: string;
+    }>;
+}

package/dist/providers/cloudflare/worker.js

@@ -0,0 +1,172 @@
+import { readFileSync } from "node:fs";
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+import { getCloudflareApi, getCloudflareAccountId } from "./api.js";
+async function getZoneIdForPattern(pattern, api) {
+    let host = pattern.split("/")[0];
+    const parts = host.split(".");
+    for (let i = 0; i < parts.length - 1; i++) {
+        const possibleZone = parts.slice(i).join(".");
+        try {
+            const res = await api.get(`/zones?name=${possibleZone}`);
+            if (res.result && res.result.length > 0) {
+                return res.result[0].id;
+            }
+        }
+        catch {
+            // Ignore and try next parent domain
+        }
+    }
+    throw new Error(`Could not find Cloudflare DNS Zone for route pattern "${pattern}"`);
+}
+export class WorkerBuilder extends BaseBuilder {
+    scriptName;
+    _scriptPath;
+    _routes = [];
+    _kvs = new Map();
+    _r2s = new Map();
+    _envs = new Map();
+    constructor(scriptName) {
+        super(scriptName);
+        this.scriptName = scriptName;
+    }
+    script(filePath) {
+        this._scriptPath = filePath;
+        return this;
+    }
+    route(pattern) {
+        this._routes.push(pattern);
+        return this;
+    }
+    kv(bindingName, kvNamespace) {
+        this._kvs.set(bindingName, kvNamespace);
+        this.dependsOn(kvNamespace);
+        return this;
+    }
+    r2(bindingName, r2Bucket) {
+        this._r2s.set(bindingName, r2Bucket);
+        this.dependsOn(r2Bucket);
+        return this;
+    }
+    env(bindingName, value) {
+        this._envs.set(bindingName, value);
+        return this;
+    }
+    async deploy() {
+        if (!this._scriptPath) {
+            throw new Error(`Worker script path is not configured for "${this.name}". Call .script("filePath")`);
+        }
+        const dryRun = this.isDryRunActive();
+        const api = getCloudflareApi();
+        const accountId = getCloudflareAccountId();
+        console.log(`\n⚡ Finalizing Cloudflare Worker "${this.scriptName}"...`);
+        const metadata = {
+            main_module: "index.js",
+            bindings: [],
+        };
+        // Resolve KV Bindings
+        for (const [binding, kv] of this._kvs.entries()) {
+            const kvId = dryRun ? "mock-kv-id" : await kv.out.id.get();
+            metadata.bindings.push({
+                type: "kv_namespace",
+                name: binding,
+                namespace_id: kvId,
+            });
+        }
+        // Resolve R2 Bindings
+        for (const [binding, r2] of this._r2s.entries()) {
+            metadata.bindings.push({
+                type: "r2_bucket",
+                name: binding,
+                bucket_name: r2.bucketName,
+            });
+        }
+        // Resolve Env Bindings
+        for (const [binding, val] of this._envs.entries()) {
+            const resolvedVal = val instanceof Output ? await val.get() : val;
+            metadata.bindings.push({
+                type: "plain_text",
+                name: binding,
+                text: resolvedVal,
+            });
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Upload Worker script "${this.scriptName}"`);
+            for (const r of this._routes) {
+                console.log(`      └─ Route: ${r}`);
+            }
+            return { scriptName: this.scriptName };
+        }
+        // Load and build FormData
+        const scriptContent = readFileSync(this._scriptPath, "utf8");
+        const form = new FormData();
+        form.append("metadata", JSON.stringify(metadata));
+        form.append("script", new Blob([scriptContent], { type: "application/javascript+module" }), "index.js");
+        await api.put(`/accounts/${accountId}/workers/scripts/${this.scriptName}`, form);
+        console.log(`🚀 Uploaded Worker script "${this.scriptName}"`);
+        // Reconcile Routes
+        for (const pattern of this._routes) {
+            const zoneId = await getZoneIdForPattern(pattern, api);
+            const routesRes = await api.get(`/zones/${zoneId}/workers/routes`);
+            const existingRoute = (routesRes.result ?? []).find((r) => r.pattern === pattern);
+            if (existingRoute) {
+                if (existingRoute.script !== this.scriptName) {
+                    await api.put(`/zones/${zoneId}/workers/routes/${existingRoute.id}`, {
+                        pattern,
+                        script: this.scriptName,
+                    });
+                    console.log(`   🔄 Updated route ${pattern} → ${this.scriptName}`);
+                }
+                else {
+                    console.log(`   ✅ Route ${pattern} is up to date`);
+                }
+            }
+            else {
+                await api.post(`/zones/${zoneId}/workers/routes`, {
+                    pattern,
+                    script: this.scriptName,
+                });
+                console.log(`   🚀 Created route ${pattern} → ${this.scriptName}`);
+            }
+        }
+        return { scriptName: this.scriptName, routes: this._routes };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const api = getCloudflareApi();
+        const accountId = getCloudflareAccountId();
+        console.log(`\n🗑️  Destroying Cloudflare Worker "${this.scriptName}"...`);
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete Worker script "${this.scriptName}"`);
+            return { destroyed: this.scriptName };
+        }
+        // Clean up routes pointing to this script
+        if (this._routes.length > 0) {
+            for (const pattern of this._routes) {
+                try {
+                    const zoneId = await getZoneIdForPattern(pattern, api);
+                    const routesRes = await api.get(`/zones/${zoneId}/workers/routes`);
+                    const match = (routesRes.result ?? []).find((r) => r.pattern === pattern && r.script === this.scriptName);
+                    if (match) {
+                        await api.delete(`/zones/${zoneId}/workers/routes/${match.id}`);
+                        console.log(`   🗑️  Removed route ${pattern}`);
+                    }
+                }
+                catch {
+                    // Ignore if zone or route is already gone
+                }
+            }
+        }
+        try {
+            await api.delete(`/accounts/${accountId}/workers/scripts/${this.scriptName}`);
+            console.log(`   🗑️  Removed Worker script "${this.scriptName}"`);
+        }
+        catch (err) {
+            // Ignore if already deleted
+            if (!err.message.includes("404"))
+                throw err;
+        }
+        await this.destroySidecars();
+        return { destroyed: this.scriptName };
+    }
+}

package/dist/providers/cloudflare/worker.test.d.ts

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