puls-dev 0.3.5 → 0.3.7

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

@@ -0,0 +1,220 @@
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import fs from "node:fs";
+import path from "node:path";
+import { WorkerBuilder } from "./worker.js";
+import { KVBuilder } from "./kv.js";
+import { R2Builder } from "./r2.js";
+import { Config } from "../../core/config.js";
+describe("WorkerBuilder Unit Tests", () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    const tempScriptPath = path.resolve(process.cwd(), "temp-worker.js");
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        fs.writeFileSync(tempScriptPath, "export default { fetch() { return new Response('hello'); } };", "utf8");
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? "GET";
+            let body;
+            if (init?.body) {
+                if (init.body instanceof FormData) {
+                    body = init.body;
+                }
+                else 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;
+        if (fs.existsSync(tempScriptPath)) {
+            fs.unlinkSync(tempScriptPath);
+        }
+    });
+    test("throws if script path is not configured", async () => {
+        const builder = new WorkerBuilder("my-worker");
+        await assert.rejects(async () => {
+            await builder.deploy();
+        }, /Worker script path is not configured/);
+    });
+    test("deploys worker script with bindings and reconciles routes", async () => {
+        // KV namespace mock response for builder dependency discovery
+        mockResponses["GET /accounts/fake-cf-account/workers/namespaces?per_page=100"] = {
+            status: 200,
+            body: {
+                result: [{ id: "kv-id-999", title: "my-kv" }]
+            }
+        };
+        // R2 mock response for discovery
+        mockResponses["GET /accounts/fake-cf-account/r2/buckets"] = {
+            status: 200,
+            body: {
+                result: { buckets: [{ name: "my-bucket" }] }
+            }
+        };
+        // Worker upload mock response
+        mockResponses["PUT /accounts/fake-cf-account/workers/scripts/my-worker"] = {
+            status: 200,
+            body: { result: { id: "my-worker" } }
+        };
+        // Route resolution: zone matching
+        mockResponses["GET /zones?name=api.example.com"] = {
+            status: 200,
+            body: { result: [] }
+        };
+        mockResponses["GET /zones?name=example.com"] = {
+            status: 200,
+            body: { result: [{ id: "zone-123", name: "example.com" }] }
+        };
+        // Get routes mock response (1 existing route to update, 1 new route to create)
+        mockResponses["GET /zones/zone-123/workers/routes"] = {
+            status: 200,
+            body: {
+                result: [
+                    { id: "route-existing", pattern: "api.example.com/*", script: "old-worker" }
+                ]
+            }
+        };
+        mockResponses["PUT /zones/zone-123/workers/routes/route-existing"] = {
+            status: 200,
+            body: { result: { id: "route-existing" } }
+        };
+        mockResponses["POST /zones/zone-123/workers/routes"] = {
+            status: 200,
+            body: { result: { id: "route-new" } }
+        };
+        const kv = new KVBuilder("my-kv");
+        const r2 = new R2Builder("my-bucket");
+        // Initialize/deploy dependencies first
+        await kv.deploy();
+        await r2.deploy();
+        const worker = new WorkerBuilder("my-worker")
+            .script(tempScriptPath)
+            .kv("MY_KV", kv)
+            .r2("MY_BUCKET", r2)
+            .env("ENV_VAR", "my-env-value")
+            .route("api.example.com/*")
+            .route("example.com/*");
+        const result = await worker.deploy();
+        assert.strictEqual(result.scriptName, "my-worker");
+        assert.deepStrictEqual(result.routes, ["api.example.com/*", "example.com/*"]);
+        // Verify multipart request body contains metadata with bindings
+        const uploadCall = fetchCalls.find(c => c.method === "PUT" && c.url.endsWith("/workers/scripts/my-worker"));
+        assert.ok(uploadCall);
+        assert.ok(uploadCall.body instanceof FormData);
+        const metadataStr = uploadCall.body.get("metadata");
+        assert.ok(typeof metadataStr === "string");
+        const metadata = JSON.parse(metadataStr);
+        assert.deepStrictEqual(metadata, {
+            main_module: "index.js",
+            bindings: [
+                { type: "kv_namespace", name: "MY_KV", namespace_id: "kv-id-999" },
+                { type: "r2_bucket", name: "MY_BUCKET", bucket_name: "my-bucket" },
+                { type: "plain_text", name: "ENV_VAR", text: "my-env-value" }
+            ]
+        });
+        // Verify route updates & creations
+        const putRouteCall = fetchCalls.find(c => c.method === "PUT" && c.url.includes("/workers/routes/"));
+        assert.ok(putRouteCall);
+        assert.ok(putRouteCall.url.endsWith("/zones/zone-123/workers/routes/route-existing"));
+        assert.deepStrictEqual(putRouteCall.body, {
+            pattern: "api.example.com/*",
+            script: "my-worker"
+        });
+        const postRouteCall = fetchCalls.find(c => c.method === "POST" && c.url.endsWith("/zones/zone-123/workers/routes"));
+        assert.ok(postRouteCall);
+        assert.deepStrictEqual(postRouteCall.body, {
+            pattern: "example.com/*",
+            script: "my-worker"
+        });
+    });
+    test("does not call fetch during dryRun deploy", async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        const worker = new WorkerBuilder("my-worker")
+            .script(tempScriptPath)
+            .route("example.com/*");
+        const result = await worker.deploy();
+        assert.strictEqual(result.scriptName, "my-worker");
+        const puts = fetchCalls.filter(c => c.method === "PUT");
+        assert.strictEqual(puts.length, 0);
+    });
+    test("destroys routes and script successfully", async () => {
+        // Mock zone resolution for route cleanup
+        mockResponses["GET /zones?name=example.com"] = {
+            status: 200,
+            body: { result: [{ id: "zone-123", name: "example.com" }] }
+        };
+        mockResponses["GET /zones/zone-123/workers/routes"] = {
+            status: 200,
+            body: {
+                result: [
+                    { id: "route-existing", pattern: "example.com/*", script: "my-worker" }
+                ]
+            }
+        };
+        mockResponses["DELETE /zones/zone-123/workers/routes/route-existing"] = {
+            status: 200,
+            body: {}
+        };
+        mockResponses["DELETE /accounts/fake-cf-account/workers/scripts/my-worker"] = {
+            status: 200,
+            body: {}
+        };
+        const worker = new WorkerBuilder("my-worker")
+            .script(tempScriptPath)
+            .route("example.com/*");
+        const result = await worker.destroy();
+        assert.deepStrictEqual(result, { destroyed: "my-worker" });
+        const deleteRouteCall = fetchCalls.find(c => c.method === "DELETE" && c.url.includes("/workers/routes/"));
+        assert.ok(deleteRouteCall);
+        assert.ok(deleteRouteCall.url.endsWith("/zones/zone-123/workers/routes/route-existing"));
+        const deleteScriptCall = fetchCalls.find(c => c.method === "DELETE" && c.url.includes("/workers/scripts/"));
+        assert.ok(deleteScriptCall);
+        assert.ok(deleteScriptCall.url.endsWith("/accounts/fake-cf-account/workers/scripts/my-worker"));
+    });
+});

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

