puls-dev 0.2.7 → 0.2.8

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

@@ -0,0 +1,180 @@
+import { test, describe, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import fs from "node:fs";
+import { S3Client } from "@aws-sdk/client-s3";
+import { SpacesBuilder } from "./spaces.js";
+import { Config } from "../../core/config.js";
+describe("SpacesBuilder Unit Tests", () => {
+    let originalS3Send;
+    let s3Calls = [];
+    let mockS3Responses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                do: {
+                    token: "fake-do-token",
+                    defaultRegion: "nyc3",
+                    spacesAccessKey: "fake-spaces-key",
+                    spacesSecretKey: "fake-spaces-secret",
+                },
+            },
+        });
+        s3Calls = [];
+        mockS3Responses = {};
+        originalS3Send = S3Client.prototype.send;
+        S3Client.prototype.send = async function (command) {
+            const commandName = command.constructor.name;
+            const input = command.input;
+            s3Calls.push({ commandName, input });
+            if (mockS3Responses[commandName] !== undefined) {
+                const handler = mockS3Responses[commandName];
+                if (typeof handler === "function")
+                    return handler(input);
+                if (handler instanceof Error)
+                    throw handler;
+                return handler;
+            }
+            return {};
+        };
+        mock.method(fs, "readFileSync", () => {
+            return Buffer.from("fake-file-content");
+        });
+    });
+    afterEach(() => {
+        S3Client.prototype.send = originalS3Send;
+        mock.restoreAll();
+    });
+    test("gracefully handles discovery when Space does not exist", async () => {
+        mockS3Responses["HeadBucketCommand"] = () => {
+            const err = new Error("Not Found");
+            err.name = "NotFound";
+            err.$metadata = { httpStatusCode: 404 };
+            throw err;
+        };
+        const builder = new SpacesBuilder("my-space");
+        const discoveryResult = await builder.discoveryPromise;
+        assert.strictEqual(discoveryResult, false);
+        assert.strictEqual(s3Calls.length, 1);
+        assert.strictEqual(s3Calls[0].commandName, "HeadBucketCommand");
+        assert.strictEqual(s3Calls[0].input.Bucket, "my-space");
+    });
+    test("discovers Space successfully when it exists", async () => {
+        mockS3Responses["HeadBucketCommand"] = () => ({});
+        const builder = new SpacesBuilder("my-space");
+        const discoveryResult = await builder.discoveryPromise;
+        assert.strictEqual(discoveryResult, true);
+        assert.strictEqual(s3Calls.length, 1);
+    });
+    test("performs clean dry-run planning without making write requests", async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                do: {
+                    token: "fake-do-token",
+                    spacesAccessKey: "fake-key",
+                    spacesSecretKey: "fake-secret",
+                },
+            },
+        });
+        mockS3Responses["HeadBucketCommand"] = () => {
+            const err = new Error("Not Found");
+            err.name = "NotFound";
+            err.$metadata = { httpStatusCode: 404 };
+            throw err;
+        };
+        const builder = new SpacesBuilder("my-dry-space")
+            .region("ams3")
+            .acl("public-read")
+            .cors([
+            {
+                AllowedMethods: ["GET", "PUT"],
+                AllowedOrigins: ["*"],
+            },
+        ])
+            .upload("dist/index.js");
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, "my-dry-space");
+        assert.strictEqual(result.region, "ams3");
+        // HeadBucketCommand should run for discovery, but no creation/write commands
+        assert.ok(s3Calls.some((c) => c.commandName === "HeadBucketCommand"));
+        const writeCalls = s3Calls.filter((c) => c.commandName !== "HeadBucketCommand");
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test("deploys new Space, applying ACL and CORS rules successfully", async () => {
+        mockS3Responses["HeadBucketCommand"] = () => {
+            const err = new Error("Not Found");
+            err.name = "NotFound";
+            err.$metadata = { httpStatusCode: 404 };
+            throw err;
+        };
+        mockS3Responses["CreateBucketCommand"] = () => ({});
+        mockS3Responses["PutBucketAclCommand"] = () => ({});
+        mockS3Responses["PutBucketCorsCommand"] = () => ({});
+        const builder = new SpacesBuilder("my-new-space")
+            .region("sgp1")
+            .acl("public-read")
+            .cors([
+            {
+                AllowedHeaders: ["*"],
+                AllowedMethods: ["GET", "HEAD"],
+                AllowedOrigins: ["https://example.com"],
+            },
+        ]);
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, "my-new-space");
+        assert.strictEqual(result.region, "sgp1");
+        // Verify commands sent to S3
+        const createCall = s3Calls.find((c) => c.commandName === "CreateBucketCommand");
+        assert.ok(createCall);
+        assert.strictEqual(createCall.input.Bucket, "my-new-space");
+        const aclCall = s3Calls.find((c) => c.commandName === "PutBucketAclCommand");
+        assert.ok(aclCall);
+        assert.strictEqual(aclCall.input.Bucket, "my-new-space");
+        assert.strictEqual(aclCall.input.ACL, "public-read");
+        const corsCall = s3Calls.find((c) => c.commandName === "PutBucketCorsCommand");
+        assert.ok(corsCall);
+        assert.strictEqual(corsCall.input.Bucket, "my-new-space");
+        assert.deepStrictEqual(corsCall.input.CORSConfiguration.CORSRules, [
+            {
+                AllowedHeaders: ["*"],
+                AllowedMethods: ["GET", "HEAD"],
+                AllowedOrigins: ["https://example.com"],
+            },
+        ]);
+    });
+    test("deploys new Space and handles file upload with correct content type", async () => {
+        mockS3Responses["HeadBucketCommand"] = () => {
+            const err = new Error("Not Found");
+            err.name = "NotFound";
+            err.$metadata = { httpStatusCode: 404 };
+            throw err;
+        };
+        mockS3Responses["CreateBucketCommand"] = () => ({});
+        mockS3Responses["PutBucketAclCommand"] = () => ({});
+        mockS3Responses["PutObjectCommand"] = () => ({});
+        const builder = new SpacesBuilder("my-upload-space")
+            .upload("dist/app.json");
+        const result = await builder.deploy();
+        assert.ok(result);
+        const putCall = s3Calls.find((c) => c.commandName === "PutObjectCommand");
+        assert.ok(putCall);
+        assert.strictEqual(putCall.input.Bucket, "my-upload-space");
+        assert.strictEqual(putCall.input.Key, "app.json");
+        assert.strictEqual(putCall.input.ContentType, "application/json");
+        assert.strictEqual(putCall.input.ACL, "private");
+    });
+    test("destroys Space successfully", async () => {
+        mockS3Responses["HeadBucketCommand"] = () => ({});
+        mockS3Responses["DeleteBucketCommand"] = () => ({});
+        const builder = new SpacesBuilder("my-delete-space");
+        await builder.discoveryPromise;
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: "my-delete-space" });
+        const deleteCall = s3Calls.find((c) => c.commandName === "DeleteBucketCommand");
+        assert.ok(deleteCall);
+        assert.strictEqual(deleteCall.input.Bucket, "my-delete-space");
+    });
+});

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

