puls-dev 0.1.9 → 0.2.1

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

@@ -0,0 +1,133 @@
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { CertificateBuilder } from './certificate.js';
+import { Config } from '../../core/config.js';
+describe('CertificateBuilder Unit Tests', () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                do: { token: 'fake-do-token' }
+            }
+        });
+        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).find(key => {
+                const [mMethod, mPath] = key.split(' ');
+                return method === mMethod && url.includes(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 () => ({ message: 'Not found' }),
+                text: async () => 'Not found',
+            };
+        };
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    test('gracefully handles discovery when certificate does not exist', async () => {
+        mockResponses['GET /certificates'] = {
+            status: 200,
+            body: { certificates: [] }
+        };
+        const builder = new CertificateBuilder('example.com');
+        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.endsWith('/certificates?per_page=200'));
+    });
+    test('discovers certificate successfully when it exists', async () => {
+        mockResponses['GET /certificates'] = {
+            status: 200,
+            body: {
+                certificates: [
+                    { id: 'cert-123', name: 'ssl-example.com', state: 'active' }
+                ]
+            }
+        };
+        const builder = new CertificateBuilder('example.com');
+        const discoveryResult = await builder.discoveryPromise;
+        assert.ok(discoveryResult);
+        assert.strictEqual(discoveryResult.id, 'cert-123');
+        assert.strictEqual(discoveryResult.name, 'ssl-example.com');
+    });
+    test('performs clean dry-run planning without making write requests', async () => {
+        Config.set({
+            dryRun: true,
+            providers: { do: { token: 'fake-token' } }
+        });
+        mockResponses['GET /certificates'] = {
+            status: 200,
+            body: { certificates: [] }
+        };
+        const builder = new CertificateBuilder('example.com');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, 'ssl-example.com');
+        const writeCalls = fetchCalls.filter(c => c.method !== 'GET');
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test('deploys new certificate when missing', async () => {
+        mockResponses['GET /certificates'] = {
+            status: 200,
+            body: { certificates: [] }
+        };
+        mockResponses['POST /certificates'] = {
+            status: 201,
+            body: {
+                certificate: { id: 'cert-789', name: 'ssl-example.com', type: 'lets_encrypt' }
+            }
+        };
+        const builder = new CertificateBuilder('example.com');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.id, 'cert-789');
+        const postCall = fetchCalls.find(c => c.method === 'POST');
+        assert.ok(postCall);
+        assert.ok(postCall.url.endsWith('/certificates'));
+        assert.deepStrictEqual(postCall.body, {
+            name: 'ssl-example.com',
+            type: 'lets_encrypt',
+            dns_names: ['*.example.com', 'example.com']
+        });
+    });
+    test('skips certificate deployment if certificate already exists', async () => {
+        mockResponses['GET /certificates'] = {
+            status: 200,
+            body: {
+                certificates: [
+                    { id: 'cert-123', name: 'ssl-example.com', state: 'active' }
+                ]
+            }
+        };
+        const builder = new CertificateBuilder('example.com');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.id, 'cert-123');
+        // Only GET discovery should have run, no writes
+        const writeCalls = fetchCalls.filter(c => c.method !== 'GET');
+        assert.strictEqual(writeCalls.length, 0);
+    });
+});

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