@@ -0,0 +1,42 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+export interface CFDNSRecord {
+    type: "A" | "CNAME" | "TXT" | "MX" | "AAAA" | "SRV" | "CAA";
+    name: string;
+    value: string | BaseBuilder | Output<string>;
+    ttl?: number;
+    priority?: number;
+    port?: number;
+    weight?: number;
+    flags?: number;
+    tag?: string;
+    proxied?: boolean;
+}
+export declare class ZoneBuilder extends BaseBuilder {
+    domainName: string;
+    readonly out: {
+        id: Output<string>;
+    };
+    resolvedId: string | null;
+    private records;
+    constructor(domainName: string);
+    private discoverZone;
+    record(filePath: string): this;
+    record(name: string, type: CFDNSRecord["type"], value: string | BaseBuilder | Output<string>, ttl?: number, priority?: number, port?: number, weight?: number, flags?: number, tag?: string, proxied?: boolean): this;
+    pointer(name: string, target: BaseBuilder | Output<string> | string, proxied?: boolean): this;
+    cname(name: string, target: string, proxied?: boolean): this;
+    aaaa(name: string, target: string | Output<string>, proxied?: boolean): this;
+    txt(name: string, target: string): this;
+    mx(name: string, target: string, priority?: number): this;
+    srv(name: string, target: string, port: number, priority?: number, weight?: number): this;
+    caa(name: string, tag: string, target: string, flags?: number): this;
+    deploy(): Promise<{
+        zone: string;
+        zoneId: string | null;
+    }>;
+    destroy(): Promise<{
+        destroyed: boolean;
+    } | {
+        destroyed: string;
+    }>;
+}

package/dist/providers/cloudflare/zone.js

