@causa/runtime-google 0.33.1 → 0.34.0

package/README.md

@@ -102,12 +102,24 @@ For testing, the `createDatabase` utility creates a temporary database, copying
 
 ### GCP-based Causa transaction runners
 
-This package provides two `TransactionRunner`s: the `SpannerPubSubTransactionRunner` and the `FirestorePubSubTransactionRunner`. Both use Pub/Sub and a `BufferEventTransaction` to publish events. They only differ by the service used to store the state.
+This package provides the following `TransactionRunner`s:
 
-The `SpannerPubSubTransactionRunner` uses a Spanner transaction as the underlying transaction for the `SpannerPubSubTransaction`, while the `FirestorePubSubTransactionRunner` uses a Firestore transaction for the `FirestorePubSubTransaction`. Both state transactions implement the `FindReplaceStateTransaction` interface, and therefore the runners can be used with the `VersionedEntityManager`.
+- `SpannerPubSubTransactionRunner`
+- `FirestorePubSubTransactionRunner`
+- `SpannerOutboxTransactionRunner`
+
+The first two use Pub/Sub and a `BufferEventTransaction` to publish events. They only differ by the service used to store the state.
+
+The `SpannerPubSubTransactionRunner` uses a Spanner transaction as the underlying transaction for the `SpannerTransaction`, while the `FirestorePubSubTransactionRunner` uses a Firestore transaction for the `FirestorePubSubTransaction`. Both state transactions implement the `FindReplaceStateTransaction` interface, and therefore the runners can be used with the `VersionedEntityManager`.
 
 One feature sets the `FirestorePubSubTransactionRunner` and its `FirestoreStateTransaction` apart: the handling of deleted entities using a separate, "soft-deleted document collection". Entities with a non-null `deletedAt` property are moved to a collection suffixed with `$deleted`, and an `_expirationDate` field is added to them. A TTL is expected to be set on this field. The `@SoftDeletedFirestoreCollection` decorator must be added to document classes that are meant to be handled using the `FirestorePubSubTransactionRunner`.
 
+> [!CAUTION]
+>
+> `SpannerPubSubTransactionRunner` and `FirestorePubSubTransactionRunner` do not provide atomic guarantees between the state and the events being committed. This could result in events being lost, as they are published once the state transaction successfully committed. Prefer the `SpannerOutboxTransactionRunner` when applicable.
+
+`SpannerOutboxTransactionRunner` implements the outbox pattern (from the base runtime's `OutboxTransactionRunner`), and uses the default injected `EventPublisher` (which can be the `PubSubPublisher`, if the corresponding module is imported). It requires an outbox table to be created in each database using the runner. See the documentation of the `SpannerOutboxEvent` for more information.
+
 ### Validation
 
 The `@IsValidFirestoreId` validation decorator checks that a property is a string which is not `.` or `..`, and does not contain forward slashes. This ensures the property's value can be used as a Firestore document ID.

package/dist/pubsub/publisher.d.ts

@@ -1,4 +1,4 @@
-import { type EventPublisher, type ObjectSerializer, type PublishOptions } from '@causa/runtime';
+import { type EventPublisher, type ObjectSerializer, type PreparedEvent, type PublishOptions } from '@causa/runtime';
 import { PubSub, type PublishOptions as TopicPublishOptions } from '@google-cloud/pubsub';
 import type { OnApplicationShutdown } from '@nestjs/common';
 import type { Logger } from 'pino';
@@ -88,7 +88,8 @@ export declare class PubSubPublisher implements EventPublisher, OnApplicationShu
      * @returns The Pub/Sub {@link Topic} to which messages can be published.
      */
     private getTopic;
-    publish(topic: string, event: object, options?: PublishOptions): Promise<void>;
+    prepare(topic: string, event: object, options?: PublishOptions): Promise<PreparedEvent>;
+    publish(topicOrPreparedEvent: string | PreparedEvent, event?: object, options?: PublishOptions): Promise<void>;
     flush(): Promise<void>;
     onApplicationShutdown(): Promise<void>;
 }

package/dist/pubsub/publisher.js

@@ -85,17 +85,11 @@ export class PubSubPublisher {
         this.topicCache[topicName] = topic;
         return topic;
     }
