puls-dev 0.2.1 → 0.2.3

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

@@ -0,0 +1,31 @@
+import { BaseBuilder } from "../../core/resource.js";
+export declare class GCPPubSubTopicBuilder extends BaseBuilder {
+    resolvedTopicName: string | null;
+    constructor(topicId: string);
+    private discoverTopic;
+    deploy(): Promise<{
+        name: string;
+        topicName: string | null;
+    }>;
+    destroy(): Promise<{
+        destroyed: string;
+    }>;
+}
+export declare class GCPPubSubSubscriptionBuilder extends BaseBuilder {
+    private _topic?;
+    private _pushEndpoint?;
+    private _ackDeadlineSeconds;
+    resolvedSubscriptionName: string | null;
+    constructor(subscriptionId: string);
+    topic(t: string | GCPPubSubTopicBuilder): this;
+    pushEndpoint(url: string): this;
+    ackDeadline(seconds: number): this;
+    private discoverSubscription;
+    deploy(): Promise<{
+        name: string;
+        subscriptionName: string | null;
+    }>;
+    destroy(): Promise<{
+        destroyed: string;
+    }>;
+}

package/dist/providers/gcp/pubsub.js

@@ -0,0 +1,227 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { gcpFetch, getProjectId } from "./api.js";
+const PUBSUB_BASE = "https://pubsub.googleapis.com";
+export class GCPPubSubTopicBuilder extends BaseBuilder {
+    resolvedTopicName = null;
+    constructor(topicId) {
+        super(topicId);
+        this.discoveryPromise = this.discoverTopic();
+    }
+    async discoverTopic() {
+        try {
+            const project = getProjectId();
+            const res = await gcpFetch(PUBSUB_BASE, `/v1/projects/${project}/topics/${this.name}`);
+            this.resolvedTopicName = res.name ?? null;
+            return res;
+        }
+        catch (e) {
+            if (e.message?.includes("404") ||
+                e.message?.includes("403") ||
+                e.message?.includes("credentials not configured")) {
+                return null;
+            }
+            throw e;
+        }
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const project = getProjectId();
+        const topicId = this.name;
+        const existing = await this.discoveryPromise;
+        console.log(`\n📢 Finalizing GCP Pub/Sub Topic "${topicId}"...`);
+        if (dryRun) {
+            console.log(`   📝 [PLAN] ${existing ? "Update" : "Create"} Pub/Sub topic "${topicId}"`);
+            this.resolvedTopicName = `projects/${project}/topics/${topicId}`;
+            return {
+                name: topicId,
+                topicName: this.resolvedTopicName,
+            };
+        }
+        if (!existing) {
+            console.log(`🚀 Creating GCP Pub/Sub topic "${topicId}"...`);
+            const topic = await gcpFetch(PUBSUB_BASE, `/v1/projects/${project}/topics/${topicId}`, {
+                method: "PUT",
+                body: JSON.stringify({}),
+            });
+            this.resolvedTopicName = topic.name ?? null;
+            console.log(`🚀 Created Pub/Sub topic "${topicId}"`);
+        }
+        else {
+            this.resolvedTopicName = existing.name ?? null;
+            console.log(`   ✅ GCP Pub/Sub topic "${topicId}" already exists.`);
+        }
+        await this.deploySidecars();
+        return {
+            name: topicId,
+            topicName: this.resolvedTopicName,
+        };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const project = getProjectId();
+        const topicId = this.name;
+        console.log(`\n🗑️  Destroying GCP Pub/Sub Topic "${topicId}"...`);
+        const existing = await this.discoverTopic();
+        if (!existing) {
+            console.log(`   ✅ Topic "${topicId}" does not exist - nothing to do.`);
+            return { destroyed: topicId };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete Pub/Sub topic "${topicId}"`);
+            return { destroyed: topicId };
+        }
+        console.log(`   🔄 Deleting Pub/Sub topic "${topicId}"...`);
+        await gcpFetch(PUBSUB_BASE, `/v1/projects/${project}/topics/${topicId}`, {
+            method: "DELETE",
+        });
+        console.log(`   ✅ Pub/Sub topic "${topicId}" deleted.`);
+        await this.destroySidecars();
+        return { destroyed: topicId };
+    }
+}
+export class GCPPubSubSubscriptionBuilder extends BaseBuilder {
+    _topic;
+    _pushEndpoint;
+    _ackDeadlineSeconds = 10;
+    resolvedSubscriptionName = null;
+    constructor(subscriptionId) {
+        super(subscriptionId);
+        this.discoveryPromise = this.discoverSubscription();
+    }
+    topic(t) {
+        this._topic = t;
+        return this;
+    }
+    pushEndpoint(url) {
+        this._pushEndpoint = url;
+        return this;
+    }
+    ackDeadline(seconds) {
+        this._ackDeadlineSeconds = seconds;
+        return this;
+    }
+    async discoverSubscription() {
+        try {
+            const project = getProjectId();
+            const res = await gcpFetch(PUBSUB_BASE, `/v1/projects/${project}/subscriptions/${this.name}`);
+            this.resolvedSubscriptionName = res.name ?? null;
+            return res;
+        }
+        catch (e) {
+            if (e.message?.includes("404") ||
+                e.message?.includes("403") ||
+                e.message?.includes("credentials not configured")) {
+                return null;
+            }
+            throw e;
+        }
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const project = getProjectId();
+        const subscriptionId = this.name;
+        console.log(`\n📥 Finalizing GCP Pub/Sub Subscription "${subscriptionId}"...`);
+        if (!this._topic) {
+            throw new Error(`[GCP.PubSub.Subscription:${subscriptionId}] .topic(...) is required`);
+        }
+        const existing = await this.discoveryPromise;
+        // Resolve full topic name
+        let targetTopicName;
+        if (this._topic instanceof GCPPubSubTopicBuilder) {
+            targetTopicName = this._topic.resolvedTopicName ?? `projects/${project}/topics/${this._topic.name}`;
+        }
+        else {
+            targetTopicName = this._topic.includes("/")
+                ? this._topic
+                : `projects/${project}/topics/${this._topic}`;
+        }
+        const pushConfig = this._pushEndpoint
+            ? { pushEndpoint: this._pushEndpoint }
+            : {};
+        if (dryRun) {
+            console.log(`   📝 [PLAN] ${existing ? "Update" : "Create"} Pub/Sub subscription "${subscriptionId}"`);
+            console.log(`      └─ Topic: ${targetTopicName}`);
+            if (this._pushEndpoint) {
+                console.log(`      └─ Push Endpoint: ${this._pushEndpoint}`);
+            }
+            else {
+                console.log(`      └─ Pull Subscription`);
+            }
+            this.resolvedSubscriptionName = `projects/${project}/subscriptions/${subscriptionId}`;
+            return {
+                name: subscriptionId,
+                subscriptionName: this.resolvedSubscriptionName,
+            };
+        }
+        // Determine if update is needed
+        let needsUpdate = !existing;
+        if (existing) {
+            const existingEndpoint = existing.pushConfig?.pushEndpoint ?? "";
+            const targetEndpoint = this._pushEndpoint ?? "";
+            const hasEndpointChange = existingEndpoint !== targetEndpoint;
+            const hasTopicChange = existing.topic !== targetTopicName;
+            const hasAckChange = (existing.ackDeadlineSeconds ?? 10) !== this._ackDeadlineSeconds;
+            needsUpdate = hasEndpointChange || hasTopicChange || hasAckChange;
+        }
+        const subscriptionBody = {
+            topic: targetTopicName,
+            pushConfig,
+            ackDeadlineSeconds: this._ackDeadlineSeconds,
+        };
+        if (!existing) {
+            console.log(`🚀 Creating GCP Pub/Sub subscription "${subscriptionId}"...`);
+            const sub = await gcpFetch(PUBSUB_BASE, `/v1/projects/${project}/subscriptions/${subscriptionId}`, {
+                method: "PUT",
+                body: JSON.stringify(subscriptionBody),
+            });
+            this.resolvedSubscriptionName = sub.name ?? null;
+            console.log(`🚀 Created Pub/Sub subscription "${subscriptionId}"`);
+        }
+        else if (needsUpdate) {
+            console.log(`🔄 Updating GCP Pub/Sub subscription "${subscriptionId}"...`);
+            const sub = await gcpFetch(PUBSUB_BASE, `/v1/projects/${project}/subscriptions/${subscriptionId}`, {
+                method: "PATCH",
+                body: JSON.stringify({
+                    subscription: {
+                        name: `projects/${project}/subscriptions/${subscriptionId}`,
+                        ...subscriptionBody,
+                    },
+                    updateMask: "topic,pushConfig,ackDeadlineSeconds",
+                }),
+            });
+            this.resolvedSubscriptionName = sub.name ?? null;
+            console.log(`🔄 Updated Pub/Sub subscription "${subscriptionId}"`);
+        }
+        else {
+            this.resolvedSubscriptionName = existing.name ?? null;
+            console.log(`   ✅ GCP Pub/Sub subscription "${subscriptionId}" is up to date.`);
+        }
+        await this.deploySidecars();
+        return {
+            name: subscriptionId,
+            subscriptionName: this.resolvedSubscriptionName,
+        };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const project = getProjectId();
+        const subscriptionId = this.name;
+        console.log(`\n🗑️  Destroying GCP Pub/Sub Subscription "${subscriptionId}"...`);
+        const existing = await this.discoverSubscription();
+        if (!existing) {
+            console.log(`   ✅ Subscription "${subscriptionId}" does not exist - nothing to do.`);
+            return { destroyed: subscriptionId };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete Pub/Sub subscription "${subscriptionId}"`);
+            return { destroyed: subscriptionId };
+        }
+        console.log(`   🔄 Deleting Pub/Sub subscription "${subscriptionId}"...`);
+        await gcpFetch(PUBSUB_BASE, `/v1/projects/${project}/subscriptions/${subscriptionId}`, {
+            method: "DELETE",
+        });
+        console.log(`   ✅ Pub/Sub subscription "${subscriptionId}" deleted.`);
+        await this.destroySidecars();
+        return { destroyed: subscriptionId };
+    }
+}

