puls-dev 0.1.8 → 0.2.0

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

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

@@ -0,0 +1,265 @@
+import { test, describe, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import { DropletBuilder } from './droplet.js';
+import { Config } from '../../core/config.js';
+describe('DropletBuilder Unit Tests', () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                do: { token: 'fake-do-token', defaultRegion: 'nyc3' }
+            }
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? 'GET';
+            const body = init?.body ? JSON.parse(init.body) : undefined;
+            const headers = init?.headers;
+            fetchCalls.push({ url, method, body, headers });
+            const matchKey = Object.keys(mockResponses)
+                .filter(key => {
+                const [mMethod, mPath] = key.split(' ');
+                return method === mMethod && url.includes(mPath);
+            })
+                .sort((a, b) => b.split(' ')[1].length - a.split(' ')[1].length)[0];
+            if (matchKey) {
+                const resp = mockResponses[matchKey];
+                return {
+                    ok: resp.status >= 200 && resp.status < 300,
+                    status: resp.status,
+                    json: async () => resp.body,
+                    text: async () => JSON.stringify(resp.body),
+                };
+            }
+            return {
+                ok: false,
+                status: 404,
+                json: async () => ({ message: 'Not found' }),
+                text: async () => 'Not found',
+            };
+        };
+        // Mock readFileSync so tests don't hit the real filesystem for SSH keys
+        mock.method(fs, 'readFileSync', () => {
+            return 'ssh-rsa AAAA_FAKE_PUBLIC_KEY test@example.com';
+        });
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        mock.restoreAll();
+    });
+    test('gracefully handles discovery when droplet does not exist', async () => {
+        mockResponses['GET /droplets'] = {
+            status: 200,
+            body: { droplets: [] }
+        };
+        const builder = new DropletBuilder('my-droplet');
+        const discoveryResult = await builder.discoveryPromise;
+        assert.strictEqual(discoveryResult, null);
+        assert.strictEqual(fetchCalls.length, 1);
+        assert.strictEqual(fetchCalls[0].method, 'GET');
+        assert.ok(fetchCalls[0].url.includes('/droplets?name=my-droplet'));
+    });
+    test('discovers droplet successfully when it exists', async () => {
+        mockResponses['GET /droplets'] = {
+            status: 200,
+            body: {
+                droplets: [
+                    {
+                        id: 123,
+                        name: 'my-droplet',
+                        networks: {
+                            v4: [{ ip_address: '1.2.3.4', type: 'public' }]
+                        }
+                    }
+                ]
+            }
+        };
+        const builder = new DropletBuilder('my-droplet');
+        const discoveryResult = await builder.discoveryPromise;
+        assert.ok(discoveryResult);
+        assert.strictEqual(discoveryResult.id, 123);
+        assert.strictEqual(discoveryResult.name, 'my-droplet');
+        const resolvedId = await builder.out.id.get();
+        const resolvedIp = await builder.out.ip.get();
+        assert.strictEqual(resolvedId, 123);
+        assert.strictEqual(resolvedIp, '1.2.3.4');
+    });
+    test('performs clean dry-run planning without making write requests', async () => {
+        Config.set({
+            dryRun: true,
+            providers: { do: { token: 'fake-token' } }
+        });
+        mockResponses['GET /droplets'] = {
+            status: 200,
+            body: { droplets: [] }
+        };
+        const builder = new DropletBuilder('my-droplet');
+        builder
+            .region('nyc3')
+            .size('s-1vcpu-1gb')
+            .sslKey('~/.ssh/id_rsa.pub');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.region, 'nyc3');
+        assert.strictEqual(result.size, 's-1vcpu-1gb');
+        const writeCalls = fetchCalls.filter(c => c.method !== 'GET');
+        assert.strictEqual(writeCalls.length, 0);
+        const resolvedId = await builder.out.id.get();
+        const resolvedIp = await builder.out.ip.get();
+        assert.strictEqual(resolvedId, -1);
+        assert.strictEqual(resolvedIp, '0.0.0.0');
+    });
+    test('deploys new droplet, registers SSH key, and awaits status: active', async () => {
+        mockResponses['GET /droplets'] = {
+            status: 200,
+            body: { droplets: [] }
+        };
+        mockResponses['GET /account/keys'] = {
+            status: 200,
+            body: { ssh_keys: [] } // SSH key does not exist yet
+        };
+        mockResponses['POST /account/keys'] = {
+            status: 201,
+            body: { ssh_key: { id: 999, name: 'id_rsa' } }
+        };
+        mockResponses['POST /droplets'] = {
+            status: 202,
+            body: { droplet: { id: 12345, name: 'my-droplet' } }
+        };
+        // First poll returns state: new, second poll returns state: active
+        let pollCount = 0;
+        mockResponses['GET /droplets/12345'] = {
+            status: 200,
+            get body() {
+                pollCount++;
+                if (pollCount === 1) {
+                    return { droplet: { status: 'new' } };
+                }
+                return {
+                    droplet: {
+                        status: 'active',
+                        networks: {
+                            v4: [{ ip_address: '9.9.9.9', type: 'public' }]
+                        }
+                    }
+                };
+            }
+        };
+        const builder = new DropletBuilder('my-droplet');
+        builder
+            .region('nyc3')
+            .size('s-1vcpu-1gb')
+            .sslKey('/path/to/id_rsa.pub');
+        // Override the protected waitFor method to poll instantly
+        builder.waitFor = async (label, condition) => {
+            let done = false;
+            while (!done) {
+                done = await condition();
+            }
+        };
+        const result = await builder.deploy();
+        assert.ok(result);
+        const resolvedId = await builder.out.id.get();
+        const resolvedIp = await builder.out.ip.get();
+        assert.strictEqual(resolvedId, 12345);
+        assert.strictEqual(resolvedIp, '9.9.9.9');
+        // Assert SSH key registration was posted
+        const sshKeyRegisterCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes('/account/keys'));
+        assert.ok(sshKeyRegisterCall);
+        assert.deepStrictEqual(sshKeyRegisterCall.body, {
+            name: 'id_rsa',
+            public_key: 'ssh-rsa AAAA_FAKE_PUBLIC_KEY test@example.com'
+        });
+        // Assert Droplet creation was posted with registered SSH key ID
+        const dropletCreateCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes('/droplets'));
+        assert.ok(dropletCreateCall);
+        assert.deepStrictEqual(dropletCreateCall.body.ssh_keys, [999]);
+    });
+    test('skips update deployment if droplet configuration is up-to-date', async () => {
+        mockResponses['GET /droplets'] = {
+            status: 200,
+            body: {
+                droplets: [
+                    {
+                        id: 123,
+                        name: 'my-droplet',
+                        size_slug: 's-1vcpu-1gb',
+                        region: { slug: 'nyc3' },
+                        networks: {
+                            v4: [{ ip_address: '1.2.3.4', type: 'public' }]
+                        }
+                    }
+                ]
+            }
+        };
+        const builder = new DropletBuilder('my-droplet');
+        builder
+            .region('nyc3')
+            .size('s-1vcpu-1gb');
+        await builder.deploy();
+        // Verify no POST writes or updates
+        const writeCalls = fetchCalls.filter(c => c.method === 'POST' || c.method === 'PUT');
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test('resizes existing droplet when size configuration changes', async () => {
+        mockResponses['GET /droplets'] = {
+            status: 200,
+            body: {
+                droplets: [
+                    {
+                        id: 123,
+                        name: 'my-droplet',
+                        size_slug: 's-1vcpu-1gb', // different from desired s-2vcpu-2gb
+                        region: { slug: 'nyc3' },
+                        networks: {
+                            v4: [{ ip_address: '1.2.3.4', type: 'public' }]
+                        }
+                    }
+                ]
+            }
+        };
+        mockResponses['POST /droplets/123/actions'] = {
+            status: 201,
+            body: { action: { id: 888, status: 'in-progress', type: 'resize' } }
+        };
+        const builder = new DropletBuilder('my-droplet');
+        builder
+            .region('nyc3')
+            .size('s-2vcpu-2gb');
+        await builder.deploy();
+        const resizeCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes('/droplets/123/actions'));
+        assert.ok(resizeCall);
+        assert.deepStrictEqual(resizeCall.body, {
+            type: 'resize',
+            size: 's-2vcpu-2gb'
+        });
+    });
+    test('destroys droplet successfully', async () => {
+        mockResponses['GET /droplets'] = {
+            status: 200,
+            body: {
+                droplets: [
+                    { id: 123, name: 'my-droplet' }
+                ]
+            }
+        };
+        mockResponses['DELETE /droplets/123'] = {
+            status: 204,
+            body: {}
+        };
+        const builder = new DropletBuilder('my-droplet');
+        await builder.discoveryPromise;
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: 'my-droplet' });
+        const deleteCall = fetchCalls.find(c => c.method === 'DELETE');
+        assert.ok(deleteCall);
+        assert.ok(deleteCall.url.endsWith('/droplets/123'));
+    });
+});

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

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

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

