puls-dev 0.1.8 → 0.2.0

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

@@ -1,12 +1,46 @@
+import { BaseBuilder } from '../../core/resource.js';
 import { DropletBuilder } from './droplet.js';
-export declare class LoadBalancerBuilder {
-    private name;
-    private config;
+import { CertificateBuilder } from './certificate.js';
+export interface HealthCheckOpts {
+    protocol: 'http' | 'https' | 'tcp';
+    port: number;
+    path?: string;
+    checkIntervalSeconds?: number;
+    responseTimeoutSeconds?: number;
+    unhealthyThreshold?: number;
+    healthyThreshold?: number;
+}
+export interface StickySessionOpts {
+    type: 'cookies' | 'none';
+    cookieName?: string;
+    cookieTtlSeconds?: number;
+}
+export interface ForwardingRule {
+    entryProtocol: 'http' | 'https' | 'tcp' | string;
+    entryPort: number;
+    targetProtocol: 'http' | 'https' | 'tcp' | string;
+    targetPort: number;
+    certificate?: string | CertificateBuilder;
+    tlsPassthrough?: boolean;
+}
+export declare class LoadBalancerBuilder extends BaseBuilder {
+    name: string;
+    private _region;
     private targetNames;
-    private discoveryPromise;
+    private forwardingRules;
+    private healthCheckConfig?;
+    private stickySessionConfig?;
+    private lbId?;
     constructor(name: string);
     private discoverLb;
-    private resolveDropletIds;
+    region(region: string): this;
     targets(droplets: (DropletBuilder | string)[]): this;
+    target(...droplets: (DropletBuilder | string)[]): this;
+    forward(entryProtocol: 'http' | 'https' | 'tcp' | string, entryPort: number, targetProtocol: 'http' | 'https' | 'tcp' | string, targetPort: number, certificate?: string | CertificateBuilder, tlsPassthrough?: boolean): this;
+    healthCheck(opts: HealthCheckOpts): this;
+    stickySession(type: 'cookies' | 'none', cookieName?: string, cookieTtlSeconds?: number): this;
+    private resolveDropletIds;
+    private resolveCertificateId;
     deploy(): Promise<any>;
+    destroy(): Promise<any>;
 }

package/dist/providers/do/load_balancer.js

@@ -1,20 +1,75 @@
+import { BaseBuilder } from '../../core/resource.js';
 import { Config } from '../../core/config.js';
+import { CertificateBuilder } from './certificate.js';
 import { getDoApi } from './api.js';
-export class LoadBalancerBuilder {
+export class LoadBalancerBuilder extends BaseBuilder {
     name;
-    config = {
-        region: Config.get().providers.do?.defaultRegion ?? 'fra1',
-    };
+    _region = Config.get().providers.do?.defaultRegion ?? 'fra1';
     targetNames = [];
-    discoveryPromise;
+    forwardingRules = [];
+    healthCheckConfig;
+    stickySessionConfig;
+    lbId;
     constructor(name) {
+        super(name);
         this.name = name;
         this.discoveryPromise = this.discoverLb(name);
     }
     async discoverLb(name) {
         const api = getDoApi();
-        const data = await api.get('/load_balancers?per_page=200');
-        return data.load_balancers.find(lb => lb.name === name) ?? null;
+        try {
+            const data = await api.get('/load_balancers?per_page=200');
+            const match = data.load_balancers.find(lb => lb.name === name) ?? null;
+            if (match) {
+                this.lbId = match.id;
+            }
+            return match;
+        }
+        catch {
+            return null;
+        }
+    }
+    region(region) {
+        this._region = region;
+        return this;
+    }
+    targets(droplets) {
+        this.targetNames = droplets.map(d => (typeof d === 'string' ? d : d.name));
+        return this;
+    }
+    target(...droplets) {
+        return this.targets(droplets);
+    }
+    forward(entryProtocol, entryPort, targetProtocol, targetPort, certificate, tlsPassthrough) {
+        this.forwardingRules.push({
+            entryProtocol,
+            entryPort,
+            targetProtocol,
+            targetPort,
+            certificate,
+            tlsPassthrough,
+        });
+        return this;
+    }
+    healthCheck(opts) {
+        this.healthCheckConfig = {
+            protocol: opts.protocol,
+            port: opts.port,
+            path: opts.path ?? (opts.protocol === 'tcp' ? undefined : '/'),
+            checkIntervalSeconds: opts.checkIntervalSeconds ?? 10,
+            responseTimeoutSeconds: opts.responseTimeoutSeconds ?? 5,
+            unhealthyThreshold: opts.unhealthyThreshold ?? 3,
+            healthyThreshold: opts.healthyThreshold ?? 5,
+        };
+        return this;
+    }
+    stickySession(type, cookieName, cookieTtlSeconds) {
+        this.stickySessionConfig = {
+            type,
+            ...(cookieName && { cookieName }),
+            ...(cookieTtlSeconds && { cookieTtlSeconds }),
+        };
+        return this;
     }
     async resolveDropletIds() {
         const api = getDoApi();
@@ -25,38 +80,225 @@ export class LoadBalancerBuilder {
             if (match)
                 ids.push(match.id);
         }
-        return ids;
+        return ids.sort((a, b) => a - b);
     }
-    targets(droplets) {
-        this.targetNames = droplets.map(d => (typeof d === 'string' ? d : d.name));
-        return this;
+    async resolveCertificateId(cert) {
+        const api = getDoApi();
+        const name = cert instanceof CertificateBuilder ? cert.name : cert;
+        // Check if it's already a UUID
+        if (typeof cert === 'string' && cert.length === 36 && cert.includes('-')) {
+            return cert;
+        }
+        const data = await api.get('/certificates?per_page=200');
+        const match = data.certificates.find(c => c.name === name || c.id === name);
+        if (!match) {
+            throw new Error(`[LoadBalancer:${this.name}] Certificate "${name}" not found in DO account.`);
+        }
+        return match.id;
     }
     async deploy() {
-        const dryRun = Config.isGlobalDryRun();
+        const dryRun = this.isDryRunActive();
         const existing = await this.discoveryPromise;
+        const api = getDoApi();
         console.log(`\n⚖️  Finalizing load balancer "${this.name}"...`);
+        // 1. Resolve Target Droplet IDs
+        const dropletIds = dryRun ? [12345] : await this.resolveDropletIds();
+        // 2. Build Forwarding Rules
+        const finalRules = [];
+        const rulesToResolve = this.forwardingRules.length > 0
+            ? this.forwardingRules
+            : [
+                {
+                    entryProtocol: 'http',
+                    entryPort: 80,
+                    targetProtocol: 'http',
+                    targetPort: 80,
+                }
+            ];
+        for (const rule of rulesToResolve) {
+            let certId;
+            if (rule.certificate) {
+                certId = dryRun ? 'mock-cert-uuid' : await this.resolveCertificateId(rule.certificate);
+            }
+            finalRules.push({
+                entry_protocol: rule.entryProtocol.toLowerCase(),
+                entry_port: rule.entryPort,
+                target_protocol: rule.targetProtocol.toLowerCase(),
+                target_port: rule.targetPort,
+                ...(certId && { certificate_id: certId }),
+                ...(rule.tlsPassthrough !== undefined && { tls_passthrough: rule.tlsPassthrough }),
+            });
+        }
+        // 3. Build Health Check Config
+        const finalHealthCheck = this.healthCheckConfig
+            ? {
+                protocol: this.healthCheckConfig.protocol.toLowerCase(),
+                port: this.healthCheckConfig.port,
+                ...(this.healthCheckConfig.path && { path: this.healthCheckConfig.path }),
+                check_interval_seconds: this.healthCheckConfig.checkIntervalSeconds,
+                response_timeout_seconds: this.healthCheckConfig.responseTimeoutSeconds,
+                unhealthy_threshold: this.healthCheckConfig.unhealthyThreshold,
+                healthy_threshold: this.healthCheckConfig.healthyThreshold,
+            }
+            : {
+                protocol: 'http',
+                port: 80,
+                path: '/',
+                check_interval_seconds: 10,
+                response_timeout_seconds: 5,
+                unhealthy_threshold: 3,
+                healthy_threshold: 5,
+            };
+        // 4. Build Sticky Sessions Config
+        const finalStickySessions = this.stickySessionConfig
+            ? {
+                type: this.stickySessionConfig.type,
+                ...(this.stickySessionConfig.cookieName && { cookie_name: this.stickySessionConfig.cookieName }),
+                ...(this.stickySessionConfig.cookieTtlSeconds && { cookie_ttl_seconds: this.stickySessionConfig.cookieTtlSeconds }),
+            }
+            : {
+                type: 'none',
+            };
+        // 5. Compare configuration for idempotent update
+        const resolvedRegion = this._region;
+        let hasChanges = true;
         if (existing) {
-            console.log(`✅ Load balancer ${this.name} already exists (ip=${existing.ip}).`);
+            const regionMatch = existing.region?.slug === resolvedRegion;
+            const dropletsMatch = arraysEqual(existing.droplet_ids, dropletIds);
+            const rulesMatch = rulesEqual(existing.forwarding_rules, finalRules);
+            const healthMatch = healthCheckEqual(existing.health_check, finalHealthCheck);
+            const stickyMatch = stickySessionsEqual(existing.sticky_sessions, finalStickySessions);
+            hasChanges = !regionMatch || !dropletsMatch || !rulesMatch || !healthMatch || !stickyMatch;
+        }
+        if (await this.checkProtection(hasChanges))
+            return null;
+        if (dryRun) {
+            if (!existing) {
+                console.log(`   📝 [PLAN] Create load balancer ${this.name} in ${resolvedRegion}`);
+                console.log(`      └─ Targets: [${this.targetNames.join(', ')}]`);
+                console.log(`      └─ Rules: ${JSON.stringify(finalRules)}`);
+                console.log(`      └─ Health Check: ${JSON.stringify(finalHealthCheck)}`);
+                console.log(`      └─ Sticky Sessions: ${JSON.stringify(finalStickySessions)}`);
+            }
+            else if (hasChanges) {
+                console.log(`   📝 [PLAN] Update load balancer ${this.name} in ${resolvedRegion}`);
+                console.log(`      └─ Target updates or config changes detected.`);
+                console.log(`      └─ Targets: [${this.targetNames.join(', ')}]`);
+                console.log(`      └─ Rules: ${JSON.stringify(finalRules)}`);
+            }
+            else {
+                console.log(`   ✅ Load balancer ${this.name} is up to date.`);
+            }
+            for (const sidecar of this.sidecars)
+                await sidecar.deploy();
+            return existing || { name: this.name, region: resolvedRegion, forwarding_rules: finalRules };
+        }
+        if (!existing) {
+            const result = await api.post('/load_balancers', {
+                name: this.name,
+                region: resolvedRegion,
+                forwarding_rules: finalRules,
+                health_check: finalHealthCheck,
+                sticky_sessions: finalStickySessions,
+                droplet_ids: dropletIds,
+            });
+            this.lbId = result.load_balancer.id;
+            console.log(`🚀 Created load balancer ${this.name} (id=${this.lbId})`);
+            if (this.targetNames.length)
+                console.log(`   Targets: [${this.targetNames.join(', ')}]`);
+            for (const sidecar of this.sidecars)
+                await sidecar.deploy();
+            return result.load_balancer;
+        }
+        else if (hasChanges) {
+            console.log(`✨ Updating load balancer ${this.name} (id=${this.lbId})...`);
+            const result = await api.put(`/load_balancers/${this.lbId}`, {
+                name: this.name,
+                region: resolvedRegion,
+                forwarding_rules: finalRules,
+                health_check: finalHealthCheck,
+                sticky_sessions: finalStickySessions,
+                droplet_ids: dropletIds,
+            });
+            console.log(`   ✅ Load balancer updated.`);
+            for (const sidecar of this.sidecars)
+                await sidecar.deploy();
+            return result.load_balancer;
+        }
+        else {
+            console.log(`✅ Load balancer ${this.name} is up to date.`);
+            for (const sidecar of this.sidecars)
+                await sidecar.deploy();
             return existing;
         }
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        await this.discoveryPromise;
+        if (!this.lbId) {
+            console.log(`\n🗑️  "${this.name}" not found, nothing to destroy.`);
+            return { destroyed: null };
+        }
+        console.log(`\n🗑️  Destroying load balancer "${this.name}" (id=${this.lbId})...`);
         if (dryRun) {
-            console.log(`   📝 [PLAN] Create load balancer ${this.name} targeting [${this.targetNames.join(', ')}]`);
-            return this.config;
+            console.log(`   📝 [PLAN] Would delete load balancer id=${this.lbId}`);
         }
-        const dropletIds = await this.resolveDropletIds();
-        const api = getDoApi();
-        const result = await api.post('/load_balancers', {
-            name: this.name,
-            region: this.config.region,
-            forwarding_rules: [
-                { entry_protocol: 'http', entry_port: 80, target_protocol: 'http', target_port: 80 },
-                { entry_protocol: 'https', entry_port: 443, target_protocol: 'http', target_port: 80 },
-            ],
-            droplet_ids: dropletIds,
-        });
-        console.log(`🚀 Created load balancer ${this.name} (id=${result.load_balancer.id})`);
-        if (this.targetNames.length)
-            console.log(`   Targets: [${this.targetNames.join(', ')}]`);
-        return result.load_balancer;
+        else {
+            await getDoApi().delete(`/load_balancers/${this.lbId}`);
+            console.log(`   ✅ Deleted.`);
+        }
+        await this.destroySidecars();
+        return { destroyed: this.name };
     }
 }
+// Helpers for structural comparisons
+function arraysEqual(a, b) {
+    if (!a || !b)
+        return a === b;
+    if (a.length !== b.length)
+        return false;
+    const sortedA = [...a].sort();
+    const sortedB = [...b].sort();
+    return sortedA.every((val, index) => val === sortedB[index]);
+}
+function rulesEqual(existingRules, targetRules) {
+    if (!existingRules || !targetRules)
+        return existingRules === targetRules;
+    if (existingRules.length !== targetRules.length)
+        return false;
+    const sortKey = (r) => `${r.entry_protocol}:${r.entry_port}:${r.target_protocol}:${r.target_port}`;
+    const sortedExisting = [...existingRules].sort((a, b) => sortKey(a).localeCompare(sortKey(b)));
+    const sortedTarget = [...targetRules].sort((a, b) => sortKey(a).localeCompare(sortKey(b)));
+    return sortedExisting.every((ext, i) => {
+        const tgt = sortedTarget[i];
+        return (ext.entry_protocol === tgt.entry_protocol &&
+            ext.entry_port === tgt.entry_port &&
+            ext.target_protocol === tgt.target_protocol &&
+            ext.target_port === tgt.target_port &&
+            (ext.certificate_id ?? '') === (tgt.certificate_id ?? '') &&
+            Boolean(ext.tls_passthrough) === Boolean(tgt.tls_passthrough));
+    });
+}
+function healthCheckEqual(ext, tgt) {
+    if (!ext || !tgt)
+        return ext === tgt;
+    return (ext.protocol === tgt.protocol &&
+        ext.port === tgt.port &&
+        (ext.path ?? '/') === (tgt.path ?? '/') &&
+        ext.check_interval_seconds === tgt.check_interval_seconds &&
+        ext.response_timeout_seconds === tgt.response_timeout_seconds &&
+        ext.unhealthy_threshold === tgt.unhealthy_threshold &&
+        ext.healthy_threshold === tgt.healthy_threshold);
+}
+function stickySessionsEqual(ext, tgt) {
+    if (!ext || !tgt)
+        return ext === tgt;
+    const extType = ext.type ?? 'none';
+    const tgtType = tgt.type ?? 'none';
+    if (extType !== tgtType)
+        return false;
+    if (extType === 'none')
+        return true;
+    return (ext.cookie_name === tgt.cookie_name &&
+        ext.cookie_ttl_seconds === tgt.cookie_ttl_seconds);
+}

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

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

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

@@ -0,0 +1,269 @@
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { LoadBalancerBuilder } from './load_balancer.js';
+import { Config } from '../../core/config.js';
+describe('LoadBalancerBuilder 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(' ');
+                // Support matching exact endpoint subpath
+                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 load balancer does not exist', async () => {
+        mockResponses['GET /load_balancers'] = {
+            status: 200,
+            body: { load_balancers: [] }
+        };
+        const builder = new LoadBalancerBuilder('my-lb');
+        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('/load_balancers?per_page=200'));
+    });
+    test('discovers load balancer successfully when it exists', async () => {
+        mockResponses['GET /load_balancers'] = {
+            status: 200,
+            body: {
+                load_balancers: [
+                    { id: 'lb-123', name: 'my-lb', region: { slug: 'nyc3' } }
+                ]
+            }
+        };
+        const builder = new LoadBalancerBuilder('my-lb');
+        const discoveryResult = await builder.discoveryPromise;
+        assert.ok(discoveryResult);
+        assert.strictEqual(discoveryResult.id, 'lb-123');
+        assert.strictEqual(discoveryResult.name, 'my-lb');
+    });
+    test('performs clean dry-run planning without making write requests', async () => {
+        Config.set({
+            dryRun: true,
+            providers: { do: { token: 'fake-token' } }
+        });
+        mockResponses['GET /load_balancers'] = {
+            status: 200,
+            body: { load_balancers: [] }
+        };
+        const builder = new LoadBalancerBuilder('my-lb');
+        builder
+            .region('nyc3')
+            .targets(['app-vm-1'])
+            .forward('http', 80, 'http', 80);
+        const result = await builder.deploy();
+        assert.ok(result);
+        // Discovery GET happened, but no writes (POST, PUT, DELETE)
+        const writeCalls = fetchCalls.filter(c => c.method !== 'GET');
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test('deploys new load balancer and resolves droplet/certificate details', async () => {
+        mockResponses['GET /load_balancers'] = {
+            status: 200,
+            body: { load_balancers: [] }
+        };
+        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['GET /certificates'] = {
+            status: 200,
+            body: { certificates: [{ id: 'cert-uuid', name: 'my-cert' }] }
+        };
+        mockResponses['POST /load_balancers'] = {
+            status: 201,
+            body: { load_balancer: { id: 'lb-789', name: 'my-lb' } }
+        };
+        const builder = new LoadBalancerBuilder('my-lb');
+        builder
+            .region('nyc3')
+            .targets(['app-vm-1', 'app-vm-2'])
+            .forward('http', 80, 'http', 80)
+            .forward('https', 443, 'http', 80, 'my-cert')
+            .healthCheck({ protocol: 'http', port: 80, path: '/health', checkIntervalSeconds: 15 })
+            .stickySession('cookies', 'lb-cookie', 3600);
+        const result = await builder.deploy();
+        assert.strictEqual(result.id, 'lb-789');
+        // Verify resolving calls
+        const postCall = fetchCalls.find(c => c.method === 'POST');
+        assert.ok(postCall);
+        assert.ok(postCall.url.endsWith('/load_balancers'));
+        assert.deepStrictEqual(postCall.body, {
+            name: 'my-lb',
+            region: 'nyc3',
+            forwarding_rules: [
+                { entry_protocol: 'http', entry_port: 80, target_protocol: 'http', target_port: 80 },
+                { entry_protocol: 'https', entry_port: 443, target_protocol: 'http', target_port: 80, certificate_id: 'cert-uuid' }
+            ],
+            health_check: {
+                protocol: 'http',
+                port: 80,
+                path: '/health',
+                check_interval_seconds: 15,
+                response_timeout_seconds: 5,
+                unhealthy_threshold: 3,
+                healthy_threshold: 5
+            },
+            sticky_sessions: {
+                type: 'cookies',
+                cookie_name: 'lb-cookie',
+                cookie_ttl_seconds: 3600
+            },
+            droplet_ids: [111, 222]
+        });
+    });
+    test('skips update deployment if load balancer configuration is up-to-date', async () => {
+        mockResponses['GET /load_balancers'] = {
+            status: 200,
+            body: {
+                load_balancers: [
+                    {
+                        id: 'lb-123',
+                        name: 'my-lb',
+                        region: { slug: 'nyc3' },
+                        droplet_ids: [111],
+                        forwarding_rules: [
+                            { entry_protocol: 'http', entry_port: 80, target_protocol: 'http', target_port: 80 }
+                        ],
+                        health_check: {
+                            protocol: 'http',
+                            port: 80,
+                            path: '/health',
+                            check_interval_seconds: 15,
+                            response_timeout_seconds: 5,
+                            unhealthy_threshold: 3,
+                            healthy_threshold: 5
+                        },
+                        sticky_sessions: {
+                            type: 'none'
+                        }
+                    }
+                ]
+            }
+        };
+        mockResponses['GET /droplets?name=app-vm-1'] = {
+            status: 200,
+            body: { droplets: [{ id: 111, name: 'app-vm-1' }] }
+        };
+        const builder = new LoadBalancerBuilder('my-lb');
+        builder
+            .region('nyc3')
+            .targets(['app-vm-1'])
+            .forward('http', 80, 'http', 80)
+            .healthCheck({ protocol: 'http', port: 80, path: '/health', checkIntervalSeconds: 15 });
+        await builder.deploy();
+        // Verify no PUT or POST was executed
+        const writeCalls = fetchCalls.filter(c => c.method === 'POST' || c.method === 'PUT');
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test('performs in-place update when load balancer target or rule config changes', async () => {
+        mockResponses['GET /load_balancers'] = {
+            status: 200,
+            body: {
+                load_balancers: [
+                    {
+                        id: 'lb-123',
+                        name: 'my-lb',
+                        region: { slug: 'nyc3' },
+                        droplet_ids: [111], // Desired is [111, 222]
+                        forwarding_rules: [
+                            { entry_protocol: 'http', entry_port: 80, target_protocol: 'http', target_port: 80 }
+                        ],
+                        health_check: {
+                            protocol: 'http',
+                            port: 80,
+                            path: '/'
+                        },
+                        sticky_sessions: {
+                            type: 'none'
+                        }
+                    }
+                ]
+            }
+        };
+        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['PUT /load_balancers/lb-123'] = {
+            status: 200,
+            body: { load_balancer: { id: 'lb-123', name: 'my-lb' } }
+        };
+        const builder = new LoadBalancerBuilder('my-lb');
+        builder
+            .region('nyc3')
+            .targets(['app-vm-1', 'app-vm-2'])
+            .forward('http', 80, 'http', 80);
+        await builder.deploy();
+        const putCall = fetchCalls.find(c => c.method === 'PUT');
+        assert.ok(putCall);
+        assert.ok(putCall.url.endsWith('/load_balancers/lb-123'));
+        assert.deepStrictEqual(putCall.body.droplet_ids, [111, 222]);
+    });
+    test('destroys load balancer successfully', async () => {
+        mockResponses['GET /load_balancers'] = {
+            status: 200,
+            body: {
+                load_balancers: [
+                    { id: 'lb-123', name: 'my-lb' }
+                ]
+            }
+        };
+        mockResponses['DELETE /load_balancers/lb-123'] = {
+            status: 204,
+            body: {}
+        };
+        const builder = new LoadBalancerBuilder('my-lb');
+        await builder.discoveryPromise;
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: 'my-lb' });
+        const deleteCall = fetchCalls.find(c => c.method === 'DELETE');
+        assert.ok(deleteCall);
+        assert.ok(deleteCall.url.endsWith('/load_balancers/lb-123'));
+    });
+});

package/dist/providers/firebase/api.js

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import fs from 'node:fs';
 import { GoogleAuth } from 'google-auth-library';
 import { Config } from '../../core/config.js';
 function resolveFirebaseConfig() {
@@ -8,7 +8,7 @@ function resolveFirebaseConfig() {
     // Fallback: auto-configure from FIREBASE_SA env var so the decorator option is optional
     const saPath = process.env.FIREBASE_SA;
     if (saPath) {
-        const sa = JSON.parse(readFileSync(saPath, 'utf8'));
+        const sa = JSON.parse(fs.readFileSync(saPath, 'utf8'));
         return { projectId: sa.project_id, serviceAccountPath: saPath };
     }
     throw new Error('Firebase not configured. Set FIREBASE_SA=/path/to/sa.json or use @Deploy({ firebase: "..." })');

package/dist/providers/firebase/functions.d.ts

@@ -19,6 +19,7 @@ export declare class FirebaseFunctionsBuilder extends BaseBuilder {
     private _minInstances;
     private _env;
     constructor(functionName: string);
+    private discoverFunction;
     source(path: string): this;
     entryPoint(e: string): this;
     runtime(r: string): this;