puls-dev 0.3.5 → 0.3.7

package/dist/providers/aws/rds.test.js

@@ -0,0 +1,219 @@
+import { test, describe, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import { RDSClient } from "@aws-sdk/client-rds";
+import { EC2Client } from "@aws-sdk/client-ec2";
+import { RDSBuilder } from "./rds.js";
+import { Config } from "../../core/config.js";
+describe("RDSBuilder Unit Tests", () => {
+    let originalRdsSend;
+    let originalEc2Send;
+    let rdsCalls = [];
+    let ec2Calls = [];
+    let mockRdsResponses = {};
+    let mockEc2Responses = {};
+    function stubSend(calls, responses) {
+        return async function (command) {
+            const commandName = command.constructor.name;
+            calls.push({ commandName, input: command.input });
+            const handler = responses[commandName];
+            if (handler) {
+                if (typeof handler === "function")
+                    return handler(command.input);
+                if (handler instanceof Error)
+                    throw handler;
+                return handler;
+            }
+            return {};
+        };
+    }
+    beforeEach(() => {
+        Config.set({ dryRun: false, providers: { aws: { region: "us-east-1" } } });
+        rdsCalls = [];
+        ec2Calls = [];
+        mockRdsResponses = {};
+        mockEc2Responses = {};
+        originalRdsSend = RDSClient.prototype.send;
+        originalEc2Send = EC2Client.prototype.send;
+        RDSClient.prototype.send = stubSend(rdsCalls, mockRdsResponses);
+        EC2Client.prototype.send = stubSend(ec2Calls, mockEc2Responses);
+    });
+    afterEach(() => {
+        RDSClient.prototype.send = originalRdsSend;
+        EC2Client.prototype.send = originalEc2Send;
+        mock.restoreAll();
+    });
+    test("returns null when DB instance is not found during discovery", async () => {
+        const err = new Error("not found");
+        err.name = "DBInstanceNotFound";
+        mockRdsResponses["DescribeDBInstancesCommand"] = err;
+        const builder = new RDSBuilder("my-db");
+        const result = await builder.discoveryPromise;
+        assert.strictEqual(result, null);
+        assert.strictEqual(rdsCalls[0].commandName, "DescribeDBInstancesCommand");
+    });
+    test("discovers existing instance and populates resolved fields", async () => {
+        mockRdsResponses["DescribeDBInstancesCommand"] = {
+            DBInstances: [
+                {
+                    DBInstanceIdentifier: "my-db",
+                    DBInstanceStatus: "available",
+                    DBInstanceArn: "arn:aws:rds:us-east-1:123:db:my-db",
+                    Endpoint: {
+                        Address: "my-db.xyz.us-east-1.rds.amazonaws.com",
+                        Port: 5432,
+                    },
+                },
+            ],
+        };
+        const builder = new RDSBuilder("my-db");
+        const result = await builder.discoveryPromise;
+        assert.ok(result);
+        assert.strictEqual(builder.resolvedArn, "arn:aws:rds:us-east-1:123:db:my-db");
+        assert.strictEqual(builder.resolvedEndpoint, "my-db.xyz.us-east-1.rds.amazonaws.com");
+        assert.strictEqual(builder.resolvedPort, 5432);
+    });
+    test("performs dry-run without any write API calls", async () => {
+        Config.set({ dryRun: true, providers: { aws: { region: "us-east-1" } } });
+        const err = new Error("not found");
+        err.name = "DBInstanceNotFound";
+        mockRdsResponses["DescribeDBInstancesCommand"] = err;
+        const builder = new RDSBuilder("my-db");
+        builder
+            .engine({ engine: "postgres", version: "16" })
+            .size("db.t3.micro")
+            .storage(20);
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.ok(result.endpoint.includes("DRYRUN"));
+        assert.strictEqual(result.port, 5432);
+        const writeCalls = rdsCalls.filter((c) => !c.commandName.startsWith("Describe"));
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test("creates new DB instance with subnet group and security group", async () => {
+        const err = new Error("not found");
+        err.name = "DBInstanceNotFound";
+        mockRdsResponses["DescribeDBInstancesCommand"] = err;
+        // ensureSubnetGroup
+        const noGroup = new Error("not found");
+        noGroup.name = "DBSubnetGroupNotFoundFault";
+        mockRdsResponses["DescribeDBSubnetGroupsCommand"] = noGroup;
+        mockRdsResponses["CreateDBSubnetGroupCommand"] = {};
+        // ensureSecurityGroup
+        mockEc2Responses["DescribeVpcsCommand"] = {
+            Vpcs: [{ VpcId: "vpc-1", CidrBlock: "10.0.0.0/16" }],
+        };
+        mockEc2Responses["DescribeSubnetsCommand"] = {
+            Subnets: [{ SubnetId: "subnet-1" }],
+        };
+        mockEc2Responses["DescribeSecurityGroupsCommand"] = { SecurityGroups: [] };
+        mockEc2Responses["CreateSecurityGroupCommand"] = { GroupId: "sg-1" };
+        // CreateDBInstance- return available immediately so the waitFor resolves
+        mockRdsResponses["CreateDBInstanceCommand"] = {};
+        let describeCount = 0;
+        mockRdsResponses["DescribeDBInstancesCommand"] = (input) => {
+            describeCount++;
+            if (describeCount === 1) {
+                // First call: discovery in constructor- instance not found
+                const notFound = new Error("not found");
+                notFound.name = "DBInstanceNotFound";
+                throw notFound;
+            }
+            // Subsequent calls: waitFor polling- instance now available
+            return {
+                DBInstances: [
+                    {
+                        DBInstanceIdentifier: "my-db",
+                        DBInstanceStatus: "available",
+                        DBInstanceArn: "arn:aws:rds:us-east-1:123:db:my-db",
+                        Endpoint: { Address: "my-db.xyz.rds.amazonaws.com", Port: 5432 },
+                    },
+                ],
+            };
+        };
+        // Fast-forward poll timer
+        mock.method(global, "setTimeout", (fn) => fn());
+        const builder = new RDSBuilder("my-db");
+        builder
+            .engine({ engine: "postgres", version: "16" })
+            .size("db.t3.small")
+            .storage(40)
+            .credentials("admin", "secret");
+        const result = await builder.deploy();
+        assert.ok(result);
+        const createCall = rdsCalls.find((c) => c.commandName === "CreateDBInstanceCommand");
+        assert.ok(createCall);
+        assert.strictEqual(createCall.input.DBInstanceIdentifier, "my-db");
+        assert.strictEqual(createCall.input.Engine, "postgres");
+        assert.strictEqual(createCall.input.EngineVersion, "16");
+        assert.strictEqual(createCall.input.DBInstanceClass, "db.t3.small");
+        assert.strictEqual(createCall.input.AllocatedStorage, 40);
+    });
+    test("modifies existing instance on update", async () => {
+        mockRdsResponses["DescribeDBInstancesCommand"] = {
+            DBInstances: [
+                {
+                    DBInstanceIdentifier: "my-db",
+                    DBInstanceStatus: "available",
+                    DBInstanceArn: "arn:aws:rds:us-east-1:123:db:my-db",
+                    Endpoint: { Address: "my-db.xyz.rds.amazonaws.com", Port: 5432 },
+                },
+            ],
+        };
+        // ensureSubnetGroup (existing)
+        mockRdsResponses["DescribeDBSubnetGroupsCommand"] = {
+            DBSubnetGroups: [{ DBSubnetGroupName: "puls-my-db-subnet-group" }],
+        };
+        const builder = new RDSBuilder("my-db");
+        builder
+            .engine({ engine: "postgres", version: "16" })
+            .size("db.t3.medium")
+            .subnets(["subnet-1"])
+            .securityGroups(["sg-1"])
+            .credentials("admin", "secret");
+        await builder.deploy();
+        const modifyCall = rdsCalls.find((c) => c.commandName === "ModifyDBInstanceCommand");
+        assert.ok(modifyCall);
+        assert.strictEqual(modifyCall.input.DBInstanceClass, "db.t3.medium");
+        assert.strictEqual(modifyCall.input.ApplyImmediately, true);
+    });
+    test("deletes instance on destroy", async () => {
+        mockRdsResponses["DescribeDBInstancesCommand"] = {
+            DBInstances: [
+                {
+                    DBInstanceIdentifier: "my-db",
+                    DBInstanceStatus: "available",
+                    DBInstanceArn: "arn:aws:rds:us-east-1:123:db:my-db",
+                    Endpoint: { Address: "my-db.xyz.rds.amazonaws.com", Port: 5432 },
+                },
+            ],
+        };
+        const builder = new RDSBuilder("my-db");
+        await builder.discoveryPromise;
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: "my-db" });
+        const deleteCall = rdsCalls.find((c) => c.commandName === "DeleteDBInstanceCommand");
+        assert.ok(deleteCall);
+        assert.strictEqual(deleteCall.input.DBInstanceIdentifier, "my-db");
+        assert.strictEqual(deleteCall.input.SkipFinalSnapshot, true);
+    });
+    test("getDiff returns field changes against live state", () => {
+        const err = new Error("not found");
+        err.name = "DBInstanceNotFound";
+        mockRdsResponses["DescribeDBInstancesCommand"] = err;
+        const builder = new RDSBuilder("my-db");
+        builder
+            .engine({ engine: "postgres", version: "16" })
+            .size("db.t3.small")
+            .storage(40);
+        const diffs = builder.getDiff({
+            Engine: "postgres",
+            EngineVersion: "15", // differs
+            DBInstanceClass: "db.t3.micro", // differs
+            AllocatedStorage: 40,
+            PubliclyAccessible: false,
+        });
+        assert.strictEqual(diffs.length, 2);
+        assert.ok(diffs.some((d) => d.field === "engineVersion"));
+        assert.ok(diffs.some((d) => d.field === "instanceClass"));
+    });
+});

package/dist/providers/aws/sqs.test.d.ts

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

package/dist/providers/aws/sqs.test.js

@@ -0,0 +1,181 @@
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { SQSClient } from '@aws-sdk/client-sqs';
+import { SQSBuilder } from './sqs.js';
+import { Config } from '../../core/config.js';
+describe('SQSBuilder Unit Tests', () => {
+    let originalSend;
+    let calls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({ dryRun: false, providers: { aws: { region: 'us-east-1' } } });
+        calls = [];
+        mockResponses = {};
+        originalSend = SQSClient.prototype.send;
+        SQSClient.prototype.send = async function (command) {
+            const commandName = command.constructor.name;
+            calls.push({ commandName, input: command.input });
+            const handler = mockResponses[commandName];
+            if (handler) {
+                if (typeof handler === 'function')
+                    return handler(command.input);
+                if (handler instanceof Error)
+                    throw handler;
+                return handler;
+            }
+            return {};
+        };
+    });
+    afterEach(() => {
+        SQSClient.prototype.send = originalSend;
+    });
+    test('returns null when queue does not exist', async () => {
+        const err = new Error('no queue');
+        err.name = 'QueueDoesNotExist';
+        mockResponses['GetQueueUrlCommand'] = err;
+        const builder = new SQSBuilder('my-queue');
+        const result = await builder.discoveryPromise;
+        assert.strictEqual(result, null);
+        assert.strictEqual(calls[0].commandName, 'GetQueueUrlCommand');
+    });
+    test('discovers existing queue and populates resolvedUrl and resolvedArn', async () => {
+        mockResponses['GetQueueUrlCommand'] = {
+            QueueUrl: 'https://sqs.us-east-1.amazonaws.com/123/my-queue',
+        };
+        mockResponses['GetQueueAttributesCommand'] = {
+            Attributes: { QueueArn: 'arn:aws:sqs:us-east-1:123:my-queue' },
+        };
+        const builder = new SQSBuilder('my-queue');
+        const result = await builder.discoveryPromise;
+        assert.ok(result);
+        assert.strictEqual(builder.resolvedUrl, 'https://sqs.us-east-1.amazonaws.com/123/my-queue');
+        assert.strictEqual(builder.resolvedArn, 'arn:aws:sqs:us-east-1:123:my-queue');
+    });
+    test('performs dry-run without creating the queue', async () => {
+        Config.set({ dryRun: true, providers: { aws: { region: 'us-east-1' } } });
+        const err = new Error('no queue');
+        err.name = 'QueueDoesNotExist';
+        mockResponses['GetQueueUrlCommand'] = err;
+        const builder = new SQSBuilder('my-queue');
+        builder.retention(7).timeout(60);
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.ok(result.url.includes('DRYRUN'));
+        assert.ok(result.arn.includes('DRYRUN'));
+        const writeCalls = calls.filter((c) => c.commandName === 'CreateQueueCommand');
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test('creates new standard queue with configured attributes', async () => {
+        const err = new Error('no queue');
+        err.name = 'QueueDoesNotExist';
+        mockResponses['GetQueueUrlCommand'] = err;
+        mockResponses['CreateQueueCommand'] = {
+            QueueUrl: 'https://sqs.us-east-1.amazonaws.com/123/my-queue',
+        };
+        mockResponses['GetQueueAttributesCommand'] = {
+            Attributes: { QueueArn: 'arn:aws:sqs:us-east-1:123:my-queue' },
+        };
+        const builder = new SQSBuilder('my-queue');
+        builder.retention(7).timeout(45).delay(5);
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, 'my-queue');
+        assert.strictEqual(result.url, 'https://sqs.us-east-1.amazonaws.com/123/my-queue');
+        const createCall = calls.find((c) => c.commandName === 'CreateQueueCommand');
+        assert.ok(createCall);
+        assert.strictEqual(createCall.input.Attributes.VisibilityTimeout, '45');
+        assert.strictEqual(createCall.input.Attributes.MessageRetentionPeriod, String(7 * 86400));
+        assert.strictEqual(createCall.input.Attributes.DelaySeconds, '5');
+    });
+    test('creates FIFO queue with .fifo suffix appended automatically', async () => {
+        const err = new Error('no queue');
+        err.name = 'QueueDoesNotExist';
+        mockResponses['GetQueueUrlCommand'] = err;
+        mockResponses['CreateQueueCommand'] = {
+            QueueUrl: 'https://sqs.us-east-1.amazonaws.com/123/my-queue.fifo',
+        };
+        mockResponses['GetQueueAttributesCommand'] = {
+            Attributes: { QueueArn: 'arn:aws:sqs:us-east-1:123:my-queue.fifo' },
+        };
+        const builder = new SQSBuilder('my-queue');
+        builder.fifo().deduplication();
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, 'my-queue.fifo');
+        const createCall = calls.find((c) => c.commandName === 'CreateQueueCommand');
+        assert.ok(createCall);
+        assert.strictEqual(createCall.input.QueueName, 'my-queue.fifo');
+        assert.strictEqual(createCall.input.Attributes.FifoQueue, 'true');
+        assert.strictEqual(createCall.input.Attributes.ContentBasedDeduplication, 'true');
+    });
+    test('creates DLQ before main queue and wires redrive policy', async () => {
+        const err = new Error('no queue');
+        err.name = 'QueueDoesNotExist';
+        let getUrlCallCount = 0;
+        mockResponses['GetQueueUrlCommand'] = (input) => {
+            getUrlCallCount++;
+            if (getUrlCallCount === 1)
+                throw err; // discovery: queue not found
+            // DLQ lookup in ensureQueue: also not found
+            if (input.QueueName === 'my-dlq')
+                throw err;
+            return { QueueUrl: `https://sqs.us-east-1.amazonaws.com/123/${input.QueueName}` };
+        };
+        mockResponses['CreateQueueCommand'] = (input) => ({
+            QueueUrl: `https://sqs.us-east-1.amazonaws.com/123/${input.QueueName}`,
+        });
+        mockResponses['GetQueueAttributesCommand'] = (input) => ({
+            Attributes: { QueueArn: `arn:aws:sqs:us-east-1:123:${input.QueueUrl?.split('/').pop()}` },
+        });
+        const builder = new SQSBuilder('my-queue');
+        builder.dlq('my-dlq', 5);
+        const result = await builder.deploy();
+        assert.ok(result);
+        const dlqCreate = calls.find((c) => c.commandName === 'CreateQueueCommand' && c.input.QueueName === 'my-dlq');
+        assert.ok(dlqCreate);
+        const mainCreate = calls.find((c) => c.commandName === 'CreateQueueCommand' && c.input.QueueName === 'my-queue');
+        assert.ok(mainCreate);
+        const redrivePolicy = JSON.parse(mainCreate.input.Attributes.RedrivePolicy);
+        assert.strictEqual(redrivePolicy.maxReceiveCount, 5);
+        assert.ok(redrivePolicy.deadLetterTargetArn.includes('my-dlq'));
+    });
+    test('updates mutable attributes on existing queue', async () => {
+        mockResponses['GetQueueUrlCommand'] = {
+            QueueUrl: 'https://sqs.us-east-1.amazonaws.com/123/my-queue',
+        };
+        mockResponses['GetQueueAttributesCommand'] = {
+            Attributes: { QueueArn: 'arn:aws:sqs:us-east-1:123:my-queue' },
+        };
+        const builder = new SQSBuilder('my-queue');
+        builder.retention(14).timeout(120);
+        await builder.deploy();
+        const setAttr = calls.find((c) => c.commandName === 'SetQueueAttributesCommand');
+        assert.ok(setAttr);
+        assert.strictEqual(setAttr.input.Attributes.VisibilityTimeout, '120');
+        assert.strictEqual(setAttr.input.Attributes.MessageRetentionPeriod, String(14 * 86400));
+    });
+    test('deletes queue on destroy', async () => {
+        mockResponses['GetQueueUrlCommand'] = {
+            QueueUrl: 'https://sqs.us-east-1.amazonaws.com/123/my-queue',
+        };
+        mockResponses['GetQueueAttributesCommand'] = {
+            Attributes: { QueueArn: 'arn:aws:sqs:us-east-1:123:my-queue' },
+        };
+        const builder = new SQSBuilder('my-queue');
+        await builder.discoveryPromise;
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: 'my-queue' });
+        const deleteCall = calls.find((c) => c.commandName === 'DeleteQueueCommand');
+        assert.ok(deleteCall);
+        assert.strictEqual(deleteCall.input.QueueUrl, 'https://sqs.us-east-1.amazonaws.com/123/my-queue');
+    });
+    test('skips destroy when queue does not exist', async () => {
+        const err = new Error('no queue');
+        err.name = 'QueueDoesNotExist';
+        mockResponses['GetQueueUrlCommand'] = err;
+        const builder = new SQSBuilder('my-queue');
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: 'my-queue' });
+        assert.ok(!calls.some((c) => c.commandName === 'DeleteQueueCommand'));
+    });
+});