@@ -0,0 +1,176 @@
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { FirewallBuilder } from './firewall.js';
+import { Config } from '../../core/config.js';
+describe('FirewallBuilder 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 firewall does not exist', async () => {
+        mockResponses['GET /firewalls'] = {
+            status: 200,
+            body: { firewalls: [] }
+        };
+        const builder = new FirewallBuilder('my-fw');
+        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('/firewalls?per_page=200'));
+    });
+    test('discovers firewall successfully when it exists', async () => {
+        mockResponses['GET /firewalls'] = {
+            status: 200,
+            body: {
+                firewalls: [
+                    { id: 'fw-123', name: 'my-fw' }
+                ]
+            }
+        };
+        const builder = new FirewallBuilder('my-fw');
+        const discoveryResult = await builder.discoveryPromise;
+        assert.ok(discoveryResult);
+        assert.strictEqual(discoveryResult.id, 'fw-123');
+        assert.strictEqual(discoveryResult.name, 'my-fw');
+    });
+    test('performs clean dry-run planning without making write requests', async () => {
+        Config.set({
+            dryRun: true,
+            providers: { do: { token: 'fake-token' } }
+        });
+        mockResponses['GET /firewalls'] = {
+            status: 200,
+            body: { firewalls: [] }
+        };
+        const builder = new FirewallBuilder('my-fw');
+        builder
+            .ingress('tcp', 80, ['0.0.0.0/0'])
+            .egress('tcp', 'all', ['0.0.0.0/0'])
+            .attachTo('app-vm');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, 'my-fw');
+        const writeCalls = fetchCalls.filter(c => c.method !== 'GET');
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test('deploys new firewall, resolves droplet names, and posts creation request', async () => {
+        mockResponses['GET /firewalls'] = {
+            status: 200,
+            body: { firewalls: [] }
+        };
+        mockResponses['GET /droplets?name=app-vm-1'] = {
+            status: 200,
+            body: { droplets: [{ id: 111, name: 'app-vm-1' }] }
+        };
+        mockResponses['GET /droplets?name=app-vm-2'] = {
+            status: 200,
+            body: { droplets: [{ id: 222, name: 'app-vm-2' }] }
+        };
+        mockResponses['POST /firewalls'] = {
+            status: 201,
+            body: {
+                firewall: { id: 'fw-789', name: 'my-fw' }
+            }
+        };
+        const builder = new FirewallBuilder('my-fw');
+        builder
+            .ingress('tcp', 80, ['0.0.0.0/0'])
+            .egress('tcp', 'all', ['0.0.0.0/0'])
+            .attachTo('app-vm-1')
+            .attachTo('app-vm-2');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, 'my-fw');
+        const postCall = fetchCalls.find(c => c.method === 'POST');
+        assert.ok(postCall);
+        assert.ok(postCall.url.endsWith('/firewalls'));
+        assert.deepStrictEqual(postCall.body, {
+            name: 'my-fw',
+            inbound_rules: [
+                { protocol: 'tcp', ports: '80', sources: { addresses: ['0.0.0.0/0'] } }
+            ],
+            outbound_rules: [
+                { protocol: 'tcp', ports: 'all', destinations: { addresses: ['0.0.0.0/0'] } }
+            ],
+            droplet_ids: [111, 222]
+        });
+    });
+    test('updates existing firewall using PUT', async () => {
+        mockResponses['GET /firewalls'] = {
+            status: 200,
+            body: {
+                firewalls: [
+                    { id: 'fw-123', name: 'my-fw' }
+                ]
+            }
+        };
+        mockResponses['GET /droplets?name=app-vm-1'] = {
+            status: 200,
+            body: { droplets: [{ id: 111, name: 'app-vm-1' }] }
+        };
+        mockResponses['PUT /firewalls/fw-123'] = {
+            status: 200,
+            body: {
+                firewall: { id: 'fw-123', name: 'my-fw' }
+            }
+        };
+        const builder = new FirewallBuilder('my-fw');
+        builder
+            .ingress('tcp', 443, ['0.0.0.0/0'])
+            .attachTo('app-vm-1');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, 'my-fw');
+        const putCall = fetchCalls.find(c => c.method === 'PUT');
+        assert.ok(putCall);
+        assert.ok(putCall.url.endsWith('/firewalls/fw-123'));
+        assert.deepStrictEqual(putCall.body, {
+            name: 'my-fw',
+            inbound_rules: [
+                { protocol: 'tcp', ports: '443', sources: { addresses: ['0.0.0.0/0'] } }
+            ],
+            outbound_rules: [],
+            droplet_ids: [111]
+        });
+    });
+});

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

@@ -13,3 +13,4 @@ export declare const DO: {
     Certificate: (name: string) => CertificateBuilder;
     LoadBalancer: (name: string) => LoadBalancerBuilder;
 };
+export * from "../../types/do.js";

package/dist/providers/do/index.js

@@ -19,3 +19,4 @@ export const DO = {
     Certificate: (name) => new CertificateBuilder(name),
     LoadBalancer: (name) => new LoadBalancerBuilder(name),
 };
+export * from "../../types/do.js";