@@ -0,0 +1,2 @@
+import { S3Client } from "@aws-sdk/client-s3";
+export declare function getSpacesS3Client(region?: string): S3Client;

package/dist/providers/do/spaces_api.js

@@ -0,0 +1,20 @@
+import { S3Client } from "@aws-sdk/client-s3";
+import { Config } from "../../core/config.js";
+export function getSpacesS3Client(region = "nyc3") {
+    const doConfig = Config.get().providers.do;
+    const accessKey = doConfig?.spacesAccessKey ?? process.env.SPACES_ACCESS_KEY_ID;
+    const secretKey = doConfig?.spacesSecretKey ?? process.env.SPACES_SECRET_ACCESS_KEY;
+    if (!accessKey || !secretKey) {
+        throw new Error("DigitalOcean Spaces credentials not found. " +
+            "Please set SPACES_ACCESS_KEY_ID and SPACES_SECRET_ACCESS_KEY env vars, " +
+            "or configure 'spacesAccessKey' and 'spacesSecretKey' in your DO provider options.");
+    }
+    return new S3Client({
+        endpoint: `https://${region}.digitaloceanspaces.com`,
+        region: region, // S3Client requires region, even if endpoint is custom
+        credentials: {
+            accessKeyId: accessKey,
+            secretAccessKey: secretKey,
+        },
+    });
+}

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

@@ -0,0 +1,30 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+export declare class VPCBuilder extends BaseBuilder {
+    readonly out: {
+        id: Output<string>;
+        ipRange: Output<string>;
+    };
+    private _region;
+    private _ipRange?;
+    private _description?;
+    constructor(name: string);
+    region(r: string): this;
+    ipRange(cidr: string): this;
+    description(text: string): this;
+    private discoverVpc;
+    deploy(): Promise<{
+        name: string;
+        id: any;
+        ipRange: any;
+    } | {
+        name: string;
+        id: string;
+        ipRange?: undefined;
+    }>;
+    destroy(): Promise<{
+        destroyed: boolean;
+    } | {
+        destroyed: string;
+    }>;
+}