@@ -0,0 +1,280 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+import { getCloudflareApi, getCloudflareAccountId } from "./api.js";
+import { loadRecordsFromFile } from "../../core/parser.js";
+function getFullRecordName(name, zone) {
+    const cleanName = name.trim();
+    if (cleanName === "" || cleanName === "@")
+        return zone;
+    if (cleanName.endsWith(zone))
+        return cleanName;
+    return `${cleanName}.${zone}`;
+}
+export class ZoneBuilder extends BaseBuilder {
+    domainName;
+    out = {
+        id: new Output(),
+    };
+    resolvedId = null;
+    records = [];
+    constructor(domainName) {
+        super(domainName);
+        this.domainName = domainName;
+        this.discoveryPromise = this.discoverZone(domainName);
+    }
+    async discoverZone(name) {
+        try {
+            const api = getCloudflareApi();
+            const res = await api.get(`/zones?name=${name}`);
+            return (res.result ?? []).find((z) => z.name === name) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    record(nameOrPath, type, value, ttl, priority, port, weight, flags, tag, proxied) {
+        if (arguments.length === 1 &&
+            typeof nameOrPath === "string" &&
+            (nameOrPath.endsWith(".yaml") || nameOrPath.endsWith(".yml") || nameOrPath.endsWith(".json"))) {
+            const loaded = loadRecordsFromFile(nameOrPath);
+            for (const r of loaded) {
+                this.records.push({
+                    name: r.name,
+                    type: r.type,
+                    value: r.value,
+                    ttl: r.ttl,
+                    priority: r.priority,
+                    port: r.port,
+                    weight: r.weight,
+                    flags: r.flags,
+                    tag: r.tag,
+                    proxied: r.proxied,
+                });
+            }
+            return this;
+        }
+        this.records.push({
+            name: nameOrPath,
+            type: type,
+            value: value,
+            ttl,
+            priority,
+            port,
+            weight,
+            flags,
+            tag,
+            proxied,
+        });
+        return this;
+    }
+    pointer(name, target, proxied) {
+        this.records.push({ type: "A", name, value: target, proxied });
+        return this;
+    }
+    cname(name, target, proxied) {
+        this.records.push({ type: "CNAME", name, value: target, proxied });
+        return this;
+    }
+    aaaa(name, target, proxied) {
+        this.records.push({ type: "AAAA", name, value: target, proxied });
+        return this;
+    }
+    txt(name, target) {
+        this.records.push({ type: "TXT", name, value: target });
+        return this;
+    }
+    mx(name, target, priority = 10) {
+        this.records.push({ type: "MX", name, value: target, priority });
+        return this;
+    }
+    srv(name, target, port, priority = 10, weight = 10) {
+        this.records.push({ type: "SRV", name, value: target, port, priority, weight });
+        return this;
+    }
+    caa(name, tag, target, flags = 0) {
+        this.records.push({ type: "CAA", name, value: target, tag, flags });
+        return this;
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getCloudflareApi();
+        console.log(`\n🌐 Finalizing DNS Zone for "${this.domainName}"...`);
+        if (existing) {
+            this.resolvedId = existing.id;
+            this.out.id.resolve(existing.id);
+            console.log(`   ✅ Zone "${this.domainName}" exists (id=${existing.id})`);
+        }
+        else {
+            if (dryRun) {
+                console.log(`   📝 [PLAN] Create Cloudflare Zone "${this.domainName}"`);
+                this.resolvedId = "PENDING";
+                this.out.id.resolve("PENDING");
+            }
+            else {
+                const accountId = getCloudflareAccountId();
+                const res = await api.post("/zones", {
+                    name: this.domainName,
+                    account: { id: accountId },
+                    type: "full",
+                });
+                this.resolvedId = res.result.id;
+                this.out.id.resolve(this.resolvedId);
+                console.log(`🚀 Created Cloudflare Zone "${this.domainName}" (id=${this.resolvedId})`);
+            }
+        }
+        let existingRecords = [];
+        if (existing && !dryRun) {
+            try {
+                const res = await api.get(`/zones/${this.resolvedId}/dns_records?per_page=100`);
+                existingRecords = res.result ?? [];
+            }
+            catch {
+                existingRecords = [];
+            }
+        }
+        const consumedRecordIds = new Set();
+        for (const record of this.records) {
+            let data;
+            if (record.value instanceof Output) {
+                data = await record.value.get();
+            }
+            else if (record.value && typeof record.value === "object" && "out" in record.value) {
+                const out = record.value.out;
+                if (out && out.ip instanceof Output) {
+                    data = await out.ip.get();
+                }
+                else if (out && out.publicIp instanceof Output) {
+                    data = await out.publicIp.get();
+                }
+                else {
+                    data = String(record.value);
+                }
+            }
+            else if (record.value instanceof BaseBuilder) {
+                if (typeof record.value.getPublicIp === "function") {
+                    data = await record.value.getPublicIp();
+                }
+                else {
+                    data = String(record.value);
+                }
+            }
+            else {
+                data = String(record.value);
+            }
+            const targetFullName = getFullRecordName(record.name, this.domainName);
+            const targetTtl = record.ttl ?? 3600;
+            const targetProxied = !!record.proxied;
+            // Match logic helper
+            const isMatch = (r) => {
+                if (r.type !== record.type || r.name !== targetFullName)
+                    return false;
+                if (record.type === "MX") {
+                    return r.content === data && (r.priority ?? 10) === (record.priority ?? 10);
+                }
+                if (record.type === "SRV") {
+                    return (r.data?.target === data &&
+                        r.data?.port === (record.port ?? 5060) &&
+                        r.data?.priority === (record.priority ?? 10) &&
+                        r.data?.weight === (record.weight ?? 10));
+                }
+                if (record.type === "CAA") {
+                    return (r.data?.value === data &&
+                        r.data?.tag === (record.tag ?? "issue") &&
+                        r.data?.flags === (record.flags ?? 0));
+                }
+                return r.content === data && !!r.proxied === targetProxied;
+            };
+            const perfectMatch = existingRecords.find((r) => !consumedRecordIds.has(r.id) && isMatch(r));
+            if (perfectMatch) {
+                consumedRecordIds.add(perfectMatch.id);
+                console.log(`   ✅ ${record.type} ${targetFullName} is up to date (→ ${data})`);
+                continue;
+            }
+            const updateableMatch = existingRecords.find((r) => !consumedRecordIds.has(r.id) && r.type === record.type && r.name === targetFullName);
+            // Construct payload
+            const payload = {
+                type: record.type,
+                name: record.name,
+                ttl: targetTtl,
+            };
+            if (record.type === "MX") {
+                payload.content = data;
+                payload.priority = record.priority ?? 10;
+            }
+            else if (record.type === "SRV") {
+                payload.data = {
+                    priority: record.priority ?? 10,
+                    weight: record.weight ?? 10,
+                    port: record.port ?? 5060,
+                    target: data,
+                };
+            }
+            else if (record.type === "CAA") {
+                payload.data = {
+                    flags: record.flags ?? 0,
+                    tag: record.tag ?? "issue",
+                    value: data,
+                };
+            }
+            else {
+                payload.content = data;
+                payload.proxied = targetProxied;
+            }
+            if (updateableMatch) {
+                consumedRecordIds.add(updateableMatch.id);
+                if (dryRun) {
+                    console.log(`   📝 [PLAN] Update ${record.type} ${targetFullName} → ${data}`);
+                }
+                else {
+                    await api.put(`/zones/${this.resolvedId}/dns_records/${updateableMatch.id}`, payload);
+                    console.log(`   🔄 Updated ${record.type} ${targetFullName} → ${data}`);
+                }
+            }
+            else {
+                if (dryRun) {
+                    console.log(`   📝 [PLAN] Create ${record.type} ${targetFullName} → ${data}`);
+                }
+                else {
+                    await api.post(`/zones/${this.resolvedId}/dns_records`, payload);
+                    console.log(`   🚀 Created ${record.type} ${targetFullName} → ${data}`);
+                }
+            }
+        }
+        // Purge stale
+        const declaredKeySet = new Set(this.records.map((r) => `${r.type}:${getFullRecordName(r.name, this.domainName)}`));
+        for (const r of existingRecords) {
+            if (consumedRecordIds.has(r.id))
+                continue;
+            if (declaredKeySet.has(`${r.type}:${r.name}`)) {
+                if (dryRun) {
+                    console.log(`   📝 [PLAN] Delete stale ${r.type} ${r.name}`);
+                }
+                else {
+                    await api.delete(`/zones/${this.resolvedId}/dns_records/${r.id}`);
+                    console.log(`   🗑️  Deleted stale ${r.type} ${r.name}`);
+                }
+            }
+        }
+        await this.deploySidecars();
+        return { zone: this.domainName, zoneId: this.resolvedId };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getCloudflareApi();
+        console.log(`\n🗑️  Destroying Cloudflare DNS Zone "${this.domainName}"...`);
+        if (!existing) {
+            console.log(`   ─  Zone "${this.domainName}" not found`);
+            return { destroyed: false };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete Cloudflare Zone "${this.domainName}" (id=${existing.id})`);
+            return { destroyed: this.domainName };
+        }
+        await api.delete(`/zones/${existing.id}`);
+        console.log(`   🗑️  Removed Cloudflare Zone "${this.domainName}" (id=${existing.id})`);
+        await this.destroySidecars();
+        return { destroyed: this.domainName };
+    }
+}

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

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