puls-dev 0.2.6 → 0.2.8

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

@@ -1,8 +1,10 @@
 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 { DropletBuilder, generateDropletTagForProvision } from './droplet.js';
 import { Config } from '../../core/config.js';
+import { Output } from '../../core/output.js';
+import { getFileHash } from '../proxmox/hash.js';
 describe('DropletBuilder Unit Tests', () => {
     let originalFetch;
     let fetchCalls = [];
@@ -262,4 +264,229 @@ describe('DropletBuilder Unit Tests', () => {
         assert.ok(deleteCall);
         assert.ok(deleteCall.url.endsWith('/droplets/123'));
     });
+    test('creates droplet inside a VPC', async () => {
+        mockResponses['GET /droplets'] = {
+            status: 200,
+            body: { droplets: [] }
+        };
+        mockResponses['POST /droplets'] = {
+            status: 202,
+            body: {
+                droplet: {
+                    id: 12345,
+                    name: 'vpc-droplet',
+                    status: 'active',
+                    networks: {
+                        v4: [{ ip_address: '10.10.10.5', type: 'public' }]
+                    }
+                }
+            }
+        };
+        mockResponses['GET /droplets/12345'] = {
+            status: 200,
+            body: {
+                droplet: {
+                    id: 12345,
+                    name: 'vpc-droplet',
+                    status: 'active',
+                    networks: {
+                        v4: [{ ip_address: '10.10.10.5', type: 'public' }]
+                    }
+                }
+            }
+        };
+        const builder = new DropletBuilder('vpc-droplet');
+        builder
+            .region('nyc3')
+            .size('s-1vcpu-1gb')
+            .vpc('my-vpc-uuid-xyz');
+        await builder.deploy();
+        const dropletCreateCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes('/droplets'));
+        assert.ok(dropletCreateCall);
+        assert.strictEqual(dropletCreateCall.body.vpc_uuid, 'my-vpc-uuid-xyz');
+    });
+    test('creates droplet inside a VPC using an Output value', async () => {
+        mockResponses['GET /droplets'] = {
+            status: 200,
+            body: { droplets: [] }
+        };
+        mockResponses['POST /droplets'] = {
+            status: 202,
+            body: {
+                droplet: {
+                    id: 12345,
+                    name: 'vpc-droplet-output',
+                    status: 'active',
+                    networks: {
+                        v4: [{ ip_address: '10.10.10.6', type: 'public' }]
+                    }
+                }
+            }
+        };
+        mockResponses['GET /droplets/12345'] = {
+            status: 200,
+            body: {
+                droplet: {
+                    id: 12345,
+                    name: 'vpc-droplet-output',
+                    status: 'active',
+                    networks: {
+                        v4: [{ ip_address: '10.10.10.6', type: 'public' }]
+                    }
+                }
+            }
+        };
+        const vpcIdOutput = new Output();
+        vpcIdOutput.resolve('my-vpc-uuid-abc');
+        const builder = new DropletBuilder('vpc-droplet-output');
+        builder
+            .region('nyc3')
+            .size('s-1vcpu-1gb')
+            .vpc(vpcIdOutput);
+        await builder.deploy();
+        const dropletCreateCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes('/droplets'));
+        assert.ok(dropletCreateCall);
+        assert.strictEqual(dropletCreateCall.body.vpc_uuid, 'my-vpc-uuid-abc');
+    });
+    test('deploys new droplet with playbooks and registers initial tags', async () => {
+        mockResponses['GET /droplets'] = {
+            status: 200,
+            body: { droplets: [] }
+        };
+        mockResponses['POST /droplets'] = {
+            status: 202,
+            body: {
+                droplet: {
+                    id: 12345,
+                    name: 'prov-droplet',
+                    status: 'active',
+                    networks: {
+                        v4: [{ ip_address: '1.2.3.4', type: 'public' }]
+                    }
+                }
+            }
+        };
+        mockResponses['GET /droplets/12345'] = {
+            status: 200,
+            body: {
+                droplet: {
+                    id: 12345,
+                    name: 'prov-droplet',
+                    status: 'active',
+                    networks: {
+                        v4: [{ ip_address: '1.2.3.4', type: 'public' }]
+                    }
+                }
+            }
+        };
+        const builder = new DropletBuilder('prov-droplet')
+            .provision('playbooks/nginx.yaml', 'playbooks/db.yaml');
+        const provisionCalls = [];
+        builder.waitFor = async (label, condition) => {
+            return await condition();
+        };
+        builder.checkPort = async () => true;
+        builder.runProvisioner = async (ip, script) => {
+            provisionCalls.push(script);
+        };
+        await builder.deploy();
+        // Verify playbooks were executed
+        assert.strictEqual(provisionCalls.length, 2);
+        assert.strictEqual(provisionCalls[0], 'playbooks/nginx.yaml');
+        assert.strictEqual(provisionCalls[1], 'playbooks/db.yaml');
+        // Verify initial tags were posted during creation
+        const createCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes('/droplets'));
+        assert.ok(createCall);
+        const expectedTag1 = generateDropletTagForProvision('playbooks/nginx.yaml', getFileHash('playbooks/nginx.yaml'));
+        const expectedTag2 = generateDropletTagForProvision('playbooks/db.yaml', getFileHash('playbooks/db.yaml'));
+        assert.deepStrictEqual(createCall.body.tags, [expectedTag1, expectedTag2]);
+    });
+    test('deploys existing droplet and skips playbooks if hashes match', async () => {
+        const nginxTag = generateDropletTagForProvision('playbooks/nginx.yaml', getFileHash('playbooks/nginx.yaml'));
+        mockResponses['GET /droplets'] = {
+            status: 200,
+            body: {
+                droplets: [
+                    {
+                        id: 12345,
+                        name: 'existing-prov-droplet',
+                        status: 'active',
+                        size_slug: 's-1vcpu-1gb',
+                        region: { slug: 'nyc3' },
+                        networks: {
+                            v4: [{ ip_address: '1.2.3.4', type: 'public' }]
+                        },
+                        tags: [nginxTag]
+                    }
+                ]
+            }
+        };
+        const builder = new DropletBuilder('existing-prov-droplet')
+            .provision('playbooks/nginx.yaml');
+        const provisionCalls = [];
+        builder.runProvisioner = async (ip, script) => {
+            provisionCalls.push(script);
+        };
+        await builder.deploy();
+        // No playbooks should run
+        assert.strictEqual(provisionCalls.length, 0);
+        // No POST/DELETE tags calls
+        const writeCalls = fetchCalls.filter(c => c.method === 'POST' && c.url.includes('/tags'));
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test('deploys existing droplet and runs playbooks if hash is missing or different, updating tags', async () => {
+        const oldNginxTag = generateDropletTagForProvision('playbooks/nginx.yaml', 'abc123123123');
+        mockResponses['GET /droplets'] = {
+            status: 200,
+            body: {
+                droplets: [
+                    {
+                        id: 12345,
+                        name: 'existing-diff-droplet',
+                        status: 'active',
+                        size_slug: 's-1vcpu-1gb',
+                        region: { slug: 'nyc3' },
+                        networks: {
+                            v4: [{ ip_address: '1.2.3.4', type: 'public' }]
+                        },
+                        tags: [oldNginxTag]
+                    }
+                ]
+            }
+        };
+        mockResponses['POST /tags'] = { status: 201, body: {} };
+        mockResponses['POST /tags/'] = { status: 200, body: {} };
+        mockResponses['DELETE /tags/'] = { status: 204, body: {} };
+        const builder = new DropletBuilder('existing-diff-droplet')
+            .provision('playbooks/nginx.yaml');
+        const provisionCalls = [];
+        builder.waitFor = async (label, condition) => {
+            return await condition();
+        };
+        builder.checkPort = async () => true;
+        builder.runProvisioner = async (ip, script) => {
+            provisionCalls.push(script);
+        };
+        await builder.deploy();
+        // Playbook should run
+        assert.strictEqual(provisionCalls.length, 1);
+        assert.strictEqual(provisionCalls[0], 'playbooks/nginx.yaml');
+        // Should have deleted old tag
+        const deleteTagCall = fetchCalls.find(c => c.method === 'DELETE' && c.url.includes('/tags/puls-h-nginx-yaml-abc123123123/resources'));
+        assert.ok(deleteTagCall);
+        assert.deepStrictEqual(deleteTagCall.body, {
+            resources: [{ id: '12345', type: 'droplet' }]
+        });
+        // Should have ensured new tag exists
+        const createTagCall = fetchCalls.find(c => c.method === 'POST' && c.url.endsWith('/tags') && c.body?.name?.startsWith('puls-h-nginx-yaml-'));
+        assert.ok(createTagCall);
+        // Should have tagged the resource
+        const newHash = getFileHash('playbooks/nginx.yaml');
+        const newTag = generateDropletTagForProvision('playbooks/nginx.yaml', newHash);
+        const associateCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes(`/tags/${newTag}/resources`));
+        assert.ok(associateCall);
+        assert.deepStrictEqual(associateCall.body, {
+            resources: [{ id: '12345', type: 'droplet' }]
+        });
+    });
 });

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

