puls-dev 0.3.6 → 0.3.7

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 {};

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

@@ -0,0 +1,284 @@
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import fs from "node:fs";
+import path from "node:path";
+import { ZoneBuilder } from "./zone.js";
+import { Config } from "../../core/config.js";
+describe("ZoneBuilder 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 zone successfully if it already exists", async () => {
+        mockResponses["GET /zones?name=example.com"] = {
+            status: 200,
+            body: {
+                result: [
+                    { id: "zone-123", name: "example.com", status: "active" }
+                ]
+            }
+        };
+        mockResponses["GET /zones/zone-123/dns_records?per_page=100"] = {
+            status: 200,
+            body: { result: [] }
+        };
+        const builder = new ZoneBuilder("example.com");
+        const result = await builder.deploy();
+        assert.strictEqual(result.zoneId, "zone-123");
+        assert.strictEqual(builder.resolvedId, "zone-123");
+        const posts = fetchCalls.filter(c => c.method === "POST");
+        assert.strictEqual(posts.length, 0); // No zone creation
+    });
+    test("creates zone if it does not exist", async () => {
+        mockResponses["GET /zones?name=example.com"] = {
+            status: 200,
+            body: { result: [] }
+        };
+        mockResponses["POST /zones"] = {
+            status: 200,
+            body: { result: { id: "zone-new-456" } }
+        };
+        const builder = new ZoneBuilder("example.com");
+        const result = await builder.deploy();
+        assert.strictEqual(result.zoneId, "zone-new-456");
+        assert.strictEqual(builder.resolvedId, "zone-new-456");
+        const postCall = fetchCalls.find(c => c.method === "POST" && c.url.endsWith("/zones"));
+        assert.ok(postCall);
+        assert.deepStrictEqual(postCall.body, {
+            name: "example.com",
+            account: { id: "fake-cf-account" },
+            type: "full"
+        });
+    });
+    test("handles dry-run deploy properly", async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        mockResponses["GET /zones?name=example.com"] = {
+            status: 200,
+            body: { result: [] }
+        };
+        const builder = new ZoneBuilder("example.com");
+        const result = await builder.deploy();
+        assert.strictEqual(result.zoneId, "PENDING");
+        const posts = fetchCalls.filter(c => c.method === "POST");
+        assert.strictEqual(posts.length, 0);
+    });
+    test("reconciles records correctly (creates missing, updates out of date, deletes stale)", async () => {
+        mockResponses["GET /zones?name=example.com"] = {
+            status: 200,
+            body: {
+                result: [{ id: "zone-123", name: "example.com" }]
+            }
+        };
+        mockResponses["GET /zones/zone-123/dns_records?per_page=100"] = {
+            status: 200,
+            body: {
+                result: [
+                    // Perfect match - should be skipped
+                    { id: "rec-1", type: "A", name: "www.example.com", content: "1.1.1.1", proxied: true },
+                    // Out of date - should be updated (content mismatch)
+                    { id: "rec-2", type: "CNAME", name: "blog.example.com", content: "old.example.com", proxied: false },
+                    // Duplicate/stale record of a declared name/type - should be deleted
+                    { id: "rec-3", type: "A", name: "www.example.com", content: "8.8.8.8", proxied: true }
+                ]
+            }
+        };
+        mockResponses["PUT /zones/zone-123/dns_records/rec-2"] = {
+            status: 200,
+            body: { result: { id: "rec-2" } }
+        };
+        mockResponses["POST /zones/zone-123/dns_records"] = {
+            status: 200,
+            body: { result: { id: "rec-4" } }
+        };
+        mockResponses["DELETE /zones/zone-123/dns_records/rec-3"] = {
+            status: 200,
+            body: {}
+        };
+        const builder = new ZoneBuilder("example.com");
+        // rec-1
+        builder.pointer("www", "1.1.1.1", true);
+        // rec-2 (updated)
+        builder.cname("blog", "new.example.com", false);
+        // rec-4 (created)
+        builder.pointer("api", "2.2.2.2", false);
+        await builder.deploy();
+        const putCall = fetchCalls.find(c => c.method === "PUT");
+        assert.ok(putCall);
+        assert.ok(putCall.url.endsWith("/zones/zone-123/dns_records/rec-2"));
+        assert.deepStrictEqual(putCall.body, {
+            type: "CNAME",
+            name: "blog",
+            content: "new.example.com",
+            ttl: 3600,
+            proxied: false
+        });
+        const postCall = fetchCalls.find(c => c.method === "POST" && c.url.includes("/dns_records"));
+        assert.ok(postCall);
+        assert.ok(postCall.url.endsWith("/zones/zone-123/dns_records"));
+        assert.deepStrictEqual(postCall.body, {
+            type: "A",
+            name: "api",
+            content: "2.2.2.2",
+            ttl: 3600,
+            proxied: false
+        });
+        const deleteCall = fetchCalls.find(c => c.method === "DELETE");
+        assert.ok(deleteCall);
+        assert.ok(deleteCall.url.endsWith("/zones/zone-123/dns_records/rec-3"));
+    });
+    test("loads records from configuration file (YAML) successfully", async () => {
+        mockResponses["GET /zones?name=file-example.com"] = {
+            status: 200,
+            body: {
+                result: [{ id: "zone-555", name: "file-example.com" }]
+            }
+        };
+        mockResponses["GET /zones/zone-555/dns_records?per_page=100"] = {
+            status: 200,
+            body: { result: [] }
+        };
+        mockResponses["POST /zones/zone-555/dns_records"] = {
+            status: 200,
+            body: { result: { id: "rec-new" } }
+        };
+        const tempYamlPath = path.resolve(process.cwd(), "temp-cf-records.yaml");
+        const yamlContent = `
+- name: mail
+  type: MX
+  value: mail.file-example.com
+  priority: 5
+- name: _sip._udp
+  type: SRV
+  value: sip.file-example.com
+  port: 5061
+  priority: 20
+  weight: 20
+- name: '@'
+  type: CAA
+  value: letsencrypt.org
+  tag: issue
+  flags: 0
+`;
+        fs.writeFileSync(tempYamlPath, yamlContent, "utf-8");
+        try {
+            const builder = new ZoneBuilder("file-example.com")
+                .record("temp-cf-records.yaml");
+            await builder.deploy();
+            const mxPost = fetchCalls.find(c => c.method === "POST" && c.body?.type === "MX");
+            assert.ok(mxPost);
+            assert.deepStrictEqual(mxPost.body, {
+                type: "MX",
+                name: "mail",
+                content: "mail.file-example.com",
+                ttl: 3600,
+                priority: 5
+            });
+            const srvPost = fetchCalls.find(c => c.method === "POST" && c.body?.type === "SRV");
+            assert.ok(srvPost);
+            assert.deepStrictEqual(srvPost.body, {
+                type: "SRV",
+                name: "_sip._udp",
+                ttl: 3600,
+                data: {
+                    priority: 20,
+                    weight: 20,
+                    port: 5061,
+                    target: "sip.file-example.com"
+                }
+            });
+            const caaPost = fetchCalls.find(c => c.method === "POST" && c.body?.type === "CAA");
+            assert.ok(caaPost);
+            assert.deepStrictEqual(caaPost.body, {
+                type: "CAA",
+                name: "@",
+                ttl: 3600,
+                data: {
+                    flags: 0,
+                    tag: "issue",
+                    value: "letsencrypt.org"
+                }
+            });
+        }
+        finally {
+            if (fs.existsSync(tempYamlPath))
+                fs.unlinkSync(tempYamlPath);
+        }
+    });
+    test("destroys zone successfully if exists", async () => {
+        mockResponses["GET /zones?name=example.com"] = {
+            status: 200,
+            body: {
+                result: [
+                    { id: "zone-123", name: "example.com" }
+                ]
+            }
+        };
+        mockResponses["DELETE /zones/zone-123"] = {
+            status: 200,
+            body: {}
+        };
+        const builder = new ZoneBuilder("example.com");
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: "example.com" });
+        const deleteCall = fetchCalls.find(c => c.method === "DELETE");
+        assert.ok(deleteCall);
+        assert.ok(deleteCall.url.endsWith("/zones/zone-123"));
+    });
+});

package/dist/providers/firebase/auth.test.d.ts

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