@causa/workspace-google 0.18.0-beta.2 → 0.18.0-beta.4

package/dist/emulators/identity-platform.js

@@ -19,6 +19,18 @@ export function getIdentityPlatformContainerName(context) {
     return `${workspaceName}-identity-platform`;
 }
 /**
- * The port on which the Firebase Auth emulator is listening.
+ * The default host port on which the Firebase Auth emulator is listening.
  */
 export const FIREBASE_AUTH_PORT = 9099;
+/**
+ * Returns the host port to which the Identity Platform (Firebase Auth) emulator should be bound.
+ * Reads `google.identityPlatform.emulator.port`, falling back to {@link FIREBASE_AUTH_PORT}.
+ *
+ * @param context The {@link WorkspaceContext}.
+ * @returns The host port for the Identity Platform emulator.
+ */
+export function getIdentityPlatformEmulatorPort(context) {
+    return (context
+        .asConfiguration()
+        .get('google.identityPlatform.emulator.port') ?? FIREBASE_AUTH_PORT);
+}

package/dist/emulators/pubsub.d.ts

@@ -11,9 +11,17 @@ export declare const PUBSUB_EMULATOR_NAME = "google.pubSub";
  */
 export declare function getPubSubContainerName(context: WorkspaceContext): string;
 /**
- * The port on which the Pub/Sub emulator is listening.
+ * The default host port on which the Pub/Sub emulator is listening.
  */
 export declare const PUBSUB_PORT = 8085;
+/**
+ * Returns the host port to which the Pub/Sub emulator should be bound.
+ * Reads `google.pubSub.emulator.port`, falling back to {@link PUBSUB_PORT}.
+ *
+ * @param context The {@link WorkspaceContext}.
+ * @returns The host port for the Pub/Sub emulator.
+ */
+export declare function getPubSubEmulatorPort(context: WorkspaceContext): number;
 /**
  * Formats the name of a Pub/Sub topic as an environment variable.
  * The value of the corresponding environment variable is expected to be the Pub/Sub topic ID, e.g.

package/dist/emulators/pubsub.js

@@ -19,9 +19,21 @@ export function getPubSubContainerName(context) {
     return `${workspaceName}-pubsub`;
 }
 /**
- * The port on which the Pub/Sub emulator is listening.
+ * The default host port on which the Pub/Sub emulator is listening.
  */
 export const PUBSUB_PORT = 8085;
+/**
+ * Returns the host port to which the Pub/Sub emulator should be bound.
+ * Reads `google.pubSub.emulator.port`, falling back to {@link PUBSUB_PORT}.
+ *
+ * @param context The {@link WorkspaceContext}.
+ * @returns The host port for the Pub/Sub emulator.
+ */
+export function getPubSubEmulatorPort(context) {
+    return (context
+        .asConfiguration()
+        .get('google.pubSub.emulator.port') ?? PUBSUB_PORT);
+}
 /**
  * Formats the name of a Pub/Sub topic as an environment variable.
  * The value of the corresponding environment variable is expected to be the Pub/Sub topic ID, e.g.

package/dist/emulators/spanner.d.ts

@@ -15,10 +15,26 @@ export declare function getSpannerContainerName(context: WorkspaceContext): stri
  */
 export declare const SPANNER_IMAGE = "gcr.io/cloud-spanner-emulator/emulator";
 /**
- * The port on which the Spanner emulator exposes its gRPC API.
+ * The default host port on which the Spanner emulator exposes its gRPC API.
  */
 export declare const SPANNER_GRPC_PORT = 9010;
 /**
- * The port on which the Spanner emulator exposes its HTTP API.
+ * The default host port on which the Spanner emulator exposes its HTTP API.
  */
 export declare const SPANNER_HTTP_PORT = 9020;
+/**
+ * Returns the host port to which the Spanner emulator gRPC API should be bound.
+ * Reads `google.spanner.emulator.grpcPort`, falling back to {@link SPANNER_GRPC_PORT}.
+ *
+ * @param context The {@link WorkspaceContext}.
+ * @returns The host gRPC port for the Spanner emulator.
+ */
+export declare function getSpannerEmulatorGrpcPort(context: WorkspaceContext): number;
+/**
+ * Returns the host port to which the Spanner emulator HTTP API should be bound.
+ * Reads `google.spanner.emulator.httpPort`, falling back to {@link SPANNER_HTTP_PORT}.
+ *
+ * @param context The {@link WorkspaceContext}.
+ * @returns The host HTTP port for the Spanner emulator.
+ */
+export declare function getSpannerEmulatorHttpPort(context: WorkspaceContext): number;

package/dist/emulators/spanner.js