@@ -7,12 +7,13 @@ export interface FirewallRule {
     destinations?: string[];
 }
 export declare class FirewallBuilder extends BaseBuilder {
-    private rules;
+    private _rules;
     private dropletNames;
     constructor(name: string);
     private discoverFirewall;
     ingress(protocol: 'tcp' | 'udp' | 'icmp', port: number | string, sources: string[]): this;
     egress(protocol: 'tcp' | 'udp' | 'icmp', port: number | string, destinations: string[]): this;
+    rules(filePath: string): this;
     attachTo(dropletName: string): this;
     private resolveDropletIds;
     private buildApiRules;

package/dist/providers/do/firewall.js

@@ -1,7 +1,8 @@
 import { BaseBuilder } from '../../core/resource.js';
 import { getDoApi } from './api.js';
+import { loadRecordsFromFile } from '../../core/parser.js';
 export class FirewallBuilder extends BaseBuilder {
-    rules = [];
+    _rules = [];
     dropletNames = [];
     constructor(name) {
         super(name);
@@ -13,11 +14,24 @@ export class FirewallBuilder extends BaseBuilder {
         return data.firewalls.find(f => f.name === name) ?? null;
     }
     ingress(protocol, port, sources) {
-        this.rules.push({ type: 'ingress', protocol, port, sources });
+        this._rules.push({ type: 'ingress', protocol, port, sources });
         return this;
     }
     egress(protocol, port, destinations) {
-        this.rules.push({ type: 'egress', protocol, port, destinations });
+        this._rules.push({ type: 'egress', protocol, port, destinations });
+        return this;
+    }
+    rules(filePath) {
+        const loaded = loadRecordsFromFile(filePath);
+        for (const r of loaded) {
+            this._rules.push({
+                type: r.type,
+                protocol: r.protocol,
+                port: r.port,
+                sources: r.sources,
+                destinations: r.destinations,
+            });
+        }
         return this;
     }
     attachTo(dropletName) {
@@ -35,14 +49,14 @@ export class FirewallBuilder extends BaseBuilder {
         return ids;
     }
     buildApiRules() {
-        const inbound = this.rules
+        const inbound = this._rules
             .filter(r => r.type === 'ingress')
             .map(r => ({
             protocol: r.protocol,
             ports: String(r.port),
             sources: { addresses: r.sources ?? [] },
         }));
-        const outbound = this.rules
+        const outbound = this._rules
             .filter(r => r.type === 'egress')
             .map(r => ({
             protocol: r.protocol,
@@ -57,12 +71,12 @@ export class FirewallBuilder extends BaseBuilder {
         const api = getDoApi();
         console.log(`\n🛡️  Finalizing firewall "${this.name}"...`);
         if (dryRun) {
-            this.rules.forEach(r => {
+            this._rules.forEach(r => {
                 const dir = r.type === 'ingress' ? 'from' : 'to';
                 const targets = r.type === 'ingress' ? r.sources : r.destinations;
                 console.log(`   📝 [PLAN] ${r.type.toUpperCase()}: ${r.protocol.toUpperCase()} ${r.port} ${dir} [${targets?.join(', ')}]`);
             });
-            return { name: this.name, rules: this.rules };
+            return { name: this.name, rules: this._rules };
         }
         const dropletIds = await this.resolveDropletIds(api);
         const { inbound, outbound } = this.buildApiRules();
@@ -84,11 +98,11 @@ export class FirewallBuilder extends BaseBuilder {
             });
             console.log(`🚀 Created firewall ${this.name} (id=${result.firewall.id})`);
         }
-        this.rules.forEach(r => {
+        this._rules.forEach(r => {
             const dir = r.type === 'ingress' ? 'from' : 'to';
             const targets = r.type === 'ingress' ? r.sources : r.destinations;
             console.log(`   ✅ ${r.type.toUpperCase()}: ${r.protocol.toUpperCase()} ${r.port} ${dir} [${targets?.join(', ')}]`);
         });
-        return { name: this.name, rules: this.rules };
+        return { name: this.name, rules: this._rules };
     }
 }

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

@@ -1,5 +1,7 @@
 import { test, describe, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
 import { FirewallBuilder } from './firewall.js';
 import { Config } from '../../core/config.js';
 describe('FirewallBuilder Unit Tests', () => {
@@ -173,4 +175,56 @@ describe('FirewallBuilder Unit Tests', () => {
             droplet_ids: [111]
         });
     });
+    test('loads rules from a configuration file (YAML) successfully', 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['POST /firewalls'] = {
+            status: 201,
+            body: { firewall: { id: 'fw-789', name: 'my-fw' } }
+        };
+        // Mock YAML file creation
+        const tempYamlPath = path.resolve(process.cwd(), "temp-firewall-rules.yaml");
+        const yamlContent = `
+- type: ingress
+  protocol: tcp
+  port: 80
+  sources:
+    - 0.0.0.0/0
+- type: egress
+  protocol: tcp
+  port: all
+  destinations:
+    - 0.0.0.0/0
+`;
+        fs.writeFileSync(tempYamlPath, yamlContent, "utf-8");
+        try {
+            const builder = new FirewallBuilder('my-fw')
+                .rules("temp-firewall-rules.yaml")
+                .attachTo('app-vm-1');
+            const result = await builder.deploy();
+            assert.ok(result);
+            const postCall = fetchCalls.find(c => c.method === 'POST');
+            assert.ok(postCall);
+            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]
+            });
+        }
+        finally {
+            if (fs.existsSync(tempYamlPath))
+                fs.unlinkSync(tempYamlPath);
+        }
+    });
 });

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

@@ -3,14 +3,25 @@ import { DomainBuilder } from "./domain.js";
 import { FirewallBuilder } from "./firewall.js";
 import { CertificateBuilder } from "./certificate.js";
 import { LoadBalancerBuilder } from "./load_balancer.js";
+import { SpacesBuilder } from "./spaces.js";
+import { DatabaseBuilder } from "./database.js";
+import { AppPlatformBuilder } from "./app.js";
+import { VPCBuilder } from "./vpc.js";
 export declare const DO: {
     init: (opts: {
         token: string;
+        defaultRegion?: string;
+        spacesAccessKey?: string;
+        spacesSecretKey?: string;
     }) => void;
     Droplet: (name: string) => DropletBuilder;
     Domain: (name: string) => DomainBuilder;
     Firewall: (name: string) => FirewallBuilder;
     Certificate: (name: string) => CertificateBuilder;
     LoadBalancer: (name: string) => LoadBalancerBuilder;
+    Spaces: (name: string) => SpacesBuilder;
+    Database: (name: string) => DatabaseBuilder;
+    App: (name: string) => AppPlatformBuilder;
+    VPC: (name: string) => VPCBuilder;
 };
 export * from "../../types/do.js";

package/dist/providers/do/index.js

@@ -4,6 +4,10 @@ import { DomainBuilder } from "./domain.js";
 import { FirewallBuilder } from "./firewall.js";
 import { CertificateBuilder } from "./certificate.js";
 import { LoadBalancerBuilder } from "./load_balancer.js";
+import { SpacesBuilder } from "./spaces.js";
+import { DatabaseBuilder } from "./database.js";
+import { AppPlatformBuilder } from "./app.js";
+import { VPCBuilder } from "./vpc.js";
 export const DO = {
     init: (opts) => {
         Config.set({
@@ -18,5 +22,9 @@ export const DO = {
     Firewall: (name) => new FirewallBuilder(name),
     Certificate: (name) => new CertificateBuilder(name),
     LoadBalancer: (name) => new LoadBalancerBuilder(name),
+    Spaces: (name) => new SpacesBuilder(name),
+    Database: (name) => new DatabaseBuilder(name),
+    App: (name) => new AppPlatformBuilder(name),
+    VPC: (name) => new VPCBuilder(name),
 };
 export * from "../../types/do.js";

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

@@ -0,0 +1,27 @@
+import { BaseBuilder } from "../../core/resource.js";
+export type CORSRule = {
+    AllowedHeaders?: string[];
+    AllowedMethods: string[];
+    AllowedOrigins: string[];
+    ExposeHeaders?: string[];
+    MaxAgeSeconds?: number;
+};
+export declare class SpacesBuilder extends BaseBuilder {
+    bucketName: string;
+    private _region;
+    private _acl;
+    private _corsRules?;
+    private _uploadPath?;
+    constructor(bucketName: string);
+    region(r: string): this;
+    acl(type: "private" | "public-read"): this;
+    cors(rules: CORSRule[]): this;
+    upload(filePath: string): this;
+    private discoverBucket;
+    deploy(): Promise<{
+        name: string;
+        region: string;
+    }>;
+    destroy(): Promise<any>;
+    private uploadFile;
+}

package/dist/providers/do/spaces.js

@@ -0,0 +1,142 @@
+import fs from "node:fs";
+import { basename, extname } from "node:path";
+import { HeadBucketCommand, CreateBucketCommand, PutBucketAclCommand, PutBucketCorsCommand, PutObjectCommand, DeleteBucketCommand, } from "@aws-sdk/client-s3";
+import { BaseBuilder } from "../../core/resource.js";
+import { getSpacesS3Client } from "./spaces_api.js";
+export class SpacesBuilder extends BaseBuilder {
+    bucketName;
+    _region = "nyc3";
+    _acl = "private";
+    _corsRules;
+    _uploadPath;
+    constructor(bucketName) {
+        super(bucketName);
+        this.bucketName = bucketName;
+        this.discoveryPromise = this.discoverBucket(bucketName);
+    }
+    region(r) {
+        this._region = r;
+        this.discoveryPromise = this.discoverBucket(this.bucketName);
+        return this;
+    }
+    acl(type) {
+        this._acl = type;
+        return this;
+    }
+    cors(rules) {
+        this._corsRules = rules;
+        return this;
+    }
+    upload(filePath) {
+        this._uploadPath = filePath;
+        return this;
+    }
+    async discoverBucket(name) {
+        try {
+            const s3 = getSpacesS3Client(this._region);
+            await s3.send(new HeadBucketCommand({ Bucket: name }));
+            return true;
+        }
+        catch (e) {
+            const status = e.$metadata?.httpStatusCode;
+            if (status === 404 || e.name === "NotFound")
+                return false;
+            if (status === 301 || status === 403)
+                return true; // exists or access denied
+            if (e.name === "CredentialsProviderError")
+                return false;
+            throw e;
+        }
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const exists = await this.discoveryPromise;
+        const s3 = getSpacesS3Client(this._region);
+        console.log(`\n🌌 Finalizing DigitalOcean Space "${this.bucketName}"...`);
+        if (!exists) {
+            if (dryRun) {
+                console.log(`   📝 [PLAN] Create DigitalOcean Space "${this.bucketName}" (${this._region})`);
+            }
+            else {
+                await s3.send(new CreateBucketCommand({ Bucket: this.bucketName }));
+                console.log(`🚀 Created DigitalOcean Space "${this.bucketName}"`);
+            }
+        }
+        else {
+            console.log(`   ✅ DigitalOcean Space "${this.bucketName}" already exists.`);
+        }
+        // Apply ACL
+        if (this._acl) {
+            if (dryRun) {
+                console.log(`   📝 [PLAN] Set Space ACL: ${this._acl}`);
+            }
+            else {
+                await s3.send(new PutBucketAclCommand({ Bucket: this.bucketName, ACL: this._acl }));
+                console.log(`   ✅ Set Space ACL: ${this._acl}`);
+            }
+        }
+        // Apply CORS
+        if (this._corsRules) {
+            if (dryRun) {
+                console.log(`   📝 [PLAN] Configure CORS rules: ${JSON.stringify(this._corsRules)}`);
+            }
+            else {
+                await s3.send(new PutBucketCorsCommand({
+                    Bucket: this.bucketName,
+                    CORSConfiguration: { CORSRules: this._corsRules },
+                }));
+                console.log(`   ✅ Configured CORS rules`);
+            }
+        }
+        // Handle single file upload
+        if (this._uploadPath) {
+            if (dryRun) {
+                console.log(`   📝 [PLAN] Upload ${basename(this._uploadPath)} → space://${this.bucketName}/`);
+            }
+            else {
+                await this.uploadFile(s3, this._uploadPath);
+            }
+        }
+        await this.deploySidecars();
+        return { name: this.bucketName, region: this._region };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const exists = await this.discoveryPromise;
+        console.log(`\n🌌 Destroying DigitalOcean Space "${this.bucketName}"...`);
+        if (!exists) {
+            console.log(`   ─  Space "${this.bucketName}" not found`);
+            return { destroyed: false };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete DigitalOcean Space "${this.bucketName}"`);
+            return { destroyed: this.bucketName };
+        }
+        const s3 = getSpacesS3Client(this._region);
+        await s3.send(new DeleteBucketCommand({ Bucket: this.bucketName }));
+        console.log(`   🗑️  Removed DigitalOcean Space "${this.bucketName}"`);
+        return { destroyed: this.bucketName };
+    }
+    async uploadFile(s3, filePath) {
+        const key = basename(filePath);
+        const body = fs.readFileSync(filePath);
+        const contentTypeMap = {
+            ".json": "application/json",
+            ".js": "application/javascript",
+            ".html": "text/html",
+            ".css": "text/css",
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".svg": "image/svg+xml",
+        };
+        const contentType = contentTypeMap[extname(filePath).toLowerCase()] ?? "application/octet-stream";
+        await s3.send(new PutObjectCommand({
+            Bucket: this.bucketName,
+            Key: key,
+            Body: body,
+            ContentType: contentType,
+            ACL: this._acl,
+        }));
+        console.log(`   ✅ Uploaded ${key} → space://${this.bucketName}/${key}`);
+    }
+}

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

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