package/dist/providers/do/vpc.js

@@ -0,0 +1,128 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { getDoApi } from "./api.js";
+import { Output } from "../../core/output.js";
+export class VPCBuilder extends BaseBuilder {
+    out = {
+        id: new Output(),
+        ipRange: new Output(),
+    };
+    _region = "nyc3";
+    _ipRange;
+    _description;
+    constructor(name) {
+        super(name);
+        this.discoveryPromise = this.discoverVpc(name);
+    }
+    region(r) {
+        this._region = r;
+        this.discoveryPromise = this.discoverVpc(this.name);
+        return this;
+    }
+    ipRange(cidr) {
+        this._ipRange = cidr;
+        return this;
+    }
+    description(text) {
+        this._description = text;
+        return this;
+    }
+    async discoverVpc(name) {
+        try {
+            const api = getDoApi();
+            const res = await api.get("/vpcs?per_page=200");
+            const match = (res.vpcs ?? []).find((vpc) => vpc.name === name);
+            if (match) {
+                this.out.id.resolve(match.id);
+                this.out.ipRange.resolve(match.ip_range);
+            }
+            return match ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getDoApi();
+        console.log(`\n🌐 Finalizing DigitalOcean VPC "${this.name}"...`);
+        if (existing) {
+            console.log(`   ✅ VPC "${this.name}" already exists (id=${existing.id}, ipRange=${existing.ip_range}).`);
+            this.out.id.resolve(existing.id);
+            this.out.ipRange.resolve(existing.ip_range);
+            const hasDescriptionChange = this._description !== undefined && existing.description !== this._description;
+            if (hasDescriptionChange) {
+                if (dryRun) {
+                    console.log(`   📝 [PLAN] Update VPC description → "${this._description}"`);
+                }
+                else {
+                    await api.put(`/vpcs/${existing.id}`, {
+                        name: this.name,
+                        description: this._description,
+                    });
+                    console.log(`   ✅ VPC description updated.`);
+                }
+            }
+            return {
+                name: this.name,
+                id: existing.id,
+                ipRange: existing.ip_range,
+            };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Create DigitalOcean VPC "${this.name}" (${this._region})`);
+            if (this._ipRange) {
+                console.log(`      └─ Custom IP Range: ${this._ipRange}`);
+            }
+            if (this._description) {
+                console.log(`      └─ Description: ${this._description}`);
+            }
+            this.out.id.resolve("PENDING");
+            this.out.ipRange.resolve(this._ipRange || "10.10.10.0/20");
+            return { name: this.name, id: "PENDING" };
+        }
+        console.log(`🚀 Creating DigitalOcean VPC "${this.name}"...`);
+        const body = {
+            name: this.name,
+            region: this._region,
+        };
+        if (this._ipRange) {
+            body.ip_range = this._ipRange;
+        }
+        if (this._description) {
+            body.description = this._description;
+        }
+        const createRes = await api.post("/vpcs", body);
+        const vpc = createRes.vpc;
+        console.log(`🚀 VPC created with ID: ${vpc.id}`);
+        this.out.id.resolve(vpc.id);
+        this.out.ipRange.resolve(vpc.ip_range);
+        return {
+            name: this.name,
+            id: vpc.id,
+            ipRange: vpc.ip_range,
+        };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getDoApi();
+        console.log(`\n🗑️  Destroying DigitalOcean VPC "${this.name}"...`);
+        if (!existing) {
+            console.log(`   ─  VPC "${this.name}" not found`);
+            return { destroyed: false };
+        }
+        if (existing.default) {
+            console.log(`   ⏭️  [SKIP] Cannot delete the default VPC "${this.name}"`);
+            return { destroyed: false };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete VPC "${this.name}" (id=${existing.id})`);
+            return { destroyed: this.name };
+        }
+        console.log(`   🔄 Deleting VPC "${this.name}" (id=${existing.id})...`);
+        await api.delete(`/vpcs/${existing.id}`);
+        console.log(`   🗑️  Removed VPC "${this.name}"`);
+        return { destroyed: this.name };
+    }
+}

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

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

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