package/dist/providers/cloudflare/api.d.ts

@@ -0,0 +1,15 @@
+export declare class CloudflareApiClient {
+    private token;
+    private static readonly BASE;
+    constructor(token: string);
+    private get authHeaders();
+    private createCfOfflineMock;
+    private request;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body: unknown): Promise<T>;
+    put<T>(path: string, body: unknown, headers?: Record<string, string>): Promise<T>;
+    patch<T>(path: string, body: unknown): Promise<T>;
+    delete(path: string, body?: unknown): Promise<void>;
+}
+export declare function getCloudflareApi(): CloudflareApiClient;
+export declare function getCloudflareAccountId(): string;

package/dist/providers/cloudflare/api.js

@@ -0,0 +1,199 @@
+import { Config } from "../../core/config.js";
+import { withRetry } from "../../core/retry.js";
+import { resourceContextStorage } from "../../core/context.js";
+export class CloudflareApiClient {
+    token;
+    static BASE = "https://api.cloudflare.com/client/v4";
+    constructor(token) {
+        this.token = token;
+    }
+    get authHeaders() {
+        return {
+            Authorization: `Bearer ${this.token}`,
+            "Content-Type": "application/json",
+        };
+    }
+    createCfOfflineMock(method, path, body) {
+        if (path.includes("/zones") && !path.includes("/dns_records") && !path.includes("/routes")) {
+            if (method === "GET") {
+                return {
+                    result: [
+                        { id: "mock-zone-id", name: "mock-domain.com", status: "active" }
+                    ]
+                };
+            }
+            return {
+                result: { id: "mock-zone-id", name: "mock-domain.com", status: "active" }
+            };
+        }
+        if (path.includes("/dns_records")) {
+            if (method === "GET") {
+                return { result: [] };
+            }
+            return { result: { id: "mock-dns-record-id" } };
+        }
+        if (path.includes("/namespaces")) {
+            if (method === "GET") {
+                return {
+                    result: [
+                        { id: "mock-kv-namespace-id", title: "mock-namespace" }
+                    ]
+                };
+            }
+            return { result: { id: "mock-kv-namespace-id", title: "mock-namespace" } };
+        }
+        if (path.includes("/workers/scripts")) {
+            return { result: { id: "mock-worker-script-id" } };
+        }
+        if (path.includes("/routes")) {
+            if (method === "GET") {
+                return { result: [] };
+            }
+            return { result: { id: "mock-route-id" } };
+        }
+        if (path.includes("/r2/buckets")) {
+            if (method === "GET") {
+                return { result: { buckets: [] } };
+            }
+            return { result: {} };
+        }
+        return new Proxy({}, {
+            get(target, prop) {
+                if (prop === "then")
+                    return undefined;
+                if (prop === "id")
+                    return "mock-cf-id-123456";
+                if (prop === "name")
+                    return "mock-cf-name";
+                if (prop === "status")
+                    return "active";
+                if (prop.endsWith("s"))
+                    return [];
+                return `mock-cf-${prop.toLowerCase()}`;
+            }
+        });
+    }
+    async request(fn) {
+        return withRetry(fn, {
+            retryable: (err) => {
+                const match = err.message.match(/: (\d+)/);
+                const status = match ? parseInt(match[1], 10) : null;
+                return status === 429 || (status && status >= 500) || err.message.includes("ETIMEDOUT");
+            }
+        });
+    }
+    async get(path) {
+        const context = resourceContextStorage.getStore();
+        const abortSignal = context?.abortSignal;
+        if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+            return Promise.resolve(this.createCfOfflineMock("GET", path));
+        }
+        return this.request(async () => {
+            const res = await fetch(`${CloudflareApiClient.BASE}${path}`, {
+                headers: this.authHeaders,
+                ...(abortSignal && { signal: abortSignal })
+            });
+            if (!res.ok)
+                throw new Error(`Cloudflare API GET ${path}: ${res.status} ${await res.text()}`);
+            return res.json();
+        });
+    }
+    async post(path, body) {
+        const context = resourceContextStorage.getStore();
+        const abortSignal = context?.abortSignal;
+        if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+            return Promise.resolve(this.createCfOfflineMock("POST", path, body));
+        }
+        return this.request(async () => {
+            const res = await fetch(`${CloudflareApiClient.BASE}${path}`, {
+                method: "POST",
+                headers: this.authHeaders,
+                body: JSON.stringify(body),
+                ...(abortSignal && { signal: abortSignal })
+            });
+            if (!res.ok)
+                throw new Error(`Cloudflare API POST ${path}: ${res.status} ${await res.text()}`);
+            return res.json();
+        });
+    }
+    async put(path, body, headers) {
+        const context = resourceContextStorage.getStore();
+        const abortSignal = context?.abortSignal;
+        if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+            return Promise.resolve(this.createCfOfflineMock("PUT", path, body));
+        }
+        return this.request(async () => {
+            const isMultipartOrRaw = body instanceof FormData || typeof body === "string" || body instanceof Buffer;
+            const customHeaders = headers ?? (isMultipartOrRaw ? {} : { "Content-Type": "application/json" });
+            const reqHeaders = {
+                Authorization: `Bearer ${this.token}`,
+                ...customHeaders,
+            };
+            const res = await fetch(`${CloudflareApiClient.BASE}${path}`, {
+                method: "PUT",
+                headers: reqHeaders,
+                body: isMultipartOrRaw ? body : JSON.stringify(body),
+                ...(abortSignal && { signal: abortSignal })
+            });
+            if (!res.ok)
+                throw new Error(`Cloudflare API PUT ${path}: ${res.status} ${await res.text()}`);
+            return res.json();
+        });
+    }
+    async patch(path, body) {
+        const context = resourceContextStorage.getStore();
+        const abortSignal = context?.abortSignal;
+        if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+            return Promise.resolve(this.createCfOfflineMock("PATCH", path, body));
+        }
+        return this.request(async () => {
+            const res = await fetch(`${CloudflareApiClient.BASE}${path}`, {
+                method: "PATCH",
+                headers: this.authHeaders,
+                body: JSON.stringify(body),
+                ...(abortSignal && { signal: abortSignal })
+            });
+            if (!res.ok)
+                throw new Error(`Cloudflare API PATCH ${path}: ${res.status} ${await res.text()}`);
+            return res.json();
+        });
+    }
+    async delete(path, body) {
+        const context = resourceContextStorage.getStore();
+        const abortSignal = context?.abortSignal;
+        if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+            return Promise.resolve();
+        }
+        return this.request(async () => {
+            const res = await fetch(`${CloudflareApiClient.BASE}${path}`, {
+                method: "DELETE",
+                headers: this.authHeaders,
+                ...(body !== undefined && { body: JSON.stringify(body) }),
+                ...(abortSignal && { signal: abortSignal })
+            });
+            if (!res.ok && res.status !== 404) {
+                throw new Error(`Cloudflare API DELETE ${path}: ${res.status} ${await res.text()}`);
+            }
+        });
+    }
+}
+export function getCloudflareApi() {
+    const token = Config.get().providers.cloudflare?.token;
+    if (!token) {
+        if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+            return new CloudflareApiClient("mock-cf-token");
+        }
+        throw new Error('Cloudflare token not configured. Call CF.init({ token: "..." })');
+    }
+    return new CloudflareApiClient(token);
+}
+export function getCloudflareAccountId() {
+    const accId = Config.get().providers.cloudflare?.accountId;
+    if (!accId) {
+        if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+            return "mock-cf-account-id";
+        }
+        throw new Error("Cloudflare account ID not configured. Account ID is required for Workers, KV namespaces, and R2 buckets.");
+    }
+    return accId;
+}

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