-    async publish(topic, event, options = {}) {
+    async prepare(topic, event, options = {}) {
         const data = await this.serializer.serialize(event);
-        const pubSubTopic = this.getTopic(topic);
         const defaultAttributes = {};
-        const baseLogData = {
-            topic,
-            pubSubTopic: pubSubTopic.name,
-        };
         if ('id' in event && typeof event.id === 'string') {
             defaultAttributes.eventId = event.id;
-            baseLogData.eventId = event.id;
         }
         if ('producedAt' in event && event.producedAt instanceof Date) {
             defaultAttributes.producedAt = event.producedAt.toISOString();
@@ -105,14 +99,29 @@ export class PubSubPublisher {
         }
         const attributes = {
             ...defaultAttributes,
-            ...options.attributes,
+            ...options?.attributes,
+        };
+        const key = options?.key;
+        return { topic, data, attributes, key };
+    }
+    async publish(topicOrPreparedEvent, event, options = {}) {
+        const isPrepared = typeof topicOrPreparedEvent !== 'string';
+        const { topic, data, attributes, key } = isPrepared
+            ? topicOrPreparedEvent
+            : await this.prepare(topicOrPreparedEvent, event, options);
+        const pubSubTopic = this.getTopic(topic);
+        const baseLogData = {
+            topic,
+            pubSubTopic: pubSubTopic.name,
         };
-        const orderingKey = options.key;
+        if (attributes && 'eventId' in attributes) {
+            baseLogData.eventId = attributes.eventId;
+        }
         try {
             const pubSubMessageId = await pubSubTopic.publishMessage({
                 data,
                 attributes,
-                orderingKey,
+                orderingKey: key,
             });
             this.logger.info({ ...baseLogData, pubSubMessageId }, 'Published message to Pub/Sub.');
         }
@@ -121,6 +130,7 @@ export class PubSubPublisher {
                 ...baseLogData,
                 pubSubMessage: data.toString('base64'),
                 pubSubAttributes: attributes,
+                pubSubOrderingKey: key,
                 errorMessage: error.message,
                 errorStack: error.stack,
             }, 'Failed to publish message to Pub/Sub.');

package/dist/spanner/entity-manager.d.ts

@@ -8,6 +8,10 @@ import type { RecursivePartialEntity } from './types.js';
  * Any Spanner transaction that can be used for reading.
  */
 export type SpannerReadOnlyTransaction = Snapshot | Transaction;
+/**
+ * A Spanner transaction that can be used for reading and writing.
+ */
+export type SpannerReadWriteTransaction = Transaction;
 /**
  * A key for a Spanner row.
  */
@@ -17,16 +21,16 @@ export type SpannerKey = (string | null)[];
  */
 type WriteOperationOptions = {
     /**
-     * The {@link Transaction} to use.
+     * The {@link SpannerReadWriteTransaction} to use.
      */
-    transaction?: Transaction;
+    transaction?: SpannerReadWriteTransaction;
 };
 /**
  * Base options for all read operations.
  */
 type ReadOperationOptions = {
     /**
-     * The {@link Transaction} or {@link Snapshot} to use.
+     * The {@link SpannerReadOnlyTransaction} to use.
      */
     transaction?: SpannerReadOnlyTransaction;
 };
@@ -42,7 +46,7 @@ type SnapshotOptions = {
 /**
  * A function that can be passed to the {@link SpannerEntityManager.snapshot} method.
  */
-export type SnapshotFunction<T> = (snapshot: Snapshot) => Promise<T>;
+export type SnapshotFunction<T> = (snapshot: SpannerReadOnlyTransaction) => Promise<T>;
 /**
  * A SQL statement run using {@link SpannerEntityManager.query}.
  */
@@ -196,16 +200,16 @@ export declare class SpannerEntityManager {
      */
     findOneByKeyOrFail<T>(entityType: Type<T>, key: SpannerKey | SpannerKey[number], options?: FindOptions): Promise<T>;
     /**
-     * Runs the provided function in a (read write) {@link Transaction}.
+     * Runs the provided function in a (read write) {@link SpannerReadWriteTransaction}.
      * The function itself should not commit or rollback the transaction.
      * If the function throws an error, the transaction will be rolled back.
      *
      * @param runFn The function to run in the transaction.
      * @returns The return value of the function.
      */
-    transaction<T>(runFn: (transaction: Transaction) => Promise<T>): Promise<T>;
+    transaction<T>(runFn: (transaction: SpannerReadWriteTransaction) => Promise<T>): Promise<T>;
     /**
-     * Runs the provided function in a read-only transaction ({@link Snapshot}).
+     * Runs the provided function in a {@link SpannerReadOnlyTransaction}.
      * The snapshot will be automatically released when the function returns.
      *
      * @param runFn The function to run in the transaction.
@@ -213,7 +217,7 @@ export declare class SpannerEntityManager {
      */
     snapshot<T>(runFn: SnapshotFunction<T>): Promise<T>;
     /**
-     * Runs the provided function in a read-only transaction ({@link Snapshot}).
+     * Runs the provided function in a {@link SpannerReadOnlyTransaction}.
      * The snapshot will be automatically released when the function returns.
      *
      * @param options The options to use when creating the snapshot.
@@ -230,8 +234,8 @@ export declare class SpannerEntityManager {
     clear(entityType: Type, options?: WriteOperationOptions): Promise<void>;
     /**
      * Runs the given SQL statement in the database.
-     * By default, the statement is run in a read-only transaction ({@link Snapshot}). To perform a write operation, pass
-     * a {@link Transaction} in the options.
+     * By default, the statement is run in a {@link SpannerReadOnlyTransaction}. To perform a write operation, pass a
+     * {@link SpannerReadWriteTransaction} in the options.
      *
      * @param options Options for the operation.
      * @param statement The SQL statement to run.
@@ -241,7 +245,7 @@ export declare class SpannerEntityManager {
     query<T>(options: QueryOptions<T>, statement: SqlStatement): Promise<T[]>;
     /**
      * Runs the given SQL statement in the database.
-     * The statement is run in a read-only transaction ({@link Snapshot}).
+     * The statement is run in a {@link SpannerReadOnlyTransaction}.
      *
      * @param statement The SQL statement to run.
      * @returns The rows returned by the query.
@@ -331,22 +335,22 @@ export declare class SpannerEntityManager {
         validateFn?: (entity: T) => void;
     }): Promise<T>;
     /**
-     * Runs the given "read-write" function on a transaction. If a transaction is not passed, a new {@link Transaction} is
-     * created instead.
+     * Runs the given "read-write" function on a transaction. If a transaction is not passed, a new
+     * {@link SpannerReadWriteTransaction} is created instead.
      *
      * @param transaction The transaction to use. If `undefined`, a new transaction is created.
      * @param fn The function to run on the transaction.
      * @returns The result of the function.
      */
-    runInExistingOrNewTransaction<T>(transaction: Transaction | undefined, fn: (transaction: Transaction) => Promise<T>): Promise<T>;
+    runInExistingOrNewTransaction<T>(transaction: SpannerReadWriteTransaction | undefined, fn: (transaction: SpannerReadWriteTransaction) => Promise<T>): Promise<T>;
     /**
-     * Runs the given "read-only" function on a transaction. If a transaction is not passed, a new {@link Snapshot} is
-     * created instead.
+     * Runs the given "read-only" function on a transaction. If a transaction is not passed, a new
+     * {@link SpannerReadOnlyTransaction} is created instead.
      *
-     * @param transaction The transaction to use. If `undefined`, a new {@link Snapshot} is created.
+     * @param transaction The transaction to use. If `undefined`, a new {@link SpannerReadOnlyTransaction} is created.
      * @param fn The function to run on the transaction.
      * @returns The result of the function.
      */
-    runInExistingOrNewReadOnlyTransaction<T>(transaction: SpannerReadOnlyTransaction | undefined, fn: (transaction: SpannerReadOnlyTransaction) => Promise<T>): Promise<T>;
+    runInExistingOrNewReadOnlyTransaction<T>(transaction: SpannerReadOnlyTransaction | undefined, fn: SnapshotFunction<T>): Promise<T>;
 }
 export {};

package/dist/spanner/entity-manager.js

@@ -202,7 +202,7 @@ let SpannerEntityManager = class SpannerEntityManager {
         return entity;
     }
     /**
-     * Runs the provided function in a (read write) {@link Transaction}.
+     * Runs the provided function in a (read write) {@link SpannerReadWriteTransaction}.
      * The function itself should not commit or rollback the transaction.
      * If the function throws an error, the transaction will be rolled back.
      *
@@ -440,8 +440,8 @@ let SpannerEntityManager = class SpannerEntityManager {
         });
     }
     /**
-     * Runs the given "read-write" function on a transaction. If a transaction is not passed, a new {@link Transaction} is
-     * created instead.
+     * Runs the given "read-write" function on a transaction. If a transaction is not passed, a new
+     * {@link SpannerReadWriteTransaction} is created instead.
      *
      * @param transaction The transaction to use. If `undefined`, a new transaction is created.
      * @param fn The function to run on the transaction.
@@ -459,10 +459,10 @@ let SpannerEntityManager = class SpannerEntityManager {
         return this.transaction(fn);
     }
     /**
-     * Runs the given "read-only" function on a transaction. If a transaction is not passed, a new {@link Snapshot} is
-     * created instead.
+     * Runs the given "read-only" function on a transaction. If a transaction is not passed, a new
+     * {@link SpannerReadOnlyTransaction} is created instead.
      *
-     * @param transaction The transaction to use. If `undefined`, a new {@link Snapshot} is created.
+     * @param transaction The transaction to use. If `undefined`, a new {@link SpannerReadOnlyTransaction} is created.
      * @param fn The function to run on the transaction.
      * @returns The result of the function.
      */

package/dist/spanner/index.d.ts

@@ -1,7 +1,7 @@
 export { SpannerColumn } from './column.decorator.js';
 export { SPANNER_SESSION_POOL_OPTIONS_FOR_CLOUD_FUNCTIONS, SPANNER_SESSION_POOL_OPTIONS_FOR_SERVICE, catchSpannerDatabaseErrors, getDefaultSpannerDatabaseForCloudFunction, } from './database.js';
 export { SpannerEntityManager } from './entity-manager.js';
-export type { SpannerKey, SpannerReadOnlyTransaction, } from './entity-manager.js';
+export type { SpannerKey, SpannerReadOnlyTransaction, SpannerReadWriteTransaction, } from './entity-manager.js';
 export * from './errors.js';
 export { SpannerHealthIndicator } from './healthcheck.js';
 export { SpannerModule } from './module.js';

package/dist/transaction/index.d.ts

@@ -1,2 +1,5 @@
 export * from './firestore-pubsub/index.js';
+export * from './spanner-outbox/index.js';
 export * from './spanner-pubsub/index.js';
+export { SpannerStateTransaction } from './spanner-state-transaction.js';
+export { SpannerTransaction } from './spanner-transaction.js';

package/dist/transaction/index.js

@@ -1,2 +1,5 @@
 export * from './firestore-pubsub/index.js';
+export * from './spanner-outbox/index.js';
 export * from './spanner-pubsub/index.js';
+export { SpannerStateTransaction } from './spanner-state-transaction.js';
+export { SpannerTransaction } from './spanner-transaction.js';

package/dist/transaction/spanner-outbox/event.d.ts

@@ -0,0 +1,27 @@
+import type { EventAttributes, OutboxEvent } from '@causa/runtime';
+/**
+ * A Spanner table that implements the {@link OutboxEvent} interface, such that it can be used to store outbox event.
+ *
+ * The full DDL for the table to be used by the outbox transaction runner is:
+ *
+ * ```sql
+ * CREATE TABLE OutboxEvent (
+ *   id STRING(36) NOT NULL,
+ *   topic STRING(MAX) NOT NULL,
+ *   data BYTES(MAX) NOT NULL,
+ *   attributes JSON NOT NULL,
+ *   leaseExpiration TIMESTAMP,
+ *   -- 20 is the number of shards.
+ *   shard INT64 NOT NULL AS (MOD(ABS(FARM_FINGERPRINT(id)), 20)),
+ * ) PRIMARY KEY (id);
+ * CREATE INDEX OutboxEventsByShardAndLeaseExpiration ON OutboxEvent(shard, leaseExpiration)
+ * ```
+ */
+export declare class SpannerOutboxEvent implements OutboxEvent {
+    constructor(init: SpannerOutboxEvent);
+    readonly id: string;
+    readonly topic: string;
+    readonly data: Buffer;
+    readonly attributes: EventAttributes;
+    readonly leaseExpiration: Date | null;
+}

package/dist/transaction/spanner-outbox/event.js

@@ -0,0 +1,63 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { SpannerColumn, SpannerTable } from '../../spanner/index.js';
+/**
+ * A Spanner table that implements the {@link OutboxEvent} interface, such that it can be used to store outbox event.
+ *
+ * The full DDL for the table to be used by the outbox transaction runner is:
+ *
+ * ```sql
+ * CREATE TABLE OutboxEvent (
+ *   id STRING(36) NOT NULL,
+ *   topic STRING(MAX) NOT NULL,
+ *   data BYTES(MAX) NOT NULL,
+ *   attributes JSON NOT NULL,
+ *   leaseExpiration TIMESTAMP,
+ *   -- 20 is the number of shards.
+ *   shard INT64 NOT NULL AS (MOD(ABS(FARM_FINGERPRINT(id)), 20)),
+ * ) PRIMARY KEY (id);
+ * CREATE INDEX OutboxEventsByShardAndLeaseExpiration ON OutboxEvent(shard, leaseExpiration)
+ * ```
+ */
+let SpannerOutboxEvent = class SpannerOutboxEvent {
+    constructor(init) {
+        Object.assign(this, init);
+    }
+    id;
+    topic;
+    data;
+    attributes;
+    leaseExpiration;
+};
+__decorate([
+    SpannerColumn(),
+    __metadata("design:type", String)
+], SpannerOutboxEvent.prototype, "id", void 0);
+__decorate([
+    SpannerColumn(),
+    __metadata("design:type", String)
+], SpannerOutboxEvent.prototype, "topic", void 0);
+__decorate([
+    SpannerColumn(),
+    __metadata("design:type", Buffer)
+], SpannerOutboxEvent.prototype, "data", void 0);
+__decorate([
+    SpannerColumn({ isJson: true }),
+    __metadata("design:type", Object)
+], SpannerOutboxEvent.prototype, "attributes", void 0);
+__decorate([
+    SpannerColumn(),
+    __metadata("design:type", Object)
+], SpannerOutboxEvent.prototype, "leaseExpiration", void 0);
+SpannerOutboxEvent = __decorate([
+    SpannerTable({ name: 'OutboxEvent', primaryKey: ['id'] }),
+    __metadata("design:paramtypes", [SpannerOutboxEvent])
+], SpannerOutboxEvent);
+export { SpannerOutboxEvent };

package/dist/transaction/spanner-outbox/index.d.ts

@@ -0,0 +1,5 @@
+export { SpannerOutboxEvent } from './event.js';
+export { SpannerOutboxTransactionModule } from './module.js';
+export { SpannerOutboxTransactionRunner } from './runner.js';
+export type { SpannerOutboxTransaction } from './runner.js';
+export { SpannerOutboxSender } from './sender.js';

package/dist/transaction/spanner-outbox/index.js

@@ -0,0 +1,4 @@
+export { SpannerOutboxEvent } from './event.js';
+export { SpannerOutboxTransactionModule } from './module.js';
+export { SpannerOutboxTransactionRunner } from './runner.js';
+export { SpannerOutboxSender } from './sender.js';

package/dist/transaction/spanner-outbox/module.d.ts

@@ -0,0 +1,28 @@
+import type { OutboxEvent } from '@causa/runtime';
+import type { DynamicModule, Type } from '@nestjs/common';
+import { type SpannerOutboxSenderOptions } from './sender.js';
+/**
+ * Options for the {@link SpannerOutboxTransactionModule}.
+ */
+export type SpannerOutboxTransactionModuleOptions = SpannerOutboxSenderOptions & {
+    /**
+     * The type of {@link OutboxEvent} used by the {@link SpannerOutboxTransactionRunner}.
+     * This should be a valid class decorated with `@SpannerTable`.
+     * Defaults to {@link SpannerOutboxEvent}.
+     */
+    outboxEventType?: Type<OutboxEvent>;
+};
+/**
+ * The module providing the {@link SpannerOutboxTransactionRunner}.
+ * This assumes the `SpannerModule` and an {@link EventPublisher} are available (as well as the `LoggerModule`).
+ */
+export declare class SpannerOutboxTransactionModule {
+    /**
+     * Initializes the {@link SpannerOutboxTransactionModule} with the given options.
+     * The returned module is always global.
+     *
+     * @param options Options for the {@link SpannerOutboxTransactionModule}.
+     * @returns The module.
+     */
+    static forRoot(options?: SpannerOutboxTransactionModuleOptions): DynamicModule;
+}

package/dist/transaction/spanner-outbox/module.js

@@ -0,0 +1,91 @@
+import { EVENT_PUBLISHER_INJECTION_NAME, Logger } from '@causa/runtime/nestjs';
+import { ConfigService } from '@nestjs/config';
+import { SpannerEntityManager } from '../../spanner/index.js';
+import { SpannerOutboxEvent } from './event.js';
+import { SpannerOutboxTransactionRunner } from './runner.js';
+import { SpannerOutboxSender, } from './sender.js';
+/**
+ * Combines options passed to the module with the configuration (from the environment).
+ *
+ * @param options Options passed to the module.
+ * @param config The {@link ConfigService} to use.
+ * @returns The parsed {@link SpannerOutboxSenderOptions}.
+ */
+function parseSenderOptions(options, config) {
+    function validateIntOrUndefined(name) {
+        const strValue = config.get(name);
+        if (strValue === undefined) {
+            return undefined;
+        }
+        const value = parseInt(strValue);
+        if (isNaN(value)) {
+            throw new Error(`Environment variable ${name} must be a number.`);
+        }
+        return value;
+    }
+    const batchSize = validateIntOrUndefined('SPANNER_OUTBOX_BATCH_SIZE');
+    const pollingInterval = validateIntOrUndefined('SPANNER_OUTBOX_POLLING_INTERVAL');
+    const idColumn = config.get('SPANNER_OUTBOX_ID_COLUMN');
+    const leaseExpirationColumn = config.get('SPANNER_OUTBOX_LEASE_EXPIRATION_COLUMN');
+    const index = config.get('SPANNER_OUTBOX_INDEX');
+    const shardingColumn = config.get('SPANNER_OUTBOX_SHARDING_COLUMN');
+    const shardingCount = validateIntOrUndefined('SPANNER_OUTBOX_SHARDING_COUNT');
+    const leaseDuration = validateIntOrUndefined('SPANNER_OUTBOX_LEASE_DURATION');
+    const sharding = shardingColumn && shardingCount
+        ? { column: shardingColumn, count: shardingCount }
+        : undefined;
+    const envOptions = {
+        batchSize,
+        pollingInterval,
+        idColumn,
+        leaseExpirationColumn,
+        index,
+        sharding,
+        leaseDuration,
+    };
+    return { ...envOptions, ...options };
+}
+/**
+ * The module providing the {@link SpannerOutboxTransactionRunner}.
+ * This assumes the `SpannerModule` and an {@link EventPublisher} are available (as well as the `LoggerModule`).
+ */
+export class SpannerOutboxTransactionModule {
+    /**
+     * Initializes the {@link SpannerOutboxTransactionModule} with the given options.
+     * The returned module is always global.
+     *
+     * @param options Options for the {@link SpannerOutboxTransactionModule}.
+     * @returns The module.
+     */
+    static forRoot(options = {}) {
+        const { outboxEventType, ...senderOptions } = {
+            outboxEventType: SpannerOutboxEvent,
+            ...options,
+        };
+        return {
+            module: SpannerOutboxTransactionModule,
+            global: true,
+            providers: [
+                {
+                    provide: SpannerOutboxSender,
+                    useFactory: (entityManager, publisher, logger, config) => {
+                        const options = parseSenderOptions(senderOptions, config);
+                        return new SpannerOutboxSender(entityManager, outboxEventType, publisher, logger, options);
+                    },
+                    inject: [
+                        SpannerEntityManager,
+                        EVENT_PUBLISHER_INJECTION_NAME,
+                        Logger,
+                        ConfigService,
+                    ],
+                },
+                {
+                    provide: SpannerOutboxTransactionRunner,
+                    useFactory: (entityManager, sender, logger) => new SpannerOutboxTransactionRunner(entityManager, outboxEventType, sender, logger),
+                    inject: [SpannerEntityManager, SpannerOutboxSender, Logger],
+                },
+            ],
+            exports: [SpannerOutboxTransactionRunner],
+        };
+    }
+}

package/dist/transaction/spanner-outbox/runner.d.ts

@@ -0,0 +1,19 @@
+import { OutboxTransactionRunner, type OutboxEvent, type OutboxEventTransaction } from '@causa/runtime';
+import { Logger } from '@causa/runtime/nestjs';
+import type { Type } from '@nestjs/common';
+import { SpannerEntityManager } from '../../spanner/index.js';
+import { SpannerTransaction } from '../spanner-transaction.js';
+import { SpannerOutboxSender } from './sender.js';
+/**
+ * A {@link SpannerTransaction} that uses an {@link OutboxEventTransaction}.
+ */
+export type SpannerOutboxTransaction = SpannerTransaction<OutboxEventTransaction>;
+/**
+ * An {@link OutboxTransactionRunner} that uses a {@link SpannerTransaction} to run transactions.
+ * Events are stored in a Spanner table before being published.
+ */
+export declare class SpannerOutboxTransactionRunner extends OutboxTransactionRunner<SpannerOutboxTransaction> {
+    readonly entityManager: SpannerEntityManager;
+    constructor(entityManager: SpannerEntityManager, outboxEventType: Type<OutboxEvent>, sender: SpannerOutboxSender, logger: Logger);
+    protected runStateTransaction<RT>(eventTransaction: OutboxEventTransaction, runFn: (transaction: SpannerOutboxTransaction) => Promise<RT>): Promise<RT>;
+}

package/dist/transaction/spanner-outbox/runner.js

@@ -0,0 +1,31 @@
+import { OutboxTransactionRunner, } from '@causa/runtime';
+import { Logger } from '@causa/runtime/nestjs';
+import { SpannerEntityManager } from '../../spanner/index.js';
+import { SpannerStateTransaction } from '../spanner-state-transaction.js';
+import { SpannerTransaction } from '../spanner-transaction.js';
+import { throwRetryableInTransactionIfNeeded } from '../spanner-utils.js';
+import { SpannerOutboxSender } from './sender.js';
+/**
+ * An {@link OutboxTransactionRunner} that uses a {@link SpannerTransaction} to run transactions.
+ * Events are stored in a Spanner table before being published.
+ */
+export class SpannerOutboxTransactionRunner extends OutboxTransactionRunner {
+    entityManager;
+    constructor(entityManager, outboxEventType, sender, logger) {
+        super(outboxEventType, sender, logger);
+        this.entityManager = entityManager;
+    }
+    async runStateTransaction(eventTransaction, runFn) {
+        return await this.entityManager.transaction(async (dbTransaction) => {
+            const stateTransaction = new SpannerStateTransaction(this.entityManager, dbTransaction);
+            const transaction = new SpannerTransaction(stateTransaction, eventTransaction);
+            try {
+                return await runFn(transaction);
+            }
+            catch (error) {
+                await throwRetryableInTransactionIfNeeded(error);
+                throw error;
+            }
+        });
+    }
+}

package/dist/transaction/spanner-outbox/sender.d.ts

@@ -0,0 +1,95 @@
+import { OutboxEventSender, type EventPublisher, type OutboxEvent, type OutboxEventPublishResult, type OutboxEventSenderOptions } from '@causa/runtime';
+import { Logger } from '@causa/runtime/nestjs';
+import type { Type } from '@nestjs/common';
+import { SpannerEntityManager } from '../../spanner/index.js';
+/**
+ * Sharding options for the {@link SpannerOutboxSender}.
+ */
+export type SpannerOutboxSenderShardingOptions = {
+    /**
+     * The name of the column used for sharding.
+     */
+    readonly column: string;
+    /**
+     * The number of shards.
+     */
+    readonly count: number;
+};
+/**
+ * Options for the {@link SpannerOutboxSender}.
+ */
+export type SpannerOutboxSenderOptions = OutboxEventSenderOptions & {
+    /**
+     * Sharding options.
+     * If not set, queries to fetch events will not use sharding.
+     */
+    readonly sharding?: SpannerOutboxSenderShardingOptions;
+    /**
+     * The name of the column used to store the event ID.
+     * Defaults to `id`.
+     */
+    readonly idColumn?: string;
+    /**
+     * The name of the column used to store the lease expiration.
+     * Defaults to `leaseExpiration`.
+     */
+    readonly leaseExpirationColumn?: string;
+    /**
+     * The index used to fetch events.
+     */
+    readonly index?: string;
+};
+/**
+ * An {@link OutboxEventSender} that uses a Spanner table to store events.
+ */
+export declare class SpannerOutboxSender extends OutboxEventSender {
+    readonly entityManager: SpannerEntityManager;
+    readonly outboxEventType: Type<OutboxEvent>;
+    /**
+     * Sharding options.
+     * If `null`, queries to fetch events will not use sharding.
+     */
+    readonly sharding: SpannerOutboxSenderShardingOptions | undefined;
+    /**
+     * The name of the column used for the {@link OutboxEvent.id} property.
+     */
+    readonly idColumn: string;
+    /**
+     * The name of the column used for the {@link OutboxEvent.leaseExpiration} property.
+     */
+    readonly leaseExpirationColumn: string;
+    /**
+     * The index used to fetch events.
+     */
+    readonly index: string | undefined;
+    /**
+     * The SQL query used to fetch events from the outbox.
+     */
+    readonly fetchEventsSql: string;
+    /**
+     * The SQL query used to update events in the outbox after they have been successfully published.
+     */
+    readonly successfulUpdateSql: string;
+    /**
+     * The SQL query used to update events in the outbox after they have failed to be published.
+     */
+    readonly failedUpdateSql: string;
+    /**
+     * Creates a new {@link SpannerOutboxSender}.
+     *
+     * @param entityManager The {@link SpannerEntityManager} to use to access the outbox.
+     * @param outboxEventType The type for the Spanner table used to store outbox events.
+     * @param publisher The {@link EventPublisher} to use to publish events.
+     * @param logger The {@link Logger} to use.
+     * @param options Options for the {@link SpannerOutboxSender}.
+     */
+    constructor(entityManager: SpannerEntityManager, outboxEventType: Type<OutboxEvent>, publisher: EventPublisher, logger: Logger, options?: SpannerOutboxSenderOptions);
+    /**
+     * Builds the SQL queries used to fetch and update events in the outbox based on the options.
+     *
+     * @returns The SQL queries used to fetch and update events in the outbox.
+     */
+    protected buildSql(): Pick<SpannerOutboxSender, 'fetchEventsSql' | 'successfulUpdateSql' | 'failedUpdateSql'>;
+    protected fetchEvents(): Promise<OutboxEvent[]>;
+    protected updateOutbox(result: OutboxEventPublishResult): Promise<void>;
+}

package/dist/transaction/spanner-outbox/sender.js

@@ -0,0 +1,150 @@
+import { OutboxEventSender, } from '@causa/runtime';
+import { Logger } from '@causa/runtime/nestjs';
+import { SpannerEntityManager } from '../../spanner/index.js';
+/**
+ * The default name for the {@link OutboxEvent.id} column.
+ */
+const DEFAULT_ID_COLUMN = 'id';
+/**
+ * The default name for the {@link OutboxEvent.leaseExpiration} column.
+ */
+const DEFAULT_LEASE_EXPIRATION_COLUMN = 'leaseExpiration';
+/**
+ * An {@link OutboxEventSender} that uses a Spanner table to store events.
+ */
+export class SpannerOutboxSender extends OutboxEventSender {
+    entityManager;
+    outboxEventType;
+    /**
+     * Sharding options.
+     * If `null`, queries to fetch events will not use sharding.
+     */
+    sharding;
+    /**
+     * The name of the column used for the {@link OutboxEvent.id} property.
+     */
+    idColumn;
+    /**
+     * The name of the column used for the {@link OutboxEvent.leaseExpiration} property.
+     */
+    leaseExpirationColumn;
+    /**
+     * The index used to fetch events.
+     */
+    index;
+    /**
+     * The SQL query used to fetch events from the outbox.
+     */
+    fetchEventsSql;
+    /**
+     * The SQL query used to update events in the outbox after they have been successfully published.
+     */
+    successfulUpdateSql;
+    /**
+     * The SQL query used to update events in the outbox after they have failed to be published.
+     */
+    failedUpdateSql;
+    /**
+     * Creates a new {@link SpannerOutboxSender}.
+     *
+     * @param entityManager The {@link SpannerEntityManager} to use to access the outbox.
+     * @param outboxEventType The type for the Spanner table used to store outbox events.
+     * @param publisher The {@link EventPublisher} to use to publish events.
+     * @param logger The {@link Logger} to use.
+     * @param options Options for the {@link SpannerOutboxSender}.
+     */
+    constructor(entityManager, outboxEventType, publisher, logger, options = {}) {
+        super(publisher, logger, options);
+        this.entityManager = entityManager;
+        this.outboxEventType = outboxEventType;
+        this.sharding = options.sharding;
+        this.idColumn = options.idColumn ?? DEFAULT_ID_COLUMN;
+        this.leaseExpirationColumn =
+            options.leaseExpirationColumn ?? DEFAULT_LEASE_EXPIRATION_COLUMN;
+        this.index = options.index;
+        ({
+            fetchEventsSql: this.fetchEventsSql,
+            successfulUpdateSql: this.successfulUpdateSql,
+            failedUpdateSql: this.failedUpdateSql,
+        } = this.buildSql());
+    }
+    /**
+     * Builds the SQL queries used to fetch and update events in the outbox based on the options.
+     *
+     * @returns The SQL queries used to fetch and update events in the outbox.
+     */
+    buildSql() {
+        const table = this.entityManager.sqlTableName(this.outboxEventType);
+        const tableWithIndex = this.entityManager.sqlTableName(this.outboxEventType, { index: this.index });
+        let filter = `${this.leaseExpirationColumn} IS NULL OR ${this.leaseExpirationColumn} < @currentTime`;
+        if (this.sharding) {
+            const { column, count } = this.sharding;
+            filter = `${column} BETWEEN 0 AND ${count - 1} AND (${filter})`;
+        }
+        const fetchEventsSql = `
+      UPDATE
+        ${table}
+      SET
+        \`${this.leaseExpirationColumn}\` = @leaseExpiration
+      WHERE
+        \`${this.idColumn}\` IN (
+          SELECT
+            \`${this.idColumn}\`
+          FROM
+            ${tableWithIndex}
+          WHERE
+            ${filter}
+          LIMIT
+            @batchSize
+        )
+      THEN RETURN
+        ${this.entityManager.sqlColumns(this.outboxEventType)}`;
+        const successfulUpdateSql = `
+      DELETE FROM
+        ${table}
+      WHERE
+        \`${this.idColumn}\` IN UNNEST(@ids)`;
+        const failedUpdateSql = `
+      UPDATE
+        ${table}
+      SET
+        \`${this.leaseExpirationColumn}\` = NULL
+      WHERE
+        \`${this.idColumn}\` IN UNNEST(@ids)`;
+        return { fetchEventsSql, successfulUpdateSql, failedUpdateSql };
+    }
+    async fetchEvents() {
+        return await this.entityManager.transaction(async (transaction) => {
+            const currentTime = new Date();
+            const leaseExpiration = new Date(currentTime.getTime() + this.leaseDuration);
+            const params = {
+                leaseExpiration,
+                currentTime,
+                batchSize: this.batchSize,
+            };
+            return await this.entityManager.query({ transaction, entityType: this.outboxEventType }, { sql: this.fetchEventsSql, params });
+        });
+    }
+    async updateOutbox(result) {
+        const successfulSends = [];
+        const failedSends = [];
+        Object.entries(result).forEach(([id, success]) => (success ? successfulSends : failedSends).push(id));
+        const batchUpdates = [];
+        if (successfulSends.length > 0) {
+            batchUpdates.push({
+                sql: this.successfulUpdateSql,
+                params: { ids: successfulSends },
+            });
+        }
+        if (failedSends.length > 0) {
+            batchUpdates.push({
+                sql: this.failedUpdateSql,
+                params: { ids: failedSends },
+            });
+        }
+        if (batchUpdates.length === 0) {
+            return;
+        }
+        await this.entityManager.transaction((transaction) => transaction.batchUpdate(batchUpdates));
+    }
+}

package/dist/transaction/spanner-pubsub/index.d.ts

@@ -1,4 +1,2 @@
 export { SpannerPubSubTransactionModule } from './module.js';
 export { SpannerPubSubTransactionRunner } from './runner.js';
-export { SpannerStateTransaction } from './state-transaction.js';
-export { SpannerPubSubTransaction } from './transaction.js';

package/dist/transaction/spanner-pubsub/index.js

@@ -1,4 +1,2 @@
 export { SpannerPubSubTransactionModule } from './module.js';
 export { SpannerPubSubTransactionRunner } from './runner.js';
-export { SpannerStateTransaction } from './state-transaction.js';
-export { SpannerPubSubTransaction } from './transaction.js';

package/dist/transaction/spanner-pubsub/runner.d.ts

@@ -2,12 +2,12 @@ import { TransactionRunner } from '@causa/runtime';
 import { Logger } from '@causa/runtime/nestjs';
 import { PubSubPublisher } from '../../pubsub/index.js';
 import { SpannerEntityManager } from '../../spanner/index.js';
-import { SpannerPubSubTransaction } from './transaction.js';
+import { SpannerTransaction } from '../spanner-transaction.js';
 /**
  * A {@link TransactionRunner} that uses Spanner for state and Pub/Sub for events.
  * A Spanner transaction is used as the main transaction. If it succeeds, events are published to Pub/Sub outside of it.
  */
-export declare class SpannerPubSubTransactionRunner extends TransactionRunner<SpannerPubSubTransaction> {
+export declare class SpannerPubSubTransactionRunner extends TransactionRunner<SpannerTransaction> {
     readonly entityManager: SpannerEntityManager;
     readonly publisher: PubSubPublisher;
     private readonly logger;
@@ -19,5 +19,5 @@ export declare class SpannerPubSubTransactionRunner extends TransactionRunner<Sp
      * @param logger The {@link Logger} to use.
      */
     constructor(entityManager: SpannerEntityManager, publisher: PubSubPublisher, logger: Logger);
-    run<T>(runFn: (transaction: SpannerPubSubTransaction) => Promise<T>): Promise<[T]>;
+    run<T>(runFn: (transaction: SpannerTransaction) => Promise<T>): Promise<[T]>;
 }

package/dist/transaction/spanner-pubsub/runner.js

@@ -7,18 +7,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { BufferEventTransaction, TransactionOldTimestampError, TransactionRunner, } from '@causa/runtime';
+import { BufferEventTransaction, TransactionRunner } from '@causa/runtime';
 import { Logger } from '@causa/runtime/nestjs';
 import { Injectable } from '@nestjs/common';
-import { setTimeout } from 'timers/promises';
 import { PubSubPublisher } from '../../pubsub/index.js';
-import { SpannerEntityManager, TemporarySpannerError, } from '../../spanner/index.js';
-import { SpannerStateTransaction } from './state-transaction.js';
-import { SpannerPubSubTransaction } from './transaction.js';
-/**
- * The delay, in milliseconds, over which a timestamp issue is deemed irrecoverable.
- */
-const ACCEPTABLE_PAST_DATE_DELAY = 25000;
+import { SpannerEntityManager } from '../../spanner/index.js';
+import { SpannerStateTransaction } from '../spanner-state-transaction.js';
+import { SpannerTransaction } from '../spanner-transaction.js';
+import { throwRetryableInTransactionIfNeeded } from '../spanner-utils.js';
 /**
  * A {@link TransactionRunner} that uses Spanner for state and Pub/Sub for events.
  * A Spanner transaction is used as the main transaction. If it succeeds, events are published to Pub/Sub outside of it.
@@ -46,28 +42,15 @@ let SpannerPubSubTransactionRunner = class SpannerPubSubTransactionRunner extend
             const stateTransaction = new SpannerStateTransaction(this.entityManager, dbTransaction);
             // This must be inside the Spanner transaction because staged messages should be cleared when the transaction is retried.
             const eventTransaction = new BufferEventTransaction(this.publisher);
-            const transaction = new SpannerPubSubTransaction(stateTransaction, eventTransaction);
+            const transaction = new SpannerTransaction(stateTransaction, eventTransaction);
             try {
                 const result = await runFn(transaction);
                 this.logger.info('Committing the Spanner transaction.');
                 return { result, eventTransaction };
             }
             catch (error) {
-                // `TransactionOldTimestampError`s indicate that the transaction is using a timestamp older than what is
-                // observed in the state (Spanner).
-                // Throwing a `SpannerTransactionOldTimestampError` will cause the transaction to be retried with a newer
-                // timestamp.
-                if (!(error instanceof TransactionOldTimestampError)) {
-                    throw error;
-                }
-                const delay = error.delay ?? Infinity;
-                if (delay >= ACCEPTABLE_PAST_DATE_DELAY) {
-                    throw error;
-                }
-                if (delay > 0) {
-                    await setTimeout(delay);
-                }
-                throw TemporarySpannerError.retryableInTransaction(error.message);
+                await throwRetryableInTransactionIfNeeded(error);
+                throw error;
             }
         });
         this.logger.info('Publishing Pub/Sub events.');

package/dist/transaction/{spanner-pubsub/state-transaction.d.ts → spanner-state-transaction.d.ts}

@@ -1,20 +1,19 @@
 import type { FindReplaceStateTransaction } from '@causa/runtime';
-import { Transaction as SpannerTransaction } from '@google-cloud/spanner';
 import type { Type } from '@nestjs/common';
-import { SpannerEntityManager } from '../../spanner/index.js';
+import { SpannerEntityManager, type SpannerReadWriteTransaction } from '../spanner/index.js';
 /**
  * A {@link FindReplaceStateTransaction} that uses Spanner for state storage.
  */
 export declare class SpannerStateTransaction implements FindReplaceStateTransaction {
     readonly entityManager: SpannerEntityManager;
-    readonly transaction: SpannerTransaction;
+    readonly transaction: SpannerReadWriteTransaction;
     /**
      * Creates a new {@link SpannerStateTransaction}.
      *
      * @param entityManager The {@link SpannerEntityManager} to use to access entities in the state.
-     * @param transaction The {@link SpannerTransaction} to use for the transaction.
+     * @param transaction The {@link SpannerReadWriteTransaction} to use for the transaction.
      */
-    constructor(entityManager: SpannerEntityManager, transaction: SpannerTransaction);
+    constructor(entityManager: SpannerEntityManager, transaction: SpannerReadWriteTransaction);
     replace<T extends object>(entity: T): Promise<void>;
     deleteWithSameKeyAs<T extends object>(type: Type<T>, key: Partial<T>): Promise<void>;
     findOneWithSameKeyAs<T extends object>(type: Type<T>, entity: Partial<T>): Promise<T | undefined>;

package/dist/transaction/{spanner-pubsub/state-transaction.js → spanner-state-transaction.js}

@@ -1,5 +1,4 @@
-import { Transaction as SpannerTransaction } from '@google-cloud/spanner';
-import { SpannerEntityManager } from '../../spanner/index.js';
+import { SpannerEntityManager, } from '../spanner/index.js';
 /**
  * A {@link FindReplaceStateTransaction} that uses Spanner for state storage.
  */
@@ -10,7 +9,7 @@ export class SpannerStateTransaction {
      * Creates a new {@link SpannerStateTransaction}.
      *
      * @param entityManager The {@link SpannerEntityManager} to use to access entities in the state.
-     * @param transaction The {@link SpannerTransaction} to use for the transaction.
+     * @param transaction The {@link SpannerReadWriteTransaction} to use for the transaction.
      */
     constructor(entityManager, transaction) {
         this.entityManager = entityManager;

package/dist/transaction/spanner-transaction.d.ts

@@ -0,0 +1,16 @@
+import { type EventTransaction, Transaction } from '@causa/runtime';
+import { SpannerEntityManager, type SpannerReadWriteTransaction } from '../spanner/index.js';
+import { SpannerStateTransaction } from './spanner-state-transaction.js';
+/**
+ * A {@link Transaction} that uses Spanner for state storage, and any available {@link EventTransaction} implementation.
+ */
+export declare class SpannerTransaction<ET extends EventTransaction = EventTransaction> extends Transaction<SpannerStateTransaction, ET> {
+    /**
+     * The underlying {@link SpannerTransaction} used by the state transaction.
+     */
+    get spannerTransaction(): SpannerReadWriteTransaction;
+    /**
+     * The underlying {@link SpannerEntityManager} used by the state transaction.
+     */
+    get entityManager(): SpannerEntityManager;
+}

package/dist/transaction/spanner-transaction.js

@@ -0,0 +1,20 @@
+import { Transaction } from '@causa/runtime';
+import { SpannerEntityManager, } from '../spanner/index.js';
+import { SpannerStateTransaction } from './spanner-state-transaction.js';
+/**
+ * A {@link Transaction} that uses Spanner for state storage, and any available {@link EventTransaction} implementation.
+ */
+export class SpannerTransaction extends Transaction {
+    /**
+     * The underlying {@link SpannerTransaction} used by the state transaction.
+     */
+    get spannerTransaction() {
+        return this.stateTransaction.transaction;
+    }
+    /**
+     * The underlying {@link SpannerEntityManager} used by the state transaction.
+     */
+    get entityManager() {
+        return this.stateTransaction.entityManager;
+    }
+}

package/dist/transaction/spanner-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if the given error is a `TransactionOldTimestampError` and throws a `TemporarySpannerError` such that the
+ * transaction can be retried by the runner.
+ * If the {@link TransactionOldTimestampError.delay} is too large, the error is deemed irrecoverable and nothing is
+ * thrown (it is up to the caller to handle the error).
+ *
+ * @param error The error to test.
+ */
+export declare function throwRetryableInTransactionIfNeeded(error: unknown): Promise<void>;

package/dist/transaction/spanner-utils.js

@@ -0,0 +1,31 @@
+import { TransactionOldTimestampError } from '@causa/runtime';
+import { setTimeout } from 'timers/promises';
+import { TemporarySpannerError } from '../spanner/index.js';
+/**
+ * The delay, in milliseconds, over which a timestamp issue is deemed irrecoverable.
+ */
+const ACCEPTABLE_PAST_DATE_DELAY = 25000;
+/**
+ * Checks if the given error is a `TransactionOldTimestampError` and throws a `TemporarySpannerError` such that the
+ * transaction can be retried by the runner.
+ * If the {@link TransactionOldTimestampError.delay} is too large, the error is deemed irrecoverable and nothing is
+ * thrown (it is up to the caller to handle the error).
+ *
+ * @param error The error to test.
+ */
+export async function throwRetryableInTransactionIfNeeded(error) {
+    // `TransactionOldTimestampError`s indicate that the transaction is using a timestamp older than what is
+    // observed in the state (Spanner).
+    if (!(error instanceof TransactionOldTimestampError)) {
+        return;
+    }
+    const delay = error.delay ?? Infinity;
+    if (delay >= ACCEPTABLE_PAST_DATE_DELAY) {
+        return;
+    }
+    if (delay > 0) {
+        await setTimeout(delay);
+    }
+    // Throwing a `TemporarySpannerError` will cause the transaction to be retried with a newer timestamp.
+    throw TemporarySpannerError.retryableInTransaction(error.message);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@causa/runtime-google",
-  "version": "0.33.1",
+  "version": "0.34.0",
   "description": "An extension to the Causa runtime SDK (`@causa/runtime`), providing Google-specific features.",
   "repository": "github:causa-io/runtime-typescript-google",
   "license": "ISC",
@@ -29,21 +29,21 @@
     "test:cov": "npm run test -- --coverage"
   },
   "dependencies": {
-    "@causa/runtime": ">= 0.23.0 < 1.0.0",
+    "@causa/runtime": ">= 0.24.0 < 1.0.0",
     "@google-cloud/precise-date": "^4.0.0",
     "@google-cloud/pubsub": "^4.9.0",
     "@google-cloud/spanner": "^7.16.0",
     "@google-cloud/tasks": "^5.5.1",
     "@grpc/grpc-js": "^1.12.2",
-    "@nestjs/common": "^10.4.8",
+    "@nestjs/common": "^10.4.11",
     "@nestjs/config": "^3.3.0",
-    "@nestjs/core": "^10.4.8",
+    "@nestjs/core": "^10.4.11",
     "@nestjs/passport": "^10.0.3",
     "@nestjs/terminus": "^10.2.3",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
     "express": "^4.21.1",
-    "firebase-admin": "^13.0.0",
+    "firebase-admin": "^13.0.1",
     "jsonwebtoken": "^9.0.2",
     "nestjs-pino": "^4.1.0",
     "passport-http-bearer": "^1.0.1",
@@ -51,18 +51,18 @@
     "reflect-metadata": "^0.2.2"
   },
   "devDependencies": {
-    "@nestjs/testing": "^10.4.8",
-    "@swc/core": "^1.9.2",
+    "@nestjs/testing": "^10.4.11",
+    "@swc/core": "^1.9.3",
     "@swc/jest": "^0.2.37",
     "@tsconfig/node22": "^22.0.0",
     "@types/jest": "^29.5.14",
     "@types/jsonwebtoken": "^9.0.7",
-    "@types/node": "^22.9.0",
+    "@types/node": "^22.10.0",
     "@types/passport-http-bearer": "^1.0.41",
     "@types/supertest": "^6.0.2",
     "@types/uuid": "^10.0.0",
     "dotenv": "^16.4.5",
-    "eslint": "^9.14.0",
+    "eslint": "^9.15.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.2.1",
     "jest": "^29.7.0",
@@ -71,8 +71,8 @@
     "supertest": "^7.0.0",
     "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
-    "typescript": "^5.6.3",
-    "typescript-eslint": "^8.14.0",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.16.0",
     "uuid": "^11.0.3"
   }
 }

package/dist/transaction/spanner-pubsub/transaction.d.ts

@@ -1,17 +0,0 @@
-import { BufferEventTransaction, Transaction } from '@causa/runtime';
-import { Transaction as SpannerTransaction } from '@google-cloud/spanner';
-import { SpannerEntityManager } from '../../spanner/index.js';
-import { SpannerStateTransaction } from './state-transaction.js';
-/**
- * A {@link Transaction} that uses Spanner for state storage and Pub/Sub for event publishing.
- */
-export declare class SpannerPubSubTransaction extends Transaction<SpannerStateTransaction, BufferEventTransaction> {
-    /**
-     * The underlying {@link SpannerTransaction} used by the state transaction.
-     */
-    get spannerTransaction(): SpannerTransaction;
-    /**
-     * The underlying {@link SpannerEntityManager} used by the state transaction.
-     */
-    get entityManager(): SpannerEntityManager;
-}

package/dist/transaction/spanner-pubsub/transaction.js

@@ -1,21 +0,0 @@
-import { BufferEventTransaction, Transaction } from '@causa/runtime';
-import { Transaction as SpannerTransaction } from '@google-cloud/spanner';
-import { SpannerEntityManager } from '../../spanner/index.js';
-import { SpannerStateTransaction } from './state-transaction.js';
-/**
- * A {@link Transaction} that uses Spanner for state storage and Pub/Sub for event publishing.
- */
-export class SpannerPubSubTransaction extends Transaction {
-    /**
-     * The underlying {@link SpannerTransaction} used by the state transaction.
-     */
-    get spannerTransaction() {
-        return this.stateTransaction.transaction;
-    }
-    /**
-     * The underlying {@link SpannerEntityManager} used by the state transaction.
-     */
-    get entityManager() {
-        return this.stateTransaction.entityManager;
-    }
-}