@@ -0,0 +1,258 @@
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { VPCBuilder } from './vpc.js';
+import { Config } from '../../core/config.js';
+describe('VPCBuilder 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',
+            };
+        };
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    test('gracefully handles discovery when VPC does not exist', async () => {
+        mockResponses['GET /vpcs'] = {
+            status: 200,
+            body: { vpcs: [] }
+        };
+        const builder = new VPCBuilder('my-custom-vpc');
+        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('/vpcs'));
+    });
+    test('discovers VPC successfully when it exists', async () => {
+        mockResponses['GET /vpcs'] = {
+            status: 200,
+            body: {
+                vpcs: [
+                    {
+                        id: 'vpc-uuid-111',
+                        name: 'my-custom-vpc',
+                        ip_range: '10.10.0.0/16',
+                        default: false
+                    }
+                ]
+            }
+        };
+        const builder = new VPCBuilder('my-custom-vpc');
+        const discoveryResult = await builder.discoveryPromise;
+        assert.ok(discoveryResult);
+        assert.strictEqual(discoveryResult.id, 'vpc-uuid-111');
+        const resolvedId = await builder.out.id.get();
+        const resolvedIpRange = await builder.out.ipRange.get();
+        assert.strictEqual(resolvedId, 'vpc-uuid-111');
+        assert.strictEqual(resolvedIpRange, '10.10.0.0/16');
+    });
+    test('dry-run resolves pending outputs and plans creation when VPC does not exist', async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                do: { token: 'fake-do-token' }
+            }
+        });
+        mockResponses['GET /vpcs'] = {
+            status: 200,
+            body: { vpcs: [] }
+        };
+        const builder = new VPCBuilder('my-custom-vpc')
+            .region('sfo3')
+            .ipRange('10.20.30.0/24')
+            .description('Temporary Test VPC');
+        const result = await builder.deploy();
+        assert.deepStrictEqual(result, { name: 'my-custom-vpc', id: 'PENDING' });
+        const resolvedId = await builder.out.id.get();
+        const resolvedIpRange = await builder.out.ipRange.get();
+        assert.strictEqual(resolvedId, 'PENDING');
+        assert.strictEqual(resolvedIpRange, '10.20.30.0/24');
+        // No POST writes should be triggered during dry-run
+        const writeCalls = fetchCalls.filter(c => c.method === 'POST' || c.method === 'PUT');
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test('deploys and creates a new VPC successfully', async () => {
+        mockResponses['GET /vpcs'] = {
+            status: 200,
+            body: { vpcs: [] }
+        };
+        mockResponses['POST /vpcs'] = {
+            status: 201,
+            body: {
+                vpc: {
+                    id: 'created-vpc-uuid',
+                    name: 'new-vpc',
+                    region: 'nyc3',
+                    ip_range: '10.50.0.0/16',
+                    description: 'A brand new VPC'
+                }
+            }
+        };
+        const builder = new VPCBuilder('new-vpc')
+            .region('nyc3')
+            .ipRange('10.50.0.0/16')
+            .description('A brand new VPC');
+        const result = await builder.deploy();
+        assert.deepStrictEqual(result, {
+            name: 'new-vpc',
+            id: 'created-vpc-uuid',
+            ipRange: '10.50.0.0/16'
+        });
+        const resolvedId = await builder.out.id.get();
+        const resolvedIpRange = await builder.out.ipRange.get();
+        assert.strictEqual(resolvedId, 'created-vpc-uuid');
+        assert.strictEqual(resolvedIpRange, '10.50.0.0/16');
+        const postCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes('/vpcs'));
+        assert.ok(postCall);
+        assert.deepStrictEqual(postCall.body, {
+            name: 'new-vpc',
+            region: 'nyc3',
+            ip_range: '10.50.0.0/16',
+            description: 'A brand new VPC'
+        });
+    });
+    test('updates VPC description if it changes', async () => {
+        mockResponses['GET /vpcs'] = {
+            status: 200,
+            body: {
+                vpcs: [
+                    {
+                        id: 'vpc-uuid-222',
+                        name: 'existing-vpc',
+                        ip_range: '10.10.0.0/16',
+                        description: 'Old Description',
+                        default: false
+                    }
+                ]
+            }
+        };
+        mockResponses['PUT /vpcs/vpc-uuid-222'] = {
+            status: 200,
+            body: {
+                vpc: {
+                    id: 'vpc-uuid-222',
+                    name: 'existing-vpc',
+                    ip_range: '10.10.0.0/16',
+                    description: 'New Description',
+                    default: false
+                }
+            }
+        };
+        const builder = new VPCBuilder('existing-vpc')
+            .description('New Description');
+        const result = await builder.deploy();
+        assert.strictEqual(result.id, 'vpc-uuid-222');
+        const putCall = fetchCalls.find(c => c.method === 'PUT' && c.url.includes('/vpcs/vpc-uuid-222'));
+        assert.ok(putCall);
+        assert.deepStrictEqual(putCall.body, {
+            name: 'existing-vpc',
+            description: 'New Description'
+        });
+    });
+    test('skips update if description is unchanged', async () => {
+        mockResponses['GET /vpcs'] = {
+            status: 200,
+            body: {
+                vpcs: [
+                    {
+                        id: 'vpc-uuid-222',
+                        name: 'existing-vpc',
+                        ip_range: '10.10.0.0/16',
+                        description: 'Same Description',
+                        default: false
+                    }
+                ]
+            }
+        };
+        const builder = new VPCBuilder('existing-vpc')
+            .description('Same Description');
+        await builder.deploy();
+        const putCalls = fetchCalls.filter(c => c.method === 'PUT');
+        assert.strictEqual(putCalls.length, 0);
+    });
+    test('deletes custom VPC successfully during destroy', async () => {
+        mockResponses['GET /vpcs'] = {
+            status: 200,
+            body: {
+                vpcs: [
+                    {
+                        id: 'vpc-uuid-delete',
+                        name: 'custom-vpc-to-delete',
+                        ip_range: '10.10.0.0/16',
+                        default: false
+                    }
+                ]
+            }
+        };
+        mockResponses['DELETE /vpcs/vpc-uuid-delete'] = {
+            status: 204,
+            body: {}
+        };
+        const builder = new VPCBuilder('custom-vpc-to-delete');
+        await builder.discoveryPromise;
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: 'custom-vpc-to-delete' });
+        const deleteCall = fetchCalls.find(c => c.method === 'DELETE');
+        assert.ok(deleteCall);
+        assert.ok(deleteCall.url.endsWith('/vpcs/vpc-uuid-delete'));
+    });
+    test('skips deletion of default VPC networks during destroy', async () => {
+        mockResponses['GET /vpcs'] = {
+            status: 200,
+            body: {
+                vpcs: [
+                    {
+                        id: 'default-vpc-uuid',
+                        name: 'default-nyc3',
+                        ip_range: '10.10.0.0/16',
+                        default: true
+                    }
+                ]
+            }
+        };
+        const builder = new VPCBuilder('default-nyc3');
+        await builder.discoveryPromise;
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: false });
+        // No DELETE requests should be triggered
+        const deleteCalls = fetchCalls.filter(c => c.method === 'DELETE');
+        assert.strictEqual(deleteCalls.length, 0);
+    });
+});