@@ -0,0 +1,14 @@
+import { ZoneBuilder } from "./zone.js";
+import { WorkerBuilder } from "./worker.js";
+import { KVBuilder } from "./kv.js";
+import { R2Builder } from "./r2.js";
+export declare const CF: {
+    init: (opts: {
+        token: string;
+        accountId?: string;
+    }) => void;
+    Zone: (domainName: string) => ZoneBuilder;
+    Worker: (name: string) => WorkerBuilder;
+    KV: (title: string) => KVBuilder;
+    R2: (bucketName: string) => R2Builder;
+};

package/dist/providers/cloudflare/index.js

@@ -0,0 +1,19 @@
+import { Config } from "../../core/config.js";
+import { ZoneBuilder } from "./zone.js";
+import { WorkerBuilder } from "./worker.js";
+import { KVBuilder } from "./kv.js";
+import { R2Builder } from "./r2.js";
+export const CF = {
+    init: (opts) => {
+        Config.set({
+            providers: {
+                ...Config.get().providers,
+                cloudflare: opts,
+            },
+        });
+    },
+    Zone: (domainName) => new ZoneBuilder(domainName),
+    Worker: (name) => new WorkerBuilder(name),
+    KV: (title) => new KVBuilder(title),
+    R2: (bucketName) => new R2Builder(bucketName),
+};

package/dist/providers/cloudflare/kv.d.ts

@@ -0,0 +1,20 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+export declare class KVBuilder extends BaseBuilder {
+    title: string;
+    readonly out: {
+        id: Output<string>;
+    };
+    resolvedId: string | null;
+    constructor(title: string);
+    private discoverNamespace;
+    deploy(): Promise<{
+        title: string;
+        id: string | null;
+    }>;
+    destroy(): Promise<{
+        destroyed: boolean;
+    } | {
+        destroyed: string;
+    }>;
+}