package/dist/providers/gcp/pubsub.test.d.ts

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

package/dist/providers/gcp/pubsub.test.js

@@ -0,0 +1,244 @@
+import { test, describe, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import { GoogleAuth } from "google-auth-library";
+import { GCPPubSubTopicBuilder, GCPPubSubSubscriptionBuilder } from "./pubsub.js";
+import { Config } from "../../core/config.js";
+describe("GCPPubSub Unit Tests", () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                gcp: {
+                    projectId: "my-gcp-project",
+                    serviceAccountPath: "/fake/sa.json",
+                },
+            },
+        });
+        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 = "[Binary/Buffer Body]";
+                }
+            }
+            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: `Endpoint not mocked: ${method} ${url}` }),
+                text: async () => `Endpoint not mocked: ${method} ${url}`,
+            };
+        };
+        mock.method(GoogleAuth.prototype, "getClient", async () => {
+            return {
+                getAccessToken: async () => ({ token: "fake-gcp-token" }),
+            };
+        });
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        mock.restoreAll();
+    });
+    describe("GCPPubSubTopicBuilder", () => {
+        test("runs in dry-run mode safely and logs plans", async () => {
+            Config.set({
+                dryRun: true,
+            });
+            mockResponses["GET /topics/dryrun-topic"] = {
+                status: 404,
+                body: {},
+            };
+            const builder = new GCPPubSubTopicBuilder("dryrun-topic");
+            const result = await builder.deploy();
+            assert.strictEqual(result.name, "dryrun-topic");
+            assert.strictEqual(result.topicName, "projects/my-gcp-project/topics/dryrun-topic");
+            const writeCalls = fetchCalls.filter((c) => c.method !== "GET");
+            assert.strictEqual(writeCalls.length, 0);
+        });
+        test("creates a new topic when missing", async () => {
+            mockResponses["GET /topics/new-topic"] = {
+                status: 404,
+                body: {},
+            };
+            mockResponses["PUT /topics/new-topic"] = {
+                status: 200,
+                body: { name: "projects/my-gcp-project/topics/new-topic" },
+            };
+            const builder = new GCPPubSubTopicBuilder("new-topic");
+            const result = await builder.deploy();
+            assert.strictEqual(result.name, "new-topic");
+            assert.strictEqual(result.topicName, "projects/my-gcp-project/topics/new-topic");
+            const putCall = fetchCalls.find((c) => c.method === "PUT" && c.url.includes("/topics/new-topic"));
+            assert.ok(putCall);
+        });
+        test("skips creation if topic already exists", async () => {
+            mockResponses["GET /topics/exist-topic"] = {
+                status: 200,
+                body: { name: "projects/my-gcp-project/topics/exist-topic" },
+            };
+            const builder = new GCPPubSubTopicBuilder("exist-topic");
+            const result = await builder.deploy();
+            assert.strictEqual(result.name, "exist-topic");
+            assert.strictEqual(result.topicName, "projects/my-gcp-project/topics/exist-topic");
+            const writeCalls = fetchCalls.filter((c) => c.method !== "GET");
+            assert.strictEqual(writeCalls.length, 0);
+        });
+        test("destroys an existing topic successfully", async () => {
+            mockResponses["GET /topics/delete-topic"] = {
+                status: 200,
+                body: { name: "projects/my-gcp-project/topics/delete-topic" },
+            };
+            mockResponses["DELETE /topics/delete-topic"] = {
+                status: 200,
+                body: {},
+            };
+            const builder = new GCPPubSubTopicBuilder("delete-topic");
+            const result = await builder.destroy();
+            assert.deepStrictEqual(result, { destroyed: "delete-topic" });
+            const deleteCall = fetchCalls.find((c) => c.method === "DELETE" && c.url.includes("/topics/delete-topic"));
+            assert.ok(deleteCall);
+        });
+    });
+    describe("GCPPubSubSubscriptionBuilder", () => {
+        test("fluent builder api sets properties and binds topic references", () => {
+            const topic = new GCPPubSubTopicBuilder("my-t");
+            topic.resolvedTopicName = "projects/my-gcp-project/topics/my-t";
+            const builder = new GCPPubSubSubscriptionBuilder("my-sub")
+                .topic(topic)
+                .pushEndpoint("https://my-endpoint.com/push")
+                .ackDeadline(30);
+            assert.strictEqual(builder._topic, topic);
+            assert.strictEqual(builder._pushEndpoint, "https://my-endpoint.com/push");
+            assert.strictEqual(builder._ackDeadlineSeconds, 30);
+        });
+        test("creates pull subscription when missing", async () => {
+            mockResponses["GET /subscriptions/new-pull-sub"] = {
+                status: 404,
+                body: {},
+            };
+            mockResponses["PUT /subscriptions/new-pull-sub"] = {
+                status: 200,
+                body: { name: "projects/my-gcp-project/subscriptions/new-pull-sub" },
+            };
+            const builder = new GCPPubSubSubscriptionBuilder("new-pull-sub")
+                .topic("my-t")
+                .ackDeadline(20);
+            const result = await builder.deploy();
+            assert.strictEqual(result.name, "new-pull-sub");
+            assert.strictEqual(result.subscriptionName, "projects/my-gcp-project/subscriptions/new-pull-sub");
+            const putCall = fetchCalls.find((c) => c.method === "PUT" && c.url.includes("/subscriptions/new-pull-sub"));
+            assert.ok(putCall);
+            assert.strictEqual(putCall.body.topic, "projects/my-gcp-project/topics/my-t");
+            assert.deepStrictEqual(putCall.body.pushConfig, {});
+            assert.strictEqual(putCall.body.ackDeadlineSeconds, 20);
+        });
+        test("creates push subscription when missing", async () => {
+            mockResponses["GET /subscriptions/new-push-sub"] = {
+                status: 404,
+                body: {},
+            };
+            mockResponses["PUT /subscriptions/new-push-sub"] = {
+                status: 200,
+                body: { name: "projects/my-gcp-project/subscriptions/new-push-sub" },
+            };
+            const builder = new GCPPubSubSubscriptionBuilder("new-push-sub")
+                .topic("my-t")
+                .pushEndpoint("https://my-app.run.app/push");
+            const result = await builder.deploy();
+            assert.strictEqual(result.name, "new-push-sub");
+            const putCall = fetchCalls.find((c) => c.method === "PUT" && c.url.includes("/subscriptions/new-push-sub"));
+            assert.ok(putCall);
+            assert.strictEqual(putCall.body.pushConfig.pushEndpoint, "https://my-app.run.app/push");
+        });
+        test("patches subscription if endpoints differ", async () => {
+            mockResponses["GET /subscriptions/existing-sub"] = {
+                status: 200,
+                body: {
+                    name: "projects/my-gcp-project/subscriptions/existing-sub",
+                    topic: "projects/my-gcp-project/topics/my-t",
+                    pushConfig: { pushEndpoint: "https://old-endpoint.com" },
+                    ackDeadlineSeconds: 10,
+                },
+            };
+            mockResponses["PATCH /subscriptions/existing-sub"] = {
+                status: 200,
+                body: { name: "projects/my-gcp-project/subscriptions/existing-sub" },
+            };
+            const builder = new GCPPubSubSubscriptionBuilder("existing-sub")
+                .topic("my-t")
+                .pushEndpoint("https://new-endpoint.com"); // endpoint changed!
+            const result = await builder.deploy();
+            assert.strictEqual(result.name, "existing-sub");
+            const patchCall = fetchCalls.find((c) => c.method === "PATCH" && c.url.includes("/subscriptions/existing-sub"));
+            assert.ok(patchCall);
+            assert.strictEqual(patchCall.body.subscription.pushConfig.pushEndpoint, "https://new-endpoint.com");
+            assert.strictEqual(patchCall.body.updateMask, "topic,pushConfig,ackDeadlineSeconds");
+        });
+        test("skips patching if identical", async () => {
+            mockResponses["GET /subscriptions/ident-sub"] = {
+                status: 200,
+                body: {
+                    name: "projects/my-gcp-project/subscriptions/ident-sub",
+                    topic: "projects/my-gcp-project/topics/my-t",
+                    pushConfig: { pushEndpoint: "https://endpoint.com" },
+                    ackDeadlineSeconds: 20,
+                },
+            };
+            const builder = new GCPPubSubSubscriptionBuilder("ident-sub")
+                .topic("my-t")
+                .pushEndpoint("https://endpoint.com")
+                .ackDeadline(20);
+            const result = await builder.deploy();
+            assert.strictEqual(result.name, "ident-sub");
+            const writeCalls = fetchCalls.filter((c) => c.method !== "GET");
+            assert.strictEqual(writeCalls.length, 0);
+        });
+        test("destroys an existing subscription successfully", async () => {
+            mockResponses["GET /subscriptions/delete-sub"] = {
+                status: 200,
+                body: { name: "projects/my-gcp-project/subscriptions/delete-sub" },
+            };
+            mockResponses["DELETE /subscriptions/delete-sub"] = {
+                status: 200,
+                body: {},
+            };
+            const builder = new GCPPubSubSubscriptionBuilder("delete-sub");
+            const result = await builder.destroy();
+            assert.deepStrictEqual(result, { destroyed: "delete-sub" });
+            const deleteCall = fetchCalls.find((c) => c.method === "DELETE" && c.url.includes("/subscriptions/delete-sub"));
+            assert.ok(deleteCall);
+        });
+    });
+});

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

@@ -0,0 +1,21 @@
+import { BaseBuilder } from "../../core/resource.js";
+export declare class GCPSecretBuilder extends BaseBuilder {
+    private _value?;
+    resolvedValue: string | null;
+    resolvedArn: string | null;
+    constructor(secretId: string);
+    private fetchSecret;
+    awaitValue(): Promise<string | null>;
+    plainText(v: string): this;
+    keyValue(obj: object): this;
+    deploy(): Promise<{
+        name: string;
+        arn: string | null;
+        value: string | null;
+    }>;
+    destroy(): Promise<{
+        destroyed: string;
+    }>;
+    private discoverSecretMetadata;
+}
+export declare function resolveGCPEnvVars(env: Record<string, string | GCPSecretBuilder>, isDryRun?: boolean): Promise<Record<string, string>>;