@@ -23,10 +23,34 @@ export function getSpannerContainerName(context) {
  */
 export const SPANNER_IMAGE = `gcr.io/cloud-spanner-emulator/emulator`;
 /**
- * The port on which the Spanner emulator exposes its gRPC API.
+ * The default host port on which the Spanner emulator exposes its gRPC API.
  */
 export const SPANNER_GRPC_PORT = 9010;
 /**
- * The port on which the Spanner emulator exposes its HTTP API.
+ * The default host port on which the Spanner emulator exposes its HTTP API.
  */
 export const SPANNER_HTTP_PORT = 9020;
+/**
+ * Returns the host port to which the Spanner emulator gRPC API should be bound.
+ * Reads `google.spanner.emulator.grpcPort`, falling back to {@link SPANNER_GRPC_PORT}.
+ *
+ * @param context The {@link WorkspaceContext}.
+ * @returns The host gRPC port for the Spanner emulator.
+ */
+export function getSpannerEmulatorGrpcPort(context) {
+    return (context
+        .asConfiguration()
+        .get('google.spanner.emulator.grpcPort') ?? SPANNER_GRPC_PORT);
+}
+/**
+ * Returns the host port to which the Spanner emulator HTTP API should be bound.
+ * Reads `google.spanner.emulator.httpPort`, falling back to {@link SPANNER_HTTP_PORT}.
+ *
+ * @param context The {@link WorkspaceContext}.
+ * @returns The host HTTP port for the Spanner emulator.
+ */
+export function getSpannerEmulatorHttpPort(context) {
+    return (context
+        .asConfiguration()
+        .get('google.spanner.emulator.httpPort') ?? SPANNER_HTTP_PORT);
+}

package/dist/functions/emulator/start-firebase-storage.js

@@ -1,6 +1,6 @@
 import { EmulatorStart } from '@causa/workspace-core';
 import { fileURLToPath } from 'url';
-import { FIREBASE_CONTAINER_STORAGE_RULES_FILE, FIREBASE_STORAGE_EMULATOR_NAME, FIREBASE_STORAGE_PORT, getFirebaseStorageContainerName, } from '../../emulators/index.js';
+import { FIREBASE_CONTAINER_STORAGE_RULES_FILE, FIREBASE_STORAGE_EMULATOR_NAME, FIREBASE_STORAGE_PORT, getFirebaseStorageContainerName, getFirebaseStorageEmulatorPort, } from '../../emulators/index.js';
 import { FirebaseEmulatorService } from '../../services/firebase-emulator.js';
 import { GoogleFirebaseStorageMergeRules } from '../google-firebase-storage/index.js';
 /**
@@ -30,12 +30,13 @@ export class EmulatorStartForFirebaseStorage extends EmulatorStart {
         const { securityRuleFile } = await this._context.call(GoogleFirebaseStorageMergeRules, {});
         this._context.logger.info('️🍱 Starting Firebase Storage emulator.');
         const containerName = getFirebaseStorageContainerName(this._context);
+        const hostPort = getFirebaseStorageEmulatorPort(this._context);
         const firebaseEmulatorService = this._context.service(FirebaseEmulatorService);
         await firebaseEmulatorService.start(containerName, FIREBASE_CONF_FILE, [
             {
                 host: '127.0.0.1',
                 container: FIREBASE_STORAGE_PORT,
-                local: FIREBASE_STORAGE_PORT,
+                local: hostPort,
             },
         ], {
             mounts: [
@@ -51,7 +52,7 @@ export class EmulatorStartForFirebaseStorage extends EmulatorStart {
         });
         this._context.logger.info('️🍱 Successfully initialized Firebase Storage emulator.');
         return {
-            FIREBASE_STORAGE_EMULATOR_HOST: `127.0.0.1:${FIREBASE_STORAGE_PORT}`,
+            FIREBASE_STORAGE_EMULATOR_HOST: `127.0.0.1:${hostPort}`,
             GOOGLE_CLOUD_PROJECT: firebaseEmulatorService.localGcpProject,
             GCP_PROJECT: firebaseEmulatorService.localGcpProject,
             GCLOUD_PROJECT: firebaseEmulatorService.localGcpProject,

package/dist/functions/emulator/start-firestore.js

@@ -1,5 +1,5 @@
 import { EmulatorStart } from '@causa/workspace-core';
-import { FIRESTORE_CONTAINER_RULES_FILE, FIRESTORE_EMULATOR_NAME, FIRESTORE_PORT, getFirestoreContainerName, } from '../../emulators/index.js';
+import { FIRESTORE_CONTAINER_RULES_FILE, FIRESTORE_EMULATOR_NAME, FIRESTORE_PORT, getFirestoreContainerName, getFirestoreEmulatorPort, } from '../../emulators/index.js';
 import { GcloudEmulatorService } from '../../services/gcloud-emulator.js';
 import { GoogleFirestoreMergeRules } from '../google-firestore/index.js';
 /**
@@ -26,14 +26,9 @@ export class EmulatorStartForFirestore extends EmulatorStart {
         const { securityRuleFile } = await this._context.call(GoogleFirestoreMergeRules, {});
         this._context.logger.info('🗃️ Starting Firestore emulator.');
         const containerName = getFirestoreContainerName(this._context);
+        const hostPort = getFirestoreEmulatorPort(this._context);
         const gcloudEmulatorService = this._context.service(GcloudEmulatorService);
-        await gcloudEmulatorService.start('firestore', containerName, [
-            {
-                host: '127.0.0.1',
-                local: FIRESTORE_PORT,
-                container: FIRESTORE_PORT,
-            },
-        ], {
+        await gcloudEmulatorService.start('firestore', containerName, [{ host: '127.0.0.1', local: hostPort, container: FIRESTORE_PORT }], {
             mounts: [
                 {
                     type: 'bind',
@@ -43,11 +38,11 @@ export class EmulatorStartForFirestore extends EmulatorStart {
                 },
             ],
             additionalArguments: ['--rules', FIRESTORE_CONTAINER_RULES_FILE],
-            availabilityEndpoint: `http://127.0.0.1:${FIRESTORE_PORT}/`,
+            availabilityEndpoint: `http://127.0.0.1:${hostPort}/`,
         });
         this._context.logger.info('🗃️ Successfully initialized Firestore emulator.');
         return {
-            FIRESTORE_EMULATOR_HOST: `127.0.0.1:${FIRESTORE_PORT}`,
+            FIRESTORE_EMULATOR_HOST: `127.0.0.1:${hostPort}`,
             GOOGLE_CLOUD_PROJECT: gcloudEmulatorService.localGcpProject,
             GCP_PROJECT: gcloudEmulatorService.localGcpProject,
             GCLOUD_PROJECT: gcloudEmulatorService.localGcpProject,

package/dist/functions/emulator/start-identity-platform.js

@@ -1,6 +1,6 @@
 import { EmulatorStart } from '@causa/workspace-core';
 import { fileURLToPath } from 'url';
-import { FIREBASE_AUTH_PORT, IDENTITY_PLATFORM_EMULATOR_NAME, getIdentityPlatformContainerName, } from '../../emulators/index.js';
+import { FIREBASE_AUTH_PORT, IDENTITY_PLATFORM_EMULATOR_NAME, getIdentityPlatformContainerName, getIdentityPlatformEmulatorPort, } from '../../emulators/index.js';
 import { FirebaseEmulatorService } from '../../services/firebase-emulator.js';
 /**
  * The Firebase configuration file enabling only the Auth emulator.
@@ -27,17 +27,14 @@ export class EmulatorStartForIdentityPlatform extends EmulatorStart {
         }
         this._context.logger.info('🛂 Starting the Identity Platform emulator.');
         const containerName = getIdentityPlatformContainerName(this._context);
+        const hostPort = getIdentityPlatformEmulatorPort(this._context);
         const firebaseEmulatorService = this._context.service(FirebaseEmulatorService);
         await firebaseEmulatorService.start(containerName, FIREBASE_CONF_FILE, [
-            {
-                host: '127.0.0.1',
-                local: FIREBASE_AUTH_PORT,
-                container: FIREBASE_AUTH_PORT,
-            },
+            { host: '127.0.0.1', local: hostPort, container: FIREBASE_AUTH_PORT },
         ]);
         this._context.logger.info('🛂 Successfully initialized the Identity Platform emulator.');
         return {
-            FIREBASE_AUTH_EMULATOR_HOST: `127.0.0.1:${FIREBASE_AUTH_PORT}`,
+            FIREBASE_AUTH_EMULATOR_HOST: `127.0.0.1:${hostPort}`,
             GOOGLE_CLOUD_PROJECT: firebaseEmulatorService.localGcpProject,
             GCP_PROJECT: firebaseEmulatorService.localGcpProject,
             GCLOUD_PROJECT: firebaseEmulatorService.localGcpProject,

package/dist/functions/emulator/start-pubsub.call.js

@@ -1,7 +1,7 @@
 import { EventTopicList, } from '@causa/workspace-core';
 import { PubSub } from '@google-cloud/pubsub';
 import { getLocalGcpProject } from '../../configurations/utils.js';
-import { PUBSUB_EMULATOR_NAME, PUBSUB_PORT, formatPubSubTopicAsEnvironmentVariable, getPubSubContainerName, } from '../../emulators/index.js';
+import { PUBSUB_EMULATOR_NAME, PUBSUB_PORT, formatPubSubTopicAsEnvironmentVariable, getPubSubContainerName, getPubSubEmulatorPort, } from '../../emulators/index.js';
 import { GcloudEmulatorService } from '../../services/gcloud-emulator.js';
 export default async function call() {
     const configuration = await startPubSub(this, this._context);
@@ -11,27 +11,28 @@ async function startPubSub(self, context) {
     if (self.dryRun) {
         return {};
     }
-    const emulatorConf = await startPubSubEmulator(context);
-    const topicsConf = await createTopicsIfNeeded(context);
+    const hostPort = getPubSubEmulatorPort(context);
+    const emulatorConf = await startPubSubEmulator(context, hostPort);
+    const topicsConf = await createTopicsIfNeeded(context, hostPort);
     context.logger.info('📫 Successfully initialized Pub/Sub emulator.');
     return { ...emulatorConf, ...topicsConf };
 }
-async function startPubSubEmulator(context) {
+async function startPubSubEmulator(context, hostPort) {
     context.logger.info('📫 Starting Pub/Sub emulator.');
     const gcpProject = getLocalGcpProject(context);
     const containerName = getPubSubContainerName(context);
     const gcloudEmulatorService = context.service(GcloudEmulatorService);
-    await gcloudEmulatorService.start('pubsub', containerName, [{ host: '127.0.0.1', local: PUBSUB_PORT, container: PUBSUB_PORT }], {
-        availabilityEndpoint: `http://127.0.0.1:${PUBSUB_PORT}/v1/projects/${gcpProject}/topics`,
+    await gcloudEmulatorService.start('pubsub', containerName, [{ host: '127.0.0.1', local: hostPort, container: PUBSUB_PORT }], {
+        availabilityEndpoint: `http://127.0.0.1:${hostPort}/v1/projects/${gcpProject}/topics`,
     });
     return {
-        PUBSUB_EMULATOR_HOST: `127.0.0.1:${PUBSUB_PORT}`,
+        PUBSUB_EMULATOR_HOST: `127.0.0.1:${hostPort}`,
         GOOGLE_CLOUD_PROJECT: gcloudEmulatorService.localGcpProject,
         GCP_PROJECT: gcloudEmulatorService.localGcpProject,
         GCLOUD_PROJECT: gcloudEmulatorService.localGcpProject,
     };
 }
-async function createTopicsIfNeeded(context) {
+async function createTopicsIfNeeded(context, hostPort) {
     if (context.get('events.broker') !== 'google.pubSub') {
         context.logger.warn('📫️ Pub/Sub is not set as the event broker. Skipping event topics setup.');
         return {};
@@ -40,7 +41,7 @@ async function createTopicsIfNeeded(context) {
     const gcpProject = getLocalGcpProject(context);
     const pubSub = new PubSub({
         projectId: gcpProject,
-        apiEndpoint: `127.0.0.1:${PUBSUB_PORT}`,
+        apiEndpoint: `127.0.0.1:${hostPort}`,
     });
     const envVars = await Promise.all(topics.map(async ({ id }) => {
         context.logger.info(`📫 Creating Pub/Sub emulator topic '${id}'.`);

package/dist/functions/emulator/start-spanner.call.js

@@ -5,7 +5,7 @@ import { Instance, Spanner } from '@google-cloud/spanner';
 // version can be loaded.
 import { grpc } from 'google-gax';
 import { getLocalGcpProject, } from '../../configurations/index.js';
-import { SPANNER_EMULATOR_NAME, SPANNER_GRPC_PORT, SPANNER_HTTP_PORT, SPANNER_IMAGE, getSpannerContainerName, } from '../../emulators/index.js';
+import { SPANNER_EMULATOR_NAME, SPANNER_GRPC_PORT, SPANNER_HTTP_PORT, SPANNER_IMAGE, getSpannerContainerName, getSpannerEmulatorGrpcPort, getSpannerEmulatorHttpPort, } from '../../emulators/index.js';
 import { GoogleSpannerListDatabases } from '../google-spanner/index.js';
 export default async function call() {
     const configuration = await startSpanner(this, this._context);
@@ -15,12 +15,14 @@ async function startSpanner(self, context) {
     if (self.dryRun) {
         return {};
     }
-    const emulatorConf = await startSpannerEmulator(context);
-    const instanceAndDatabaseConf = await initializeEmulator(context);
+    const grpcHostPort = getSpannerEmulatorGrpcPort(context);
+    const httpHostPort = getSpannerEmulatorHttpPort(context);
+    const emulatorConf = await startSpannerEmulator(context, grpcHostPort, httpHostPort);
+    const instanceAndDatabaseConf = await initializeEmulator(context, grpcHostPort);
     context.logger.info('🗃️ Successfully initialized Spanner emulator.');
     return { ...emulatorConf, ...instanceAndDatabaseConf };
 }
-async function startSpannerEmulator(context) {
+async function startSpannerEmulator(context, grpcHostPort, httpHostPort) {
     context.logger.info('🗃️ Starting Spanner emulator.');
     const gcpProject = getLocalGcpProject(context);
     const containerName = getSpannerContainerName(context);
@@ -28,23 +30,22 @@ async function startSpannerEmulator(context) {
         .asConfiguration()
         .get('google.spanner.emulator.version') ?? 'latest';
     const dockerEmulatorService = context.service(DockerEmulatorService);
-    await dockerEmulatorService.start(`${SPANNER_IMAGE}:${imageVersion}`, containerName, [SPANNER_GRPC_PORT, SPANNER_HTTP_PORT].map((p) => ({
-        host: '127.0.0.1',
-        local: p,
-        container: p,
-    })));
-    await dockerEmulatorService.waitForAvailability(containerName, `http://127.0.0.1:${SPANNER_HTTP_PORT}/v1/projects/${gcpProject}/instances`);
+    await dockerEmulatorService.start(`${SPANNER_IMAGE}:${imageVersion}`, containerName, [
+        { host: '127.0.0.1', local: grpcHostPort, container: SPANNER_GRPC_PORT },
+        { host: '127.0.0.1', local: httpHostPort, container: SPANNER_HTTP_PORT },
+    ]);
+    await dockerEmulatorService.waitForAvailability(containerName, `http://127.0.0.1:${httpHostPort}/v1/projects/${gcpProject}/instances`);
     return {
-        SPANNER_EMULATOR_HOST: `127.0.0.1:${SPANNER_GRPC_PORT}`,
+        SPANNER_EMULATOR_HOST: `127.0.0.1:${grpcHostPort}`,
         GOOGLE_CLOUD_PROJECT: gcpProject,
         GCP_PROJECT: gcpProject,
         GCLOUD_PROJECT: gcpProject,
     };
 }
-async function initializeEmulator(context) {
+async function initializeEmulator(context, port) {
     const spanner = new Spanner({
         servicePath: '127.0.0.1',
-        port: SPANNER_GRPC_PORT,
+        port,
         projectId: getLocalGcpProject(context),
         sslCreds: grpc.credentials.createInsecure(),
     });

package/dist/functions/event-topic/broker-create-trigger-cloud-run.call.js

@@ -45,10 +45,18 @@ function resolveFromObject(context, trigger) {
     };
 }
 export default async function call() {
-    const { serviceId, path } = typeof this.trigger === 'string'
-        ? resolveFromString(this._context, this.trigger)
-        : resolveFromObject(this._context, this.trigger);
+    // Cloning is only supported for project-scoped triggers, where the service is defined by the project's configuration.
+    // Raw URI triggers keep targeting the live service.
+    const isProjectScoped = typeof this.trigger !== 'string';
+    const { serviceId, path } = isProjectScoped
+        ? resolveFromObject(this._context, this.trigger)
+        : resolveFromString(this._context, this.trigger);
+    const clone = isProjectScoped
+        ? this._context
+            .asConfiguration()
+            .get('google.cloudRun.eventBackfillServiceCloneConfig')
+        : undefined;
     return await this._context
         .service(CloudRunPubSubTriggerService)
-        .create(this.backfillId, this.topicId, serviceId, path);
+        .create(this.backfillId, this.topicId, serviceId, path, { clone });
 }

package/dist/functions/event-topic/broker-delete-trigger-resource-cloud-run-service.call.d.ts

@@ -0,0 +1,2 @@
+import type { EventTopicBrokerDeleteTriggerResourceForCloudRunService } from './broker-delete-trigger-resource-cloud-run-service.js';
+export default function call(this: EventTopicBrokerDeleteTriggerResourceForCloudRunService): Promise<void>;

package/dist/functions/event-topic/broker-delete-trigger-resource-cloud-run-service.call.js

@@ -0,0 +1,5 @@
+import { CloudRunService } from '../../services/cloud-run.js';
+export default async function call() {
+    this._context.logger.info(`🚀 Deleting temporary Cloud Run service '${this.id}'.`);
+    await this._context.service(CloudRunService).delete(this.id);
+}

package/dist/functions/event-topic/broker-delete-trigger-resource-cloud-run-service.d.ts

@@ -0,0 +1,10 @@
+import { EventTopicBrokerDeleteTriggerResource } from '@causa/workspace-core';
+/**
+ * Implements {@link EventTopicBrokerDeleteTriggerResource} for Cloud Run services.
+ * When `google.cloudRun.eventBackfillServiceCloneConfig` is set, a temporary copy of the Cloud Run service is created
+ * for each project-scoped trigger, isolating the backfill load from production. This function deletes that copy.
+ */
+export declare class EventTopicBrokerDeleteTriggerResourceForCloudRunService extends EventTopicBrokerDeleteTriggerResource {
+    _call(): Promise<void>;
+    _supports(): boolean;
+}

package/dist/functions/event-topic/broker-delete-trigger-resource-cloud-run-service.js

@@ -0,0 +1,19 @@
+import { callDeferred } from '@causa/workspace';
+import { EventTopicBrokerDeleteTriggerResource, } from '@causa/workspace-core';
+import { CLOUD_RUN_SERVICE_ID_REGEX } from '../../services/cloud-run.utils.js';
+/**
+ * Implements {@link EventTopicBrokerDeleteTriggerResource} for Cloud Run services.
+ * When `google.cloudRun.eventBackfillServiceCloneConfig` is set, a temporary copy of the Cloud Run service is created
+ * for each project-scoped trigger, isolating the backfill load from production. This function deletes that copy.
+ */
+export class EventTopicBrokerDeleteTriggerResourceForCloudRunService extends EventTopicBrokerDeleteTriggerResource {
+    async _call() {
+        return await callDeferred(this, import.meta.url);
+    }
+    _supports() {
+        return (CLOUD_RUN_SERVICE_ID_REGEX.test(this.id) &&
+            this._context
+                .asConfiguration()
+                .get('events.broker') === 'google.pubSub');
+    }
+}

package/dist/functions/event-topic/broker-delete-trigger-resource-pubsub-subscription.js

@@ -1,5 +1,6 @@
 import { callDeferred } from '@causa/workspace';
 import { EventTopicBrokerDeleteTriggerResource, } from '@causa/workspace-core';
+import { PUBSUB_SUBSCRIPTION_ID_REGEX } from '../../services/pubsub.utils.js';
 /**
  * Implements {@link EventTopicBrokerDeleteTriggerResource} for Pub/Sub subscriptions.
  * Pub/Sub subscriptions are for example used when creating Cloud Run triggers.
@@ -9,7 +10,7 @@ export class EventTopicBrokerDeleteTriggerResourceForPubSubSubscription extends
         return await callDeferred(this, import.meta.url);
     }
     _supports() {
-        return (this.id.match(/^projects\/[\w-]+\/subscriptions\/[\w-]+$/) != null &&
+        return (PUBSUB_SUBSCRIPTION_ID_REGEX.test(this.id) &&
             this._context
                 .asConfiguration()
                 .get('events.broker') === 'google.pubSub');

package/dist/functions/event-topic/broker-publish-events-google.call.js

@@ -5,23 +5,37 @@ import { PubSubService } from '../../services/index.js';
  */
 const PUBLISH_PROGRESS_LOG_INTERVAL = 10000;
 /**
- * Options when publishing events in batches to Pub/Sub.
+ * Default options when publishing events in batches to Pub/Sub.
+ * These can be overridden through the `google.pubSub.backfillPublishOptions` configuration.
  */
-const PUBLISH_OPTIONS = {
-    flowControlOptions: {
-        maxOutstandingBytes: 10 * 1024 * 1024,
-        maxOutstandingMessages: 1000,
-    },
-    batching: {
-        maxBytes: 10 * 1024 * 1024,
-        maxMessages: 1000,
-        maxMilliseconds: 1000,
-    },
+const DEFAULT_PUBLISH_OPTIONS = {
+    maxOutstandingBytes: 10 * 1024 * 1024,
+    maxOutstandingMessages: 1000,
+    maxBytes: 10 * 1024 * 1024,
+    maxMessages: 1000,
+    maxMilliseconds: 1000,
 };
 export default async function call() {
+    const publishOptions = {
+        ...DEFAULT_PUBLISH_OPTIONS,
+        ...this._context
+            .asConfiguration()
+            .get('google.pubSub.backfillPublishOptions'),
+    };
+    const options = {
+        flowControlOptions: {
+            maxOutstandingBytes: publishOptions.maxOutstandingBytes,
+            maxOutstandingMessages: publishOptions.maxOutstandingMessages,
+        },
+        batching: {
+            maxBytes: publishOptions.maxBytes,
+            maxMessages: publishOptions.maxMessages,
+            maxMilliseconds: publishOptions.maxMilliseconds,
+        },
+    };
     const publisher = this._context
         .service(PubSubService)
-        .pubSub.topic(this.topicId, PUBLISH_OPTIONS)
+        .pubSub.topic(this.topicId, options)
         .flowControlled();
     this._context.logger.info('📫 Publishing events.');
     let numEvents = 0;

package/dist/functions/event-topic/broker-wait-for-processing-pubsub.call.d.ts

@@ -0,0 +1,2 @@
+import type { EventTopicBrokerWaitForProcessingForPubSub } from './broker-wait-for-processing-pubsub.js';
+export default function call(this: EventTopicBrokerWaitForProcessingForPubSub): Promise<void>;

package/dist/functions/event-topic/broker-wait-for-processing-pubsub.call.js

@@ -0,0 +1,119 @@
+import { setTimeout } from 'timers/promises';
+import { CloudMonitoringService, } from '../../services/cloud-monitoring.js';
+import { PUBSUB_SUBSCRIPTION_ID_REGEX, shortSubscriptionId, } from '../../services/index.js';
+/**
+ * The interval between two consecutive polls of the Cloud Monitoring API, in milliseconds.
+ */
+const POLL_INTERVAL = 30 * 1000;
+/**
+ * The duration of the trailing window of points fetched on each poll, in milliseconds.
+ * It must be greater than `QUIET_WINDOW` plus a margin for the Cloud Monitoring export lag.
+ */
+const TRAILING_WINDOW = 10 * 60 * 1000;
+/**
+ * The minimum duration (server-time, derived from point timestamps) over which all three monitored metrics must
+ * continuously report zero before a subscription is considered drained, in milliseconds.
+ */
+const QUIET_WINDOW = 3 * 60 * 1000;
+/**
+ * The alignment period used when querying the cumulative `ack_message_count` metric so that points represent the
+ * number of acks within each bucket (delta), rather than the absolute cumulative value, in seconds.
+ */
+const ALIGNMENT_PERIOD = 60;
+/**
+ * The overall timeout for waiting on a single subscription, in milliseconds.
+ * On timeout the function throws so that the backfill file is preserved for manual cleanup.
+ */
+const TIMEOUT = 60 * 60 * 1000;
+/**
+ * Returns the Cloud Monitoring filter for the given metric on the given subscription.
+ */
+function buildFilter(metricType, subscriptionId) {
+    return [
+        `metric.type = "${metricType}"`,
+        `resource.type = "pubsub_subscription"`,
+        `resource.labels.subscription_id = "${subscriptionId}"`,
+    ].join(' AND ');
+}
+/**
+ * Checks whether a gauge metric has been quiet (zero-valued) for at least {@link QUIET_WINDOW}.
+ *
+ * The check is purely server-side: the latest zero-valued point's timestamp must be at least `QUIET_WINDOW` after the
+ * latest non-zero point's timestamp. When no non-zero point exists in the trailing window, the metric is considered
+ * quiet (the outer liftoff gate is responsible for distinguishing "cold start" from "already drained").
+ */
+function isGaugeQuiet(points) {
+    const lastNonZeroTimestamp = points.filter(({ value }) => value > 0).at(-1)?.timestamp ?? -Infinity;
+    const latestZeroTimestamp = points.filter(({ value }) => value === 0).at(-1)?.timestamp ?? -Infinity;
+    return latestZeroTimestamp - lastNonZeroTimestamp >= QUIET_WINDOW;
+}
+/**
+ * Checks whether a cumulative metric (queried with `ALIGN_DELTA`) has had no non-zero activity in the trailing
+ * `QUIET_WINDOW` before the given reference time.
+ *
+ * Unlike a gauge, Pub/Sub stops writing samples for a cumulative metric while there is no activity. The server-side
+ * "still has zero points" anchor used by {@link isGaugeQuiet} therefore does not apply: the absence of points must be
+ * interpreted against an external time reference (the query end).
+ */
+function isCumulativeQuiet(points, referenceTime) {
+    const lastNonZeroTimestamp = points.filter(({ value }) => value > 0).at(-1)?.timestamp ?? -Infinity;
+    return referenceTime.getTime() - lastNonZeroTimestamp >= QUIET_WINDOW;
+}
+/**
+ * Observes a single subscription by fetching its three metrics over the configured trailing window and evaluating the
+ * liftoff and quiet conditions.
+ */
+async function observeSubscription(context, subscriptionId) {
+    const cms = context.service(CloudMonitoringService);
+    const end = new Date();
+    const start = new Date(end.getTime() - TRAILING_WINDOW);
+    const ackFilter = buildFilter('pubsub.googleapis.com/subscription/ack_message_count', subscriptionId);
+    const backlogFilter = buildFilter('pubsub.googleapis.com/subscription/num_undelivered_messages', subscriptionId);
+    const ageFilter = buildFilter('pubsub.googleapis.com/subscription/oldest_unacked_message_age', subscriptionId);
+    const [ackPoints, backlogPoints, agePoints] = await Promise.all([
+        cms.listPoints(ackFilter, start, end, {
+            aligner: 'ALIGN_DELTA',
+            alignmentPeriod: ALIGNMENT_PERIOD,
+        }),
+        cms.listPoints(backlogFilter, start, end),
+        cms.listPoints(ageFilter, start, end),
+    ]);
+    const liftoff = ackPoints.some(({ value }) => value > 0);
+    const backlog = backlogPoints.at(-1)?.value ?? null;
+    const drained = liftoff &&
+        isCumulativeQuiet(ackPoints, end) &&
+        isGaugeQuiet(backlogPoints) &&
+        isGaugeQuiet(agePoints);
+    return { liftoff, backlog, drained };
+}
+/**
+ * Waits for a single subscription to be drained, polling Cloud Monitoring until either the drained state is reached
+ * or the overall timeout elapses.
+ */
+async function waitForSubscription(context, subscriptionId) {
+    const deadline = Date.now() + TIMEOUT;
+    while (true) {
+        const { drained, backlog, liftoff } = await observeSubscription(context, subscriptionId);
+        if (drained) {
+            context.logger.debug(`✅ Subscription '${subscriptionId}' drained: backlog is empty and metrics have been quiet for at least ${QUIET_WINDOW / 1000}s.`);
+            return;
+        }
+        const backlogLabel = backlog === null ? 'no data yet' : `backlog=${backlog}`;
+        context.logger.debug(`⏳ Subscription '${subscriptionId}' not drained yet (liftoff=${liftoff}, ${backlogLabel}).`);
+        if (Date.now() >= deadline) {
+            throw new Error(`Timed out after ${Math.round(TIMEOUT / 60_000)} minute(s) waiting for subscription '${subscriptionId}' to drain.`);
+        }
+        await setTimeout(POLL_INTERVAL);
+    }
+}
+export default async function call() {
+    const subscriptionIds = this.temporaryData.temporaryTriggerResourceIds
+        .filter((id) => PUBSUB_SUBSCRIPTION_ID_REGEX.test(id))
+        .map(shortSubscriptionId);
+    if (subscriptionIds.length === 0) {
+        throw new Error(`Cannot wait for processing of backfill on event topic '${this.eventTopic}': no temporary Pub/Sub subscription was created. Only backfills with temporary triggers are supported.`);
+    }
+    this._context.logger.info(`⏳ Waiting for processing of ${subscriptionIds.length} temporary Pub/Sub subscription(s) for event topic '${this.eventTopic}'.`);
+    await Promise.all(subscriptionIds.map((id) => waitForSubscription(this._context, id)));
+    this._context.logger.info(`✅ All temporary Pub/Sub subscriptions for event topic '${this.eventTopic}' have been drained.`);
+}

package/dist/functions/event-topic/broker-wait-for-processing-pubsub.d.ts

@@ -0,0 +1,16 @@
+import { EventTopicBrokerWaitForProcessing } from '@causa/workspace-core';
+/**
+ * Implements {@link EventTopicBrokerWaitForProcessing} for Pub/Sub temporary subscriptions.
+ *
+ * Only backfills that created temporary push subscriptions are supported: at least one entry of
+ * {@link BackfillTemporaryData.temporaryTriggerResourceIds} must match a subscription ID. If none does, the function
+ * throws — there is no observable signal for backfills that publish into existing topics with existing subscriptions.
+ *
+ * Completion is decided per-subscription from Cloud Monitoring time series (`subscription/ack_message_count`,
+ * `subscription/num_undelivered_messages`, `subscription/oldest_unacked_message_age`). See the call file for the exact
+ * decision logic.
+ */
+export declare class EventTopicBrokerWaitForProcessingForPubSub extends EventTopicBrokerWaitForProcessing {
+    _call(): Promise<void>;
+    _supports(): boolean;
+}

package/dist/functions/event-topic/broker-wait-for-processing-pubsub.js

@@ -0,0 +1,23 @@
+import { callDeferred } from '@causa/workspace';
+import { EventTopicBrokerWaitForProcessing, } from '@causa/workspace-core';
+/**
+ * Implements {@link EventTopicBrokerWaitForProcessing} for Pub/Sub temporary subscriptions.
+ *
+ * Only backfills that created temporary push subscriptions are supported: at least one entry of
+ * {@link BackfillTemporaryData.temporaryTriggerResourceIds} must match a subscription ID. If none does, the function
+ * throws — there is no observable signal for backfills that publish into existing topics with existing subscriptions.
+ *
+ * Completion is decided per-subscription from Cloud Monitoring time series (`subscription/ack_message_count`,
+ * `subscription/num_undelivered_messages`, `subscription/oldest_unacked_message_age`). See the call file for the exact
+ * decision logic.
+ */
+export class EventTopicBrokerWaitForProcessingForPubSub extends EventTopicBrokerWaitForProcessing {
+    async _call() {
+        return await callDeferred(this, import.meta.url);
+    }
+    _supports() {
+        return (this._context
+            .asConfiguration()
+            .get('events.broker') === 'google.pubSub');
+    }
+}