@causa/runtime-google 1.2.0 → 1.4.0

package/dist/firestore/collection.decorator.d.ts

@@ -11,12 +11,13 @@ export type FirestoreCollectionMetadata<T> = {
     name: string;
     /**
      * Returns the path of the document (relative to the collection) for the given partial document.
+     * If an array is returned, the segments are joined with `/` to form the full path.
+     * If any `undefined` or `null` value is returned, an error is thrown.
      *
      * @param document The (partial) document for which the path should be returned.
-     * @returns The path of the document (relative to the collection), or `undefined` if the path cannot be derived from
-     *   the partial document.
+     * @returns The path of the document (relative to the collection).
      */
-    path: (document: Partial<T>) => string | undefined;
+    path: (document: Partial<T>) => string | undefined | null | (string | undefined | null)[];
 };
 /**
  * Defines this class as a type of document stored in the given Firestore collection.

package/dist/firestore/collection.decorator.js

@@ -40,9 +40,10 @@ export function getFirestoreCollectionMetadataForType(documentType) {
 export function getReferenceForFirestoreDocument(collection, document, documentType) {
     documentType ??= document.constructor;
     const { path } = getFirestoreCollectionMetadataForType(documentType);
-    const relativePath = path(document);
-    if (!relativePath) {
+    const rawPath = path(document);
+    const pathArray = Array.isArray(rawPath) ? rawPath : [rawPath];
+    if (pathArray.some((p) => p == undefined)) {
         throw new Error(`The path of the '${documentType.name}' document cannot be obtained from the given object.`);
     }
-    return collection.doc(relativePath);
+    return collection.doc(pathArray.join('/'));
 }

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

@@ -277,6 +277,41 @@ export declare class SpannerEntityManager {
      * @returns The rows returned by the query.
      */
     query<T>(statement: SqlStatement): Promise<T[]>;
+    /**
+     * Runs the given SQL statement in the database, returning an async iterable of the results.
+     * 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.
+     * @returns An async iterable that yields the rows returned by the query.
+     *   If {@link QueryOptions.entityType} is set, the rows are converted to instances of that class.
+     */
+    queryStream<T>(options: QueryOptions<T>, statement: SqlStatement): AsyncIterable<T>;
+    /**
+     * Runs the given SQL statement in the database, returning an async iterable of the results.
+     * The statement is run in a {@link SpannerReadOnlyTransaction}.
+     *
+     * @param statement The SQL statement to run.
+     * @returns An async iterable that yields the rows returned by the query.
+     */
+    queryStream<T>(statement: SqlStatement): AsyncIterable<T>;
+    /**
+     * Runs the given SQL statement in the database, returning an async iterable of batches of results.
+     * 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.
+     * @returns An async iterable that yields batches of rows returned by the query.
+     *   If {@link QueryOptions.entityType} is set, the rows are converted to instances of that class.
+     */
+    queryBatches<T>(options: QueryOptions<T> & {
+        /**
+         * The maximum number of items to include in each batch.
+         */
+        batchSize: number;
+    }, statement: SqlStatement): AsyncIterable<T[]>;
     static readonly ParamTypeFloat64Array: ParamType;
     static readonly ParamTypeInt64Array: ParamType;
     static readonly ParamTypeNumericArray: ParamType;

package/dist/spanner/entity-manager.js

@@ -9,11 +9,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { EntityNotFoundError } from '@causa/runtime';
 import { Database, Snapshot, Transaction } from '@google-cloud/spanner';
-import { Int, } from '@google-cloud/spanner/build/src/codec.js';
+import {} from '@google-cloud/spanner/build/src/codec.js';
 import { Injectable } from '@nestjs/common';
 import { copyInstanceWithMissingColumnsToNull, instanceToSpannerObject, spannerObjectToInstance, updateInstanceByColumn, } from './conversion.js';
 import { convertSpannerToEntityError } from './error-converter.js';