package/dist/providers/gcp/clouddns.d.ts

@@ -19,6 +19,7 @@ export declare class GCPCloudDNSZoneBuilder extends BaseBuilder {
     private records;
     constructor(zoneName: string);
     private discoverZone;
+    record(filePath: string): this;
     record(name: string, type: "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "NS" | "PTR" | "SRV" | "CAA" | "SPF", value: string, ttl?: number): this;
     pointer(name: string, target: BaseBuilder | Output<string> | string): this;
     deploy(): Promise<{

package/dist/providers/gcp/clouddns.js

@@ -1,6 +1,7 @@
 import { BaseBuilder } from "../../core/resource.js";
 import { Output } from "../../core/output.js";
 import { gcpFetch, getProjectId } from "./api.js";
+import { loadRecordsFromFile } from "../../core/parser.js";
 const DNS_BASE = "https://dns.googleapis.com";
 function cleanZoneId(domain) {
     return domain
@@ -57,8 +58,20 @@ export class GCPCloudDNSZoneBuilder extends BaseBuilder {
             throw e;
         }
     }
-    record(name, type, value, ttl = 300) {
-        this.records.push({ name, type, value, ttl });
+    record(nameOrPath, type, value, ttl = 300) {
+        if (arguments.length === 1 && typeof nameOrPath === "string" && (nameOrPath.endsWith(".yaml") || nameOrPath.endsWith(".yml") || nameOrPath.endsWith(".json"))) {
+            const loaded = loadRecordsFromFile(nameOrPath);
+            for (const r of loaded) {
+                this.records.push({
+                    name: r.name,
+                    type: r.type,
+                    value: r.value,
+                    ttl: r.ttl ?? 300,
+                });
+            }
+            return this;
+        }
+        this.records.push({ name: nameOrPath, type: type, value: value, ttl });
         return this;
     }
     pointer(name, target) {