@causa/runtime-google 0.33.1 → 0.35.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/app-check/guard.js

@@ -7,6 +7,7 @@ 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);
 };
+var AppCheckGuard_1;
 import { Logger, UnauthenticatedError } from '@causa/runtime/nestjs';
 import { Injectable, } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
@@ -16,7 +17,7 @@ import { APP_CHECK_DISABLED_METADATA_KEY } from './app-check-disabled.decorator.
  * A NestJS guard that verifies the App Check token in the request.
  * The token is expected to be in the `X-Firebase-AppCheck` header.
  */
-let AppCheckGuard = class AppCheckGuard {
+let AppCheckGuard = AppCheckGuard_1 = class AppCheckGuard {
     appCheck;
     reflector;
     logger;
@@ -24,6 +25,7 @@ let AppCheckGuard = class AppCheckGuard {
         this.appCheck = appCheck;
         this.reflector = reflector;
         this.logger = logger;
+        this.logger.setContext(AppCheckGuard_1.name);
     }
     async canActivate(context) {
         const isDisabled = this.reflector.getAllAndOverride(APP_CHECK_DISABLED_METADATA_KEY, [context.getHandler(), context.getClass()]);
@@ -45,7 +47,7 @@ let AppCheckGuard = class AppCheckGuard {
         }
     }
 };
-AppCheckGuard = __decorate([
+AppCheckGuard = AppCheckGuard_1 = __decorate([
     Injectable(),
     __metadata("design:paramtypes", [AppCheck,
         Reflector,

package/dist/identity-platform/identity-platform.strategy.js

@@ -7,6 +7,7 @@ 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);
 };
+var IdentityPlatformStrategy_1;
 import { Logger, UnauthenticatedError } from '@causa/runtime/nestjs';
 import { Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
@@ -19,7 +20,7 @@ import { Strategy } from 'passport-http-bearer';
  * The `IDENTITY_PLATFORM_STRATEGY_CHECK_REVOKED_TOKEN` configuration key can be set to `true` to also check whether the
  * token was revoked. This implies a call to the Identity Platform, which will increase latency.
  */
-let IdentityPlatformStrategy = class IdentityPlatformStrategy extends PassportStrategy(Strategy) {
+let IdentityPlatformStrategy = IdentityPlatformStrategy_1 = class IdentityPlatformStrategy extends PassportStrategy(Strategy) {
     auth;
     configService;
     logger;
@@ -32,6 +33,7 @@ let IdentityPlatformStrategy = class IdentityPlatformStrategy extends PassportSt
         this.auth = auth;
         this.configService = configService;
         this.logger = logger;
+        this.logger.setContext(IdentityPlatformStrategy_1.name);
         this.checkRevoked = this.configService.get('IDENTITY_PLATFORM_STRATEGY_CHECK_REVOKED_TOKEN', false);
     }
     async validate(token) {
@@ -56,7 +58,7 @@ let IdentityPlatformStrategy = class IdentityPlatformStrategy extends PassportSt
         return user;
     }
 };
-IdentityPlatformStrategy = __decorate([
+IdentityPlatformStrategy = IdentityPlatformStrategy_1 = __decorate([
     Injectable(),
     __metadata("design:paramtypes", [Auth,
         ConfigService,

package/dist/pubsub/publisher.d.ts

@@ -1,7 +1,7 @@
-import { type EventPublisher, type ObjectSerializer, type PublishOptions } from '@causa/runtime';
+import { type EventPublisher, type ObjectSerializer, type PreparedEvent, type PublishOptions } from '@causa/runtime';
+import { Logger } from '@causa/runtime/nestjs';
 import { PubSub, type PublishOptions as TopicPublishOptions } from '@google-cloud/pubsub';
 import type { OnApplicationShutdown } from '@nestjs/common';
-import type { Logger } from 'pino';
 /**
  * Options for the {@link PubSubPublisher}.
  */
@@ -32,16 +32,12 @@ export type PubSubPublisherOptions = {
      * This inherits and overrides the {@link PubSubPublisherOptions.publishOptions} for a given topic.
      */
     topicPublishOptions?: Record<string, TopicPublishOptions>;
-    /**
-     * The logger to use.
-     * Defaults to {@link getDefaultLogger}.
-     */
-    logger?: Logger;
 };
 /**
  * An implementation of the {@link EventPublisher} using Google Pub/Sub as the broker.
  */
 export declare class PubSubPublisher implements EventPublisher, OnApplicationShutdown {
+    private readonly logger;
     /**
      * The {@link PubSub} client to use.
      */
@@ -59,10 +55,6 @@ export declare class PubSubPublisher implements EventPublisher, OnApplicationShu
      * A cache of Pub/Sub {@link Topic}s to which messages can be published.
      */
     private readonly topicCache;
-    /**
-     * The logger to use.
-     */
-    readonly logger: Logger;
     /**
      * The options to use when publishing messages.
      * This is used to instantiate the Pub/Sub {@link Topic}s.
@@ -77,9 +69,10 @@ export declare class PubSubPublisher implements EventPublisher, OnApplicationShu
     /**
      * Creates a new {@link PubSubPublisher}.
      *
+     * @param logger The logger to use.
      * @param options Options for the publisher.
      */
-    constructor(options?: PubSubPublisherOptions);
+    constructor(logger: Logger, options?: PubSubPublisherOptions);
     /**
      * Returns the Pub/Sub {@link Topic} to which messages can be published for a given event topic.
      * If the topic has not been used before, it will be created using the {@link PubSubPublisher.publishOptions}.
@@ -88,7 +81,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

@@ -1,4 +1,5 @@
-import { JsonObjectSerializer, getDefaultLogger, } from '@causa/runtime';
+import { JsonObjectSerializer, } from '@causa/runtime';
+import { Logger } from '@causa/runtime/nestjs';
 import { PubSub, Topic, } from '@google-cloud/pubsub';
 import { getConfigurationKeyForTopic } from './configuration.js';
 import { PubSubTopicNotConfiguredError } from './errors.js';
@@ -14,6 +15,7 @@ const DEFAULT_PUBLISH_OPTIONS = {
  * An implementation of the {@link EventPublisher} using Google Pub/Sub as the broker.
  */
 export class PubSubPublisher {
+    logger;
     /**
      * The {@link PubSub} client to use.
      */
@@ -31,10 +33,6 @@ export class PubSubPublisher {
      * A cache of Pub/Sub {@link Topic}s to which messages can be published.
      */
     topicCache = {};
-    /**
-     * The logger to use.
-     */
-    logger;
     /**
      * The options to use when publishing messages.
      * This is used to instantiate the Pub/Sub {@link Topic}s.
@@ -49,16 +47,18 @@ export class PubSubPublisher {
     /**
      * Creates a new {@link PubSubPublisher}.
      *
+     * @param logger The logger to use.
      * @param options Options for the publisher.
      */
-    constructor(options = {}) {
+    constructor(logger, options = {}) {
+        this.logger = logger;
+        this.logger.setContext(PubSubPublisher.name);
         this.pubSub = options.pubSub ?? new PubSub();
         this.serializer = options.serializer ?? new JsonObjectSerializer();
         this.getConfiguration =
             options.configurationGetter ?? ((key) => process.env[key]);
         this.publishOptions = options.publishOptions ?? DEFAULT_PUBLISH_OPTIONS;
         this.topicPublishOptions = options.topicPublishOptions ?? {};
-        this.logger = options.logger ?? getDefaultLogger();
     }
     /**
      * Returns the Pub/Sub {@link Topic} to which messages can be published for a given event topic.
@@ -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/pubsub/publisher.module.js

@@ -28,11 +28,10 @@ export class PubSubPublisherModule {
                 },
                 {
                     provide: PubSubPublisher,
-                    useFactory: (pubSub, configurationGetter, { logger }) => new PubSubPublisher({
+                    useFactory: (pubSub, configurationGetter, logger) => new PubSubPublisher(logger, {
                         ...options,
                         pubSub,
                         configurationGetter,
-                        logger,
                     }),
                     inject: [
                         PubSub,

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/firestore-pubsub/runner.js

@@ -7,6 +7,7 @@ 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);
 };
+var FirestorePubSubTransactionRunner_1;
 import { BufferEventTransaction, TransactionRunner } from '@causa/runtime';
 import { Logger } from '@causa/runtime/nestjs';
 import { Firestore } from '@google-cloud/firestore';
@@ -22,7 +23,7 @@ import { FirestorePubSubTransaction } from './transaction.js';
  * This runner and the transaction use the {@link FirestoreStateTransaction}, which handles soft-deleted documents. All
  * entities that are written to the state should be decorated with the `SoftDeletedFirestoreCollection` decorator.
  */
-let FirestorePubSubTransactionRunner = class FirestorePubSubTransactionRunner extends TransactionRunner {
+let FirestorePubSubTransactionRunner = FirestorePubSubTransactionRunner_1 = class FirestorePubSubTransactionRunner extends TransactionRunner {
     firestore;
     pubSubPublisher;
     collectionResolver;
@@ -33,6 +34,7 @@ let FirestorePubSubTransactionRunner = class FirestorePubSubTransactionRunner ex
         this.pubSubPublisher = pubSubPublisher;
         this.collectionResolver = collectionResolver;
         this.logger = logger;
+        this.logger.setContext(FirestorePubSubTransactionRunner_1.name);
     }
     async run(runFn) {
         this.logger.info('Creating a Firestore Pub/Sub transaction.');
@@ -49,7 +51,7 @@ let FirestorePubSubTransactionRunner = class FirestorePubSubTransactionRunner ex
         return [result];
     }
 };
-FirestorePubSubTransactionRunner = __decorate([
+FirestorePubSubTransactionRunner = FirestorePubSubTransactionRunner_1 = __decorate([
     Injectable(),
     __metadata("design:paramtypes", [Firestore,
         PubSubPublisher, Object, Logger])

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