@@ -2,9 +2,14 @@ import { BaseBuilder } from "../../core/resource.js";
 import { Output } from "../../core/output.js";
 import { DropletBuilder } from "./droplet.js";
 export interface DNSRecord {
-    type: "A" | "CNAME" | "TXT" | "MX";
+    type: "A" | "CNAME" | "TXT" | "MX" | "AAAA" | "SRV" | "CAA";
     name: string;
     value: string | DropletBuilder | Output<string>;
+    priority?: number;
+    port?: number;
+    weight?: number;
+    flags?: number;
+    tag?: string;
 }
 export declare class DomainBuilder extends BaseBuilder {
     domainName: string;
@@ -14,8 +19,14 @@ export declare class DomainBuilder extends BaseBuilder {
     withSSL(): this;
     pointer(name: string, target: DropletBuilder | Output<string> | string): this;
     cname(name: string, target: string): this;
+    aaaa(name: string, target: string | Output<string>): 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<{
         domain: string;
         records: DNSRecord[];
     }>;
+    destroy(): Promise<any>;
 }

package/dist/providers/do/domain.js

@@ -35,6 +35,26 @@ export class DomainBuilder extends BaseBuilder {
         this.records.push({ type: "CNAME", name, value: target });
         return this;
     }
+    aaaa(name, target) {
+        this.records.push({ type: "AAAA", name, value: target });
+        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;
@@ -49,6 +69,19 @@ export class DomainBuilder extends BaseBuilder {
                 console.log(`🚀 Created domain ${this.domainName}`);
             }
         }
+        // Fetch existing records in a single batch
+        let existingRecords = [];
+        if (existing) {
+            try {
+                const res = await api.get(`/domains/${this.domainName}/records?per_page=200`);
+                existingRecords = res.domain_records;
+            }
+            catch {
+                existingRecords = [];
+            }
+        }
+        // Track matched existing records
+        const consumedRecordIds = new Set();
         for (const record of this.records) {
             let data;
             if (record.value instanceof Output) {
@@ -62,24 +95,107 @@ export class DomainBuilder extends BaseBuilder {
             else {
                 data = record.value;
             }
-            if (dryRun) {
-                console.log(`   📝 [PLAN] ${record.type} ${record.name}.${this.domainName} → ${data}`);
+            const targetPriority = record.priority ?? null;
+            const targetPort = record.port ?? null;
+            const targetWeight = record.weight ?? null;
+            const targetFlags = record.flags ?? null;
+            const targetTag = record.tag ?? null;
+            // 1. Check for a perfect match
+            const perfectMatch = existingRecords.find((r) => {
+                if (consumedRecordIds.has(r.id))
+                    return false;
+                return (r.type === record.type &&
+                    r.name === record.name &&
+                    String(r.data) === String(data) &&
+                    (r.priority ?? null) === targetPriority &&
+                    (r.port ?? null) === targetPort &&
+                    (r.weight ?? null) === targetWeight &&
+                    (r.flags ?? null) === targetFlags &&
+                    (r.tag ?? null) === targetTag);
+            });
+            if (perfectMatch) {
+                consumedRecordIds.add(perfectMatch.id);
+                console.log(`   ✅ ${record.type} ${record.name}.${this.domainName} is up to date (→ ${data})`);
                 continue;
             }
-            // Delete existing record with same type+name before creating
-            const existing_records = await api.get(`/domains/${this.domainName}/records?per_page=200`);
-            const dupe = existing_records.domain_records.find((r) => r.type === record.type && r.name === record.name);
-            if (dupe)
-                await api.delete(`/domains/${this.domainName}/records/${dupe.id}`);
-            await api.post(`/domains/${this.domainName}/records`, {
-                type: record.type,
-                name: record.name,
-                data,
-                ttl: 3600,
+            // 2. Look for updateable match (same type and name, different data)
+            const updateableMatch = existingRecords.find((r) => {
+                if (consumedRecordIds.has(r.id))
+                    return false;
+                return r.type === record.type && r.name === record.name;
             });
-            console.log(`   ✅ ${record.type} ${record.name}.${this.domainName} → ${data}`);
+            if (updateableMatch) {
+                consumedRecordIds.add(updateableMatch.id);
+                if (dryRun) {
+                    console.log(`   📝 [PLAN] Update ${record.type} ${record.name}.${this.domainName} → ${data} (was ${updateableMatch.data})`);
+                }
+                else {
+                    await api.put(`/domains/${this.domainName}/records/${updateableMatch.id}`, {
+                        type: record.type,
+                        name: record.name,
+                        data,
+                        ttl: 3600,
+                        priority: targetPriority,
+                        port: targetPort,
+                        weight: targetWeight,
+                        flags: targetFlags,
+                        tag: targetTag,
+                    });
+                    console.log(`   🔄 Updated ${record.type} ${record.name}.${this.domainName} → ${data}`);
+                }
+            }
+            else {
+                // 3. No match found, create a new record
+                if (dryRun) {
+                    console.log(`   📝 [PLAN] Create ${record.type} ${record.name}.${this.domainName} → ${data}`);
+                }
+                else {
+                    await api.post(`/domains/${this.domainName}/records`, {
+                        type: record.type,
+                        name: record.name,
+                        data,
+                        ttl: 3600,
+                        priority: targetPriority,
+                        port: targetPort,
+                        weight: targetWeight,
+                        flags: targetFlags,
+                        tag: targetTag,
+                    });
+                    console.log(`   🚀 Created ${record.type} ${record.name}.${this.domainName} → ${data}`);
+                }
+            }
+        }
+        // 4. Delete duplicate/stale records of the types we declared
+        const declaredTypesAndNames = new Set(this.records.map((r) => `${r.type}:${r.name}`));
+        for (const r of existingRecords) {
+            if (consumedRecordIds.has(r.id))
+                continue;
+            if (declaredTypesAndNames.has(`${r.type}:${r.name}`)) {
+                if (dryRun) {
+                    console.log(`   📝 [PLAN] Delete stale ${r.type} ${r.name}.${this.domainName} (→ ${r.data})`);
+                }
+                else {
+                    await api.delete(`/domains/${this.domainName}/records/${r.id}`);
+                    console.log(`   🗑️  Deleted stale ${r.type} ${r.name}.${this.domainName}`);
+                }
+            }
         }
         await this.deploySidecars();
         return { domain: this.domainName, records: this.records };
     }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        await this.discoveryPromise;
+        console.log(`\n🗑️  Destroying DNS domain "${this.domainName}"...`);
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Would delete domain ${this.domainName}`);
+        }
+        else {
+            const api = getDoApi();
+            await api.delete(`/domains/${this.domainName}`);
+            console.log(`   ✅ Deleted.`);
+        }
+        await this.destroySidecars();
+        return { destroyed: this.domainName };
+    }
 }

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

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

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

@@ -0,0 +1,200 @@
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import { DomainBuilder } from "./domain.js";
+import { Config } from "../../core/config.js";
+describe("DomainBuilder Unit Tests", () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                do: { token: "fake-do-token" }
+            }
+        });
+        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).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 () => ({ message: "Not found" }),
+                text: async () => "Not found",
+            };
+        };
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    test("gracefully handles discovery when domain does not exist", async () => {
+        mockResponses["GET /domains/new-domain.com"] = {
+            status: 404,
+            body: { message: "Domain not found" }
+        };
+        const builder = new DomainBuilder("new-domain.com");
+        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.endsWith("/domains/new-domain.com"));
+    });
+    test("discovers domain successfully when it exists", async () => {
+        mockResponses["GET /domains/exists.com"] = {
+            status: 200,
+            body: {
+                domain: {
+                    name: "exists.com",
+                    ttl: 1800,
+                    zone_file: "..."
+                }
+            }
+        };
+        const builder = new DomainBuilder("exists.com");
+        const discoveryResult = await builder.discoveryPromise;
+        assert.ok(discoveryResult);
+        assert.strictEqual(discoveryResult.name, "exists.com");
+        assert.strictEqual(fetchCalls.length, 1);
+    });
+    test("performs clean dry-run planning without making write requests", async () => {
+        Config.set({
+            dryRun: true,
+            providers: { do: { token: "fake-token" } }
+        });
+        mockResponses["GET /domains/dryrun.com"] = {
+            status: 404,
+            body: { message: "Domain not found" }
+        };
+        const builder = new DomainBuilder("dryrun.com");
+        builder.pointer("www", "1.2.3.4");
+        builder.cname("blog", "blog.dryrun.com");
+        const result = await builder.deploy();
+        assert.deepStrictEqual(result, {
+            domain: "dryrun.com",
+            records: [
+                { type: "A", name: "www", value: "1.2.3.4" },
+                { type: "CNAME", name: "blog", value: "blog.dryrun.com" }
+            ]
+        });
+        const writeCalls = fetchCalls.filter(c => c.method !== "GET");
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test("deploys new domain and creates records when domain is missing", async () => {
+        mockResponses["GET /domains/new.com"] = {
+            status: 404,
+            body: { message: "Domain not found" }
+        };
+        mockResponses["POST /domains"] = {
+            status: 201,
+            body: { domain: { name: "new.com" } }
+        };
+        mockResponses["POST /domains/new.com/records"] = {
+            status: 201,
+            body: { domain_record: { id: 101 } }
+        };
+        const builder = new DomainBuilder("new.com");
+        builder.pointer("www", "5.6.7.8");
+        await builder.deploy();
+        assert.strictEqual(fetchCalls.length, 3);
+        assert.strictEqual(fetchCalls[0].method, "GET");
+        assert.strictEqual(fetchCalls[1].method, "POST");
+        assert.ok(fetchCalls[1].url.endsWith("/domains"));
+        assert.deepStrictEqual(fetchCalls[1].body, { name: "new.com" });
+        assert.strictEqual(fetchCalls[2].method, "POST");
+        assert.ok(fetchCalls[2].url.endsWith("/domains/new.com/records"));
+        assert.deepStrictEqual(fetchCalls[2].body, {
+            type: "A",
+            name: "www",
+            data: "5.6.7.8",
+            ttl: 3600,
+            priority: null,
+            port: null,
+            weight: null,
+            flags: null,
+            tag: null
+        });
+    });
+    test("syncs records: skips matching, updates out-of-date, deletes stale/duplicate", async () => {
+        mockResponses["GET /domains/sync.com"] = {
+            status: 200,
+            body: { domain: { name: "sync.com" } }
+        };
+        mockResponses["GET /domains/sync.com/records?per_page=200"] = {
+            status: 200,
+            body: {
+                domain_records: [
+                    { id: 10, type: "A", name: "www", data: "1.1.1.1" },
+                    { id: 20, type: "A", name: "api", data: "2.2.2.2" },
+                    { id: 30, type: "A", name: "api", data: "4.4.4.4" }
+                ]
+            }
+        };
+        mockResponses["PUT /domains/sync.com/records/20"] = {
+            status: 200,
+            body: { domain_record: { id: 20 } }
+        };
+        mockResponses["DELETE /domains/sync.com/records/30"] = {
+            status: 204,
+            body: {}
+        };
+        const builder = new DomainBuilder("sync.com");
+        builder.pointer("www", "1.1.1.1");
+        builder.pointer("api", "3.3.3.3");
+        await builder.deploy();
+        const putCall = fetchCalls.find(c => c.method === "PUT");
+        assert.ok(putCall);
+        assert.ok(putCall.url.endsWith("/domains/sync.com/records/20"));
+        assert.deepStrictEqual(putCall.body, {
+            type: "A",
+            name: "api",
+            data: "3.3.3.3",
+            ttl: 3600,
+            priority: null,
+            port: null,
+            weight: null,
+            flags: null,
+            tag: null
+        });
+        const deleteCall = fetchCalls.find(c => c.method === "DELETE");
+        assert.ok(deleteCall);
+        assert.ok(deleteCall.url.endsWith("/domains/sync.com/records/30"));
+        const postCall = fetchCalls.find(c => c.method === "POST");
+        assert.strictEqual(postCall, undefined);
+    });
+    test("destroys domain successfully", async () => {
+        mockResponses["GET /domains/destroy.com"] = {
+            status: 200,
+            body: { domain: { name: "destroy.com" } }
+        };
+        mockResponses["DELETE /domains/destroy.com"] = {
+            status: 204,
+            body: {}
+        };
+        const builder = new DomainBuilder("destroy.com");
+        await builder.discoveryPromise;
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: "destroy.com" });
+        const deleteCall = fetchCalls.find(c => c.method === "DELETE");
+        assert.ok(deleteCall);
+        assert.ok(deleteCall.url.endsWith("/domains/destroy.com"));
+    });
+});

package/dist/providers/do/droplet.js

@@ -1,4 +1,4 @@
-import { readFileSync } from 'fs';
+import fs from 'fs';
 import { homedir } from 'os';
 import { OS, REGION, SIZE, NETWORK } from '../../types/do.js';
 import { Config } from '../../core/config.js';
@@ -71,7 +71,7 @@ export class DropletBuilder extends BaseBuilder {
     }
     async resolveOrRegisterSshKey(api) {
         const pubPath = this.sshKeyPath.replace(/\.pub$/, '') + '.pub';
-        const pubKey = readFileSync(pubPath, 'utf8').trim();
+        const pubKey = fs.readFileSync(pubPath, 'utf8').trim();
         const { ssh_keys } = await api.get('/account/keys?per_page=200');
         const existing = ssh_keys.find(k => k.public_key.trim() === pubKey);
         if (existing)

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

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