puls-dev 0.3.6 → 0.3.7

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

package/dist/providers/cloudflare/kv.js

@@ -0,0 +1,69 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+import { getCloudflareApi, getCloudflareAccountId } from "./api.js";
+export class KVBuilder extends BaseBuilder {
+    title;
+    out = {
+        id: new Output(),
+    };
+    resolvedId = null;
+    constructor(title) {
+        super(title);
+        this.title = title;
+        this.discoveryPromise = this.discoverNamespace(title);
+    }
+    async discoverNamespace(title) {
+        try {
+            const api = getCloudflareApi();
+            const accountId = getCloudflareAccountId();
+            const res = await api.get(`/accounts/${accountId}/workers/namespaces?per_page=100`);
+            return (res.result ?? []).find((n) => n.title === title) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getCloudflareApi();
+        const accountId = getCloudflareAccountId();
+        console.log(`\n📦 Finalizing Cloudflare KV Namespace "${this.title}"...`);
+        if (existing) {
+            this.resolvedId = existing.id;
+            this.out.id.resolve(existing.id);
+            console.log(`   ✅ KV Namespace "${this.title}" already exists (id=${existing.id})`);
+            return { title: this.title, id: this.resolvedId };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Create KV Namespace "${this.title}"`);
+            this.out.id.resolve("PENDING");
+            return { title: this.title, id: "PENDING" };
+        }
+        const res = await api.post(`/accounts/${accountId}/workers/namespaces`, {
+            title: this.title,
+        });
+        this.resolvedId = res.result.id;
+        this.out.id.resolve(this.resolvedId);
+        console.log(`🚀 Created KV Namespace "${this.title}" (id=${this.resolvedId})`);
+        return { title: this.title, id: this.resolvedId };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getCloudflareApi();
+        const accountId = getCloudflareAccountId();
+        console.log(`\n🗑️  Destroying Cloudflare KV Namespace "${this.title}"...`);
+        if (!existing) {
+            console.log(`   ─  KV Namespace "${this.title}" not found`);
+            return { destroyed: false };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete KV Namespace "${this.title}" (id=${existing.id})`);
+            return { destroyed: this.title };
+        }
+        await api.delete(`/accounts/${accountId}/workers/namespaces/${existing.id}`);
+        console.log(`   🗑️  Removed KV Namespace "${this.title}" (id=${existing.id})`);
+        return { destroyed: this.title };
+    }
+}

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

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

package/dist/providers/cloudflare/kv.test.js

@@ -0,0 +1,134 @@
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import { KVBuilder } from "./kv.js";
+import { Config } from "../../core/config.js";
+describe("KVBuilder Unit Tests", () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? "GET";
+            let body;
+            if (init?.body) {
+                if (typeof init.body === "string") {
+                    try {
+                        body = JSON.parse(init.body);
+                    }
+                    catch {
+                        body = init.body;
+                    }
+                }
+                else {
+                    body = init.body;
+                }
+            }
+            const headers = init?.headers;
+            fetchCalls.push({ url, method, body, headers });
+            const matchKey = Object.keys(mockResponses).find(key => {
+                const [mMethod, mPath] = key.split(" ");
+                return method === mMethod && url.endsWith(mPath);
+            });
+            if (matchKey) {
+                const resp = mockResponses[matchKey];
+                return {
+                    ok: resp.status >= 200 && resp.status < 300,
+                    status: resp.status,
+                    json: async () => resp.body,
+                    text: async () => JSON.stringify(resp.body),
+                };
+            }
+            return {
+                ok: false,
+                status: 404,
+                json: async () => ({ errors: [{ message: "Not found" }] }),
+                text: async () => "Not found",
+            };
+        };
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    test("discovers namespace successfully if it already exists", async () => {
+        mockResponses["GET /accounts/fake-cf-account/workers/namespaces?per_page=100"] = {
+            status: 200,
+            body: {
+                result: [
+                    { id: "kv-123", title: "my-namespace" }
+                ]
+            }
+        };
+        const builder = new KVBuilder("my-namespace");
+        const result = await builder.deploy();
+        assert.strictEqual(result.id, "kv-123");
+        assert.strictEqual(builder.resolvedId, "kv-123");
+        // Deploying again shouldn't send post
+        const deployAgainResult = await builder.deploy();
+        assert.strictEqual(deployAgainResult.id, "kv-123");
+        const posts = fetchCalls.filter(c => c.method === "POST");
+        assert.strictEqual(posts.length, 0);
+    });
+    test("creates namespace if it does not exist", async () => {
+        mockResponses["GET /accounts/fake-cf-account/workers/namespaces?per_page=100"] = {
+            status: 200,
+            body: { result: [] }
+        };
+        mockResponses["POST /accounts/fake-cf-account/workers/namespaces"] = {
+            status: 200,
+            body: { result: { id: "kv-created-456" } }
+        };
+        const builder = new KVBuilder("my-namespace");
+        const result = await builder.deploy();
+        assert.strictEqual(result.id, "kv-created-456");
+        assert.strictEqual(builder.resolvedId, "kv-created-456");
+        const postCall = fetchCalls.find(c => c.method === "POST");
+        assert.ok(postCall);
+        assert.deepStrictEqual(postCall.body, { title: "my-namespace" });
+    });
+    test("does not call fetch during dryRun deploy", async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        mockResponses["GET /accounts/fake-cf-account/workers/namespaces?per_page=100"] = {
+            status: 200,
+            body: { result: [] }
+        };
+        const builder = new KVBuilder("my-namespace");
+        const result = await builder.deploy();
+        assert.strictEqual(result.id, "PENDING");
+        const posts = fetchCalls.filter(c => c.method === "POST");
+        assert.strictEqual(posts.length, 0);
+    });
+    test("destroys namespace successfully if exists", async () => {
+        mockResponses["GET /accounts/fake-cf-account/workers/namespaces?per_page=100"] = {
+            status: 200,
+            body: {
+                result: [
+                    { id: "kv-123", title: "my-namespace" }
+                ]
+            }
+        };
+        mockResponses["DELETE /accounts/fake-cf-account/workers/namespaces/kv-123"] = {
+            status: 200,
+            body: { success: true }
+        };
+        const builder = new KVBuilder("my-namespace");
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: "my-namespace" });
+        const deleteCall = fetchCalls.find(c => c.method === "DELETE");
+        assert.ok(deleteCall);
+    });
+});

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

@@ -0,0 +1,14 @@
+import { BaseBuilder } from "../../core/resource.js";
+export declare class R2Builder extends BaseBuilder {
+    bucketName: string;
+    constructor(bucketName: string);
+    private discoverBucket;
+    deploy(): Promise<{
+        bucket: string;
+    }>;
+    destroy(): Promise<{
+        destroyed: boolean;
+    } | {
+        destroyed: string;
+    }>;
+}