-import { EntityMissingPrimaryKeyError, InvalidArgumentError, TransactionFinishedError, } from './errors.js';
+import { InvalidArgumentError, TransactionFinishedError } from './errors.js';
 import { SpannerTableCache } from './table-cache.js';
 /**
  * A class that manages access to entities stored in a Cloud Spanner database.
@@ -44,8 +44,8 @@ let SpannerEntityManager = class SpannerEntityManager {
      */
     getPrimaryKey(entity, entityType) {
         entityType ??= entity.constructor;
-        const obj = instanceToSpannerObject(entity, entityType);
-        return this.getPrimaryKeyForSpannerObject(obj, entityType);
+        const { primaryKeyGetter } = this.tableCache.getMetadata(entityType);
+        return primaryKeyGetter(entity);
     }
     /**
      * Returns the primary key of the given Spanner object, assumed to be an entity of the given type.
@@ -55,20 +55,8 @@ let SpannerEntityManager = class SpannerEntityManager {
      * @returns The primary key of the entity.
      */
     getPrimaryKeyForSpannerObject(obj, entityType) {
-        const { primaryKeyColumns } = this.tableCache.getMetadata(entityType);
-        return primaryKeyColumns.map((c) => {
-            const value = obj[c];
-            if (value === undefined) {
-                throw new EntityMissingPrimaryKeyError();
-            }
-            if (value instanceof Int) {
-                return value.value;
-            }
-            if (value instanceof Date) {
-                return value.toJSON();
-            }
-            return value;
-        });
+        const entity = spannerObjectToInstance(obj, entityType);
+        return this.getPrimaryKey(entity, entityType);
     }
     /**
      * Returns the (quoted) name of the table for the given entity type.
@@ -295,23 +283,53 @@ let SpannerEntityManager = class SpannerEntityManager {
         await this.transaction(options, (transaction) => transaction.runUpdate(`DELETE FROM \`${tableName}\` WHERE TRUE`));
     }
     async query(optionsOrStatement, statement) {
+        return await Array.fromAsync(this.queryStream(optionsOrStatement, statement));
+    }
+    async *queryStream(optionsOrStatement, statement) {
         const options = statement
             ? optionsOrStatement
             : {};
         const sqlStatement = statement ?? optionsOrStatement;
-        const { entityType, requestOptions } = options;
-        return await this.snapshot({ transaction: options.transaction }, async (transaction) => {
-            const [rows] = await transaction.run({
+        const { entityType, requestOptions, transaction } = options;
+        try {
+            const stream = (transaction ?? this.database).runStream({
                 ...sqlStatement,
                 requestOptions,
                 json: true,
                 jsonOptions: { wrapNumbers: entityType != null },
             });
-            if (entityType) {
-                return rows.map((row) => spannerObjectToInstance(row, entityType));
+            for await (const row of stream) {
+                yield entityType ? spannerObjectToInstance(row, entityType) : row;
             }
-            return rows;
-        });
+        }
+        catch (error) {
+            // If running in a transaction, the error will be caught by `snapshot()` or `transaction()`.
+            throw transaction ? error : (convertSpannerToEntityError(error) ?? error);
+        }
+    }
+    /**
+     * Runs the given SQL statement in the database, returning an async iterable of batches of results.
+     * 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.
+     * @returns An async iterable that yields batches of rows returned by the query.
+     *   If {@link QueryOptions.entityType} is set, the rows are converted to instances of that class.
+     */
+    async *queryBatches(options, statement) {
+        const { batchSize } = options;
+        let batch = [];
+        for await (const item of this.queryStream(options, statement)) {
+            batch.push(item);
+            if (batch.length >= batchSize) {
+                yield batch;
+                batch = [];
+            }
+        }
+        if (batch.length > 0) {
+            yield batch;
+        }
     }
     // Types that can be used as hints to disambiguate query parameter array types.
     static ParamTypeFloat64Array = {

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 { catchSpannerDatabaseErrors, getDefaultSpannerDatabaseForCloudFunction, SPANNER_SESSION_POOL_OPTIONS_FOR_CLOUD_FUNCTIONS, SPANNER_SESSION_POOL_OPTIONS_FOR_SERVICE, } from './database.js';
 export { SpannerEntityManager } from './entity-manager.js';
-export type { SpannerKey, SpannerReadOnlyTransaction, SpannerReadWriteTransaction, } from './entity-manager.js';
+export type { SpannerKey, SpannerReadOnlyTransaction, SpannerReadWriteTransaction, SqlStatement, } from './entity-manager.js';
 export * from './errors.js';
 export { SpannerHealthIndicator } from './healthcheck.js';
 export { SpannerModule } from './module.js';

package/dist/spanner/index.js

@@ -1,5 +1,5 @@
 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 { catchSpannerDatabaseErrors, getDefaultSpannerDatabaseForCloudFunction, SPANNER_SESSION_POOL_OPTIONS_FOR_CLOUD_FUNCTIONS, SPANNER_SESSION_POOL_OPTIONS_FOR_SERVICE, } from './database.js';
 export { SpannerEntityManager } from './entity-manager.js';
 export * from './errors.js';
 export { SpannerHealthIndicator } from './healthcheck.js';

package/dist/spanner/table-cache.d.ts

@@ -1,4 +1,9 @@
 import type { Type } from '@nestjs/common';
+import type { SpannerKey } from './entity-manager.js';
+/**
+ * A function that, given an entity, returns its primary key as a {@link SpannerKey}.
+ */
+type SpannerPrimaryKeyGetter = (entity: any) => SpannerKey;
 /**
  * An object providing metadata about a Spanner table and its columns.
  */
@@ -8,9 +13,14 @@ export type CachedSpannerTableMetadata = {
      */
     tableName: string;
     /**
-     * The (ordered) list of columns that are part of the primary key.
+     * The list of columns that are used to compute the primary key.
+     * For primary keys with generated columns, this includes the columns off of which the key is composed.
      */
     primaryKeyColumns: string[];
+    /**
+     * A function that, given an entity, returns its primary key as a {@link SpannerKey}.
+     */
+    primaryKeyGetter: SpannerPrimaryKeyGetter;
     /**
      * A map from class property names to Spanner column names.
      */
@@ -43,3 +53,4 @@ export declare class SpannerTableCache {
      */
     getMetadata(entityType: Type): CachedSpannerTableMetadata;
 }
+export {};

package/dist/spanner/table-cache.js

@@ -1,6 +1,34 @@
+import { Float, Float32, Int, Numeric } from '@google-cloud/spanner';
 import { getSpannerColumnsMetadata } from './column.decorator.js';
-import { InvalidEntityDefinitionError } from './errors.js';
+import { EntityMissingPrimaryKeyError, InvalidEntityDefinitionError, } from './errors.js';
 import { getSpannerTableMetadataFromType } from './table.decorator.js';
+/**
+ * Constructs a {@link SpannerPrimaryKeyGetter} for the given property paths.
+ *
+ * @param paths The paths to resolve in the entity to get primary key values.
+ * @returns The {@link SpannerPrimaryKeyGetter}.
+ */
+function makePrimaryKeyGetter(paths) {
+    return (entity) => paths.map((path) => {
+        const value = path.reduce((v, k) => v?.[k], entity);
+        if (value === undefined) {
+            throw new EntityMissingPrimaryKeyError();
+        }
+        if (value instanceof Int ||
+            value instanceof Float ||
+            value instanceof Float32 ||
+            value instanceof Numeric) {
+            return value.value.toString();
+        }
+        if (value instanceof Date) {
+            return value.toJSON();
+        }
+        if (typeof value === 'bigint' || typeof value === 'number') {
+            return value.toString();
+        }
+        return value;
+    });
+}
 /**
  * A cache storing the {@link CachedSpannerTableMetadata} for each entity type (class).
  */
@@ -21,7 +49,6 @@ export class SpannerTableCache {
             throw new InvalidEntityDefinitionError(entityType);
         }
         const tableName = tableMetadata.name;
-        const primaryKeyColumns = tableMetadata.primaryKey;
         const columnsMetadata = getSpannerColumnsMetadata(entityType);
         const softDeleteColumns = Object.values(columnsMetadata).filter((metadata) => metadata.softDelete);
         if (softDeleteColumns.length > 1) {
@@ -29,9 +56,22 @@ export class SpannerTableCache {
         }
         const softDeleteColumn = softDeleteColumns[0]?.name ?? null;
         const columnNames = Object.fromEntries(Object.entries(columnsMetadata).map(([prop, { name }]) => [prop, name]));
+        const primaryKeyColumnsSet = new Set();
+        const primaryPropertyPaths = tableMetadata.primaryKey.map((path) => {
+            const [columnName, ...nested] = path.split('.');
+            primaryKeyColumnsSet.add(columnName);
+            const property = Object.entries(columnNames).find(([, name]) => name === columnName);
+            if (!property) {
+                throw new InvalidEntityDefinitionError(entityType, `Primary key column '${columnName}' does not exist.`);
+            }
+            return [property[0], ...nested];
+        });
+        const primaryKeyColumns = [...primaryKeyColumnsSet];
+        const primaryKeyGetter = makePrimaryKeyGetter(primaryPropertyPaths);
         return {
             tableName,
             primaryKeyColumns,
+            primaryKeyGetter,
             softDeleteColumn,
             columnNames,
         };

package/dist/spanner/table.decorator.d.ts

@@ -9,7 +9,9 @@ export type SpannerTableMetadata = {
      */
     name: string;
     /**
-     * The (ordered) list of columns in the class defining the primary key.
+     * The (ordered) list of columns in the table defining the primary key.
+     * Column names should be used rather than property names (if they differ).
+     * Nested columns can be used, using dot notation (e.g., `address.city`).
      */
     primaryKey: string[];
 };

package/dist/transaction/firestore-pubsub/readonly-state-transaction.js

@@ -1,5 +1,6 @@
 import { Transaction } from 'firebase-admin/firestore';
 import { getReferenceForFirestoreDocument } from '../../firestore/index.js';
+import { getSoftDeleteInfo } from './soft-deleted-collection.decorator.js';
 /**
  * A {@link ReadOnlyStateTransaction} that uses Firestore for state storage.
  *
@@ -25,23 +26,23 @@ export class FirestoreReadOnlyStateTransaction {
         this.collectionResolver = collectionResolver;
     }
     async get(type, entity) {
-        const { activeCollection, softDelete } = this.collectionResolver.getCollectionsForType(type);
+        const { activeCollection } = this.collectionResolver.getCollectionsForType(type);
         const activeDocRef = getReferenceForFirestoreDocument(activeCollection, entity, type);
         const activeSnapshot = await this.firestoreTransaction.get(activeDocRef);
         const activeDocument = activeSnapshot.data();
         if (activeDocument) {
             return activeDocument;
         }
-        if (!softDelete) {
+        const softDeleteInfo = getSoftDeleteInfo(activeDocRef, type);
+        if (!softDeleteInfo) {
             return null;
         }
-        const deletedDocRef = getReferenceForFirestoreDocument(softDelete.collection, entity, type);
-        const deletedSnapshot = await this.firestoreTransaction.get(deletedDocRef);
+        const deletedSnapshot = await this.firestoreTransaction.get(softDeleteInfo.ref);
         const deletedDocument = deletedSnapshot.data();
         if (!deletedDocument) {
             return null;
         }
-        delete deletedDocument[softDelete.expirationField];
+        delete deletedDocument[softDeleteInfo.expirationField];
         return deletedDocument;
     }
 }

package/dist/transaction/firestore-pubsub/soft-deleted-collection.decorator.d.ts

@@ -24,6 +24,15 @@ export type SoftDeletedFirestoreCollectionMetadata = {
      */
     deletedDocumentsCollectionSuffix: string;
 };
+/**
+ * Information about soft-deletion for a given document.
+ */
+export type SoftDeleteInfo<T extends object> = Omit<SoftDeletedFirestoreCollectionMetadata, 'deletedDocumentsCollectionSuffix'> & {
+    /**
+     * The reference to the soft-deleted document.
+     */
+    ref: FirebaseFirestore.DocumentReference<T>;
+};
 /**
  * Defines this class as a type of Firestore document stored that can be soft-deleted.
  * Documents should be {@link VersionedEntity} that are considered soft-deleted when their `deletedAt` field is set.
@@ -39,3 +48,12 @@ export declare function SoftDeletedFirestoreCollection(metadata?: Partial<SoftDe
  * @returns The metadata for the soft-deleted Firestore collection, or `null` if the type is not decorated.
  */
 export declare function getSoftDeletedFirestoreCollectionMetadataForType(documentType: Type): SoftDeletedFirestoreCollectionMetadata | null;
+/**
+ * Returns the soft-delete information for a given document, if the document type supports soft-deletion.
+ *
+ * @param activeDocRef The reference to the active document.
+ * @param type The type of the document.
+ * @returns The soft-delete information for the document, or `null` if the document type does not support
+ *   soft-deletion.
+ */
+export declare function getSoftDeleteInfo<T extends object>(activeDocRef: FirebaseFirestore.DocumentReference<T>, type: Type<T>): SoftDeleteInfo<T> | null;

package/dist/transaction/firestore-pubsub/soft-deleted-collection.decorator.js

@@ -1,4 +1,5 @@
 import 'reflect-metadata';
+import { makeFirestoreDataConverter } from '../../firestore/index.js';
 /**
  * The name of the metadata key used to store the soft-deleted Firestore collection metadata.
  */
@@ -30,3 +31,23 @@ export function getSoftDeletedFirestoreCollectionMetadataForType(documentType) {
     const metadata = Reflect.getOwnMetadata(FIRESTORE_SOFT_DELETED_COLLECTION_METADATA_KEY, documentType);
     return metadata ?? null;
 }
+/**
+ * Returns the soft-delete information for a given document, if the document type supports soft-deletion.
+ *
+ * @param activeDocRef The reference to the active document.
+ * @param type The type of the document.
+ * @returns The soft-delete information for the document, or `null` if the document type does not support
+ *   soft-deletion.
+ */
+export function getSoftDeleteInfo(activeDocRef, type) {
+    const softDeleteMetadata = getSoftDeletedFirestoreCollectionMetadataForType(type);
+    if (!softDeleteMetadata) {
+        return null;
+    }
+    const { deletedDocumentsCollectionSuffix: suffix, ...info } = softDeleteMetadata;
+    const softDeleteCollection = activeDocRef.firestore
+        .collection(`${activeDocRef.parent.path}${suffix}`)
+        .withConverter(makeFirestoreDataConverter(type));
+    const ref = softDeleteCollection.doc(activeDocRef.id);
+    return { ...info, ref };
+}

package/dist/transaction/firestore-pubsub/state-transaction.js

@@ -1,6 +1,7 @@
 import { plainToInstance } from 'class-transformer';
 import { getReferenceForFirestoreDocument } from '../../firestore/index.js';
 import { FirestoreReadOnlyStateTransaction } from './readonly-state-transaction.js';
+import { getSoftDeleteInfo } from './soft-deleted-collection.decorator.js';
 /**
  * A {@link StateTransaction} that uses Firestore for state storage.
  *
@@ -22,26 +23,26 @@ export class FirestoreStateTransaction extends FirestoreReadOnlyStateTransaction
     async delete(typeOrEntity, key) {
         const type = (key === undefined ? typeOrEntity.constructor : typeOrEntity);
         key ??= typeOrEntity;
-        const { activeCollection, softDelete } = this.collectionResolver.getCollectionsForType(type);
+        const { activeCollection } = this.collectionResolver.getCollectionsForType(type);
         const activeDocRef = getReferenceForFirestoreDocument(activeCollection, key, type);
         this.firestoreTransaction.delete(activeDocRef);
-        if (!softDelete) {
+        const softDeleteInfo = getSoftDeleteInfo(activeDocRef, type);
+        if (!softDeleteInfo) {
             return;
         }
-        const deletedDocRef = getReferenceForFirestoreDocument(softDelete.collection, key, type);
-        this.firestoreTransaction.delete(deletedDocRef);
+        this.firestoreTransaction.delete(softDeleteInfo.ref);
     }
     async set(entity) {
         const documentType = entity.constructor;
-        const { activeCollection, softDelete } = this.collectionResolver.getCollectionsForType(documentType);
+        const { activeCollection } = this.collectionResolver.getCollectionsForType(documentType);
         const activeDocRef = getReferenceForFirestoreDocument(activeCollection, entity);
-        if (!softDelete) {
+        const softDeleteInfo = getSoftDeleteInfo(activeDocRef, documentType);
+        if (!softDeleteInfo) {
             this.firestoreTransaction.set(activeDocRef, entity);
             return;
         }
-        const deletedDocRef = getReferenceForFirestoreDocument(softDelete.collection, entity);
+        const { ref: deletedDocRef, expirationDelay, expirationField, } = softDeleteInfo;
         if ('deletedAt' in entity && entity.deletedAt instanceof Date) {
-            const { expirationDelay, expirationField } = softDelete;
             const expiresAt = new Date(entity.deletedAt.getTime() + expirationDelay);
             const deletedDoc = plainToInstance(documentType, {
                 ...entity,

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

@@ -1,7 +1,9 @@
 import { OutboxEventTransaction, Transaction, type PublishOptions, type TransactionOption } from '@causa/runtime';
 import type { Type } from '@nestjs/common';
 import { Transaction as FirestoreTransaction } from 'firebase-admin/firestore';
+import { FirestoreReadOnlyStateTransaction } from './readonly-state-transaction.js';
 import type { FirestoreStateTransaction } from './state-transaction.js';
+import type { FirestoreCollectionResolver } from './types.js';
 /**
  * Option for a function that accepts a {@link FirestorePubSubTransaction}.
  */
@@ -9,7 +11,7 @@ export type FirestoreOutboxTransactionOption = TransactionOption<FirestorePubSub
 /**
  * A {@link Transaction} that uses Firestore for state storage and Pub/Sub for event publishing.
  */
-export declare class FirestorePubSubTransaction extends Transaction {
+export declare class FirestorePubSubTransaction extends Transaction implements FirestoreReadOnlyStateTransaction {
     readonly stateTransaction: FirestoreStateTransaction;
     private readonly eventTransaction;
     constructor(stateTransaction: FirestoreStateTransaction, eventTransaction: OutboxEventTransaction, publishOptions?: PublishOptions);
@@ -17,6 +19,7 @@ export declare class FirestorePubSubTransaction extends Transaction {
      * The underlying {@link FirestoreTransaction} used by the state transaction.
      */
     get firestoreTransaction(): FirestoreTransaction;
+    get collectionResolver(): FirestoreCollectionResolver;
     set<T extends object>(entity: T): Promise<void>;
     delete<T extends object>(type: Type<T> | T, key?: Partial<T>): Promise<void>;
     get<T extends object>(type: Type<T>, entity: Partial<T>): Promise<T | null>;

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

@@ -1,5 +1,6 @@
 import { OutboxEventTransaction, Transaction, } from '@causa/runtime';
 import { Transaction as FirestoreTransaction } from 'firebase-admin/firestore';
+import { FirestoreReadOnlyStateTransaction } from './readonly-state-transaction.js';
 /**
  * A {@link Transaction} that uses Firestore for state storage and Pub/Sub for event publishing.
  */
@@ -17,6 +18,9 @@ export class FirestorePubSubTransaction extends Transaction {
     get firestoreTransaction() {
         return this.stateTransaction.firestoreTransaction;
     }
+    get collectionResolver() {
+        return this.stateTransaction.collectionResolver;
+    }
     set(entity) {
         return this.stateTransaction.set(entity);
     }

package/dist/transaction/firestore-pubsub/types.d.ts

@@ -12,6 +12,8 @@ export type FirestoreCollectionsForDocumentType<T> = {
     /**
      * Configuration about the soft-delete collection, where documents are stored when their `deletedAt` field is not
      * `null`. This can be `null` if the document type does not declare a soft-delete collection.
+     *
+     * @deprecated Use `SoftDeleteInfo` in `FirestoreReadOnlyStateTransaction.getSoftDeleteInfo` instead.
      */
     readonly softDelete: ({
         /**

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

@@ -1,6 +1,7 @@
 import { OutboxEventTransaction, Transaction, type OutboxTransaction, type PublishOptions, type TransactionOption } from '@causa/runtime';
 import type { Type } from '@nestjs/common';
 import { SpannerEntityManager, type SpannerReadWriteTransaction } from '../../spanner/index.js';
+import type { SpannerReadOnlyStateTransaction } from './readonly-transaction.js';
 import type { SpannerStateTransaction } from './state-transaction.js';
 /**
  * Option for a function that accepts a {@link SpannerOutboxTransaction}.
@@ -9,7 +10,7 @@ export type SpannerOutboxTransactionOption = TransactionOption<SpannerOutboxTran
 /**
  * A {@link Transaction} that uses Spanner for state (and outbox) storage, and Pub/Sub for event publishing.
  */
-export declare class SpannerOutboxTransaction extends Transaction implements OutboxTransaction {
+export declare class SpannerOutboxTransaction extends Transaction implements OutboxTransaction, SpannerReadOnlyStateTransaction {
     readonly stateTransaction: SpannerStateTransaction;
     readonly eventTransaction: OutboxEventTransaction;
     constructor(stateTransaction: SpannerStateTransaction, eventTransaction: OutboxEventTransaction, publishOptions?: PublishOptions);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@causa/runtime-google",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "An extension to the Causa runtime SDK (`@causa/runtime`), providing Google-specific features.",
   "repository": {
     "type": "git",
@@ -32,15 +32,15 @@
     "test:cov": "npm run test -- --coverage"
   },
   "dependencies": {
-    "@causa/runtime": "^1.1.0",
+    "@causa/runtime": "^1.4.0",
     "@google-cloud/precise-date": "^5.0.0",
     "@google-cloud/pubsub": "^5.2.0",
-    "@google-cloud/spanner": "^8.2.1",
-    "@google-cloud/tasks": "^6.2.0",
+    "@google-cloud/spanner": "^8.2.2",
+    "@google-cloud/tasks": "^6.2.1",
     "@grpc/grpc-js": "^1.14.0",
-    "@nestjs/common": "^11.1.6",
+    "@nestjs/common": "^11.1.8",
     "@nestjs/config": "^4.0.2",
-    "@nestjs/core": "^11.1.6",
+    "@nestjs/core": "^11.1.8",
     "@nestjs/passport": "^11.0.5",
     "@nestjs/terminus": "^11.0.0",
     "class-transformer": "^0.5.1",
@@ -49,31 +49,31 @@
     "firebase-admin": "^13.5.0",
     "jsonwebtoken": "^9.0.2",
     "passport-http-bearer": "^1.0.1",
-    "pino": "^9.12.0",
+    "pino": "^9.14.0",
     "reflect-metadata": "^0.2.2"
   },
   "devDependencies": {
-    "@nestjs/testing": "^11.1.6",
-    "@swc/core": "^1.13.5",
+    "@nestjs/testing": "^11.1.8",
+    "@swc/core": "^1.15.0",
     "@swc/jest": "^0.2.39",
     "@tsconfig/node22": "^22.0.2",
     "@types/jest": "^30.0.0",
     "@types/jsonwebtoken": "^9.0.10",
-    "@types/node": "^22.18.8",
+    "@types/node": "^22.19.0",
     "@types/passport-http-bearer": "^1.0.42",
     "@types/supertest": "^6.0.3",
     "@types/uuid": "^11.0.0",
     "dotenv": "^17.2.3",
-    "eslint": "^9.36.0",
+    "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
     "jest": "^30.2.0",
     "jest-extended": "^6.0.0",
-    "pino-pretty": "^13.1.1",
-    "rimraf": "^6.0.1",
+    "pino-pretty": "^13.1.2",
+    "rimraf": "^6.1.0",
     "supertest": "^7.1.4",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.45.0",
+    "typescript-eslint": "^8.46.3",
     "uuid": "^13.0.0"
   }
 }