@causa/runtime-google 0.40.0 → 1.0.0-rc.1

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

@@ -1,21 +0,0 @@
-import { SpannerPubSubTransactionRunner } from './runner.js';
-/**
- * The module exposing the {@link SpannerPubSubTransactionRunner}.
- * This modules assumes that the `SpannerModule` and `PubSubPublisherModule` are available.
- */
-export class SpannerPubSubTransactionModule {
-    /**
-     * Create a global module that provides the {@link SpannerPubSubTransactionRunner}.
-     * This modules assumes that the `SpannerModule` and `PubSubPublisherModule` are available.
-     *
-     * @returns The module.
-     */
-    static forRoot() {
-        return {
-            module: SpannerPubSubTransactionModule,
-            global: true,
-            providers: [SpannerPubSubTransactionRunner],
-            exports: [SpannerPubSubTransactionRunner],
-        };
-    }
-}

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

@@ -1,23 +0,0 @@
-import { TransactionRunner } from '@causa/runtime';
-import { Logger } from '@causa/runtime/nestjs';
-import { PubSubPublisher } from '../../pubsub/index.js';
-import { SpannerEntityManager } from '../../spanner/index.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<SpannerTransaction> {
-    readonly entityManager: SpannerEntityManager;
-    readonly publisher: PubSubPublisher;
-    private readonly logger;
-    /**
-     * Creates a new {@link SpannerPubSubTransactionRunner}.
-     *
-     * @param entityManager The {@link SpannerEntityManager} to use for the transaction.
-     * @param publisher The {@link PubSubPublisher} to use for the transaction.
-     * @param logger The {@link Logger} to use.
-     */
-    constructor(entityManager: SpannerEntityManager, publisher: PubSubPublisher, logger: Logger);
-    run<T>(runFn: (transaction: SpannerTransaction) => Promise<T>): Promise<[T]>;
-}

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

@@ -1,69 +0,0 @@
-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);
-};
-var SpannerPubSubTransactionRunner_1;
-import { BufferEventTransaction, TransactionRunner } from '@causa/runtime';
-import { Logger } from '@causa/runtime/nestjs';
-import { Injectable } from '@nestjs/common';
-import { PubSubPublisher } from '../../pubsub/index.js';
-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.
- */
-let SpannerPubSubTransactionRunner = SpannerPubSubTransactionRunner_1 = class SpannerPubSubTransactionRunner extends TransactionRunner {
-    entityManager;
-    publisher;
-    logger;
-    /**
-     * Creates a new {@link SpannerPubSubTransactionRunner}.
-     *
-     * @param entityManager The {@link SpannerEntityManager} to use for the transaction.
-     * @param publisher The {@link PubSubPublisher} to use for the transaction.
-     * @param logger The {@link Logger} to use.
-     */
-    constructor(entityManager, publisher, logger) {
-        super();
-        this.entityManager = entityManager;
-        this.publisher = publisher;
-        this.logger = logger;
-        this.logger.setContext(SpannerPubSubTransactionRunner_1.name);
-    }
-    async run(runFn) {
-        this.logger.info('Creating a Spanner Pub/Sub transaction.');
-        const { result, eventTransaction } = await this.entityManager.transaction(async (dbTransaction) => {
-            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 SpannerTransaction(stateTransaction, eventTransaction);
-            try {
-                const result = await runFn(transaction);
-                this.logger.info('Committing the Spanner transaction.');
-                return { result, eventTransaction };
-            }
-            catch (error) {
-                await throwRetryableInTransactionIfNeeded(error);
-                throw error;
-            }
-        });
-        this.logger.info('Publishing Pub/Sub events.');
-        await eventTransaction.commit();
-        return [result];
-    }
-};
-SpannerPubSubTransactionRunner = SpannerPubSubTransactionRunner_1 = __decorate([
-    Injectable(),
-    __metadata("design:paramtypes", [SpannerEntityManager,
-        PubSubPublisher,
-        Logger])
-], SpannerPubSubTransactionRunner);
-export { SpannerPubSubTransactionRunner };

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

@@ -1,20 +0,0 @@
-import type { FindReplaceStateTransaction } from '@causa/runtime';
-import type { Type } from '@nestjs/common';
-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: SpannerReadWriteTransaction;
-    /**
-     * Creates a new {@link SpannerStateTransaction}.
-     *
-     * @param entityManager The {@link SpannerEntityManager} to use to access entities in the state.
-     * @param transaction The {@link SpannerReadWriteTransaction} to use for the transaction.
-     */
-    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-state-transaction.js

@@ -1,35 +0,0 @@
-import { SpannerEntityManager, } from '../spanner/index.js';
-/**
- * A {@link FindReplaceStateTransaction} that uses Spanner for state storage.
- */
-export class SpannerStateTransaction {
-    entityManager;
-    transaction;
-    /**
-     * Creates a new {@link SpannerStateTransaction}.
-     *
-     * @param entityManager The {@link SpannerEntityManager} to use to access entities in the state.
-     * @param transaction The {@link SpannerReadWriteTransaction} to use for the transaction.
-     */
-    constructor(entityManager, transaction) {
-        this.entityManager = entityManager;
-        this.transaction = transaction;
-    }
-    async replace(entity) {
-        await this.entityManager.replace(entity, { transaction: this.transaction });
-    }
-    async deleteWithSameKeyAs(type, key) {
-        const primaryKey = this.entityManager.getPrimaryKey(key, type);
-        await this.entityManager.delete(type, primaryKey, {
-            transaction: this.transaction,
-            includeSoftDeletes: true,
-        });
-    }
-    async findOneWithSameKeyAs(type, entity) {
-        const primaryKey = this.entityManager.getPrimaryKey(entity, type);
-        return await this.entityManager.findOneByKey(type, primaryKey, {
-            transaction: this.transaction,
-            includeSoftDeletes: true,
-        });
-    }
-}

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

@@ -1,16 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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;
-    }
-}