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

package/dist/testing/google-app-fixture.d.ts

@@ -1,191 +0,0 @@
-import type { VersionedEntity } from '@causa/runtime';
-import { type MakeTestAppFactoryOptions } from '@causa/runtime/nestjs/testing';
-import { Database, Spanner } from '@google-cloud/spanner';
-import type { INestApplication, NestApplicationOptions, Type } from '@nestjs/common';
-import { CollectionReference } from 'firebase-admin/firestore';
-import { Test } from 'supertest';
-import TestAgent from 'supertest/lib/agent.js';
-import { AuthUsersFixture } from '../identity-platform/testing.js';
-import { type EventRequester, PubSubFixture } from '../pubsub/testing/index.js';
-import { SpannerEntityManager, type SpannerKey } from '../spanner/index.js';
-/**
- * Describes an entity to fetch using the {@link SpannerEntityManager}.
- * Used by expect methods in {@link GoogleAppFixture}.
- */
-type EntityToFetch<T extends object> = {
-    /**
-     * The type of entity to fetch.
-     */
-    type: Type<T>;
-    /**
-     * The ID of the entity to fetch.
-     */
-    id: string | SpannerKey;
-    /**
-     * Whether to include soft-deleted results when fetching the entity.
-     * See {@link SpannerEntityManager.findOneByKeyOrFail} options.
-     */
-    includeSoftDeletes?: boolean;
-};
-/**
- * Describes tests to run on a versioned entity stored in Spanner.
- */
-type VersionedEntityTests<T extends object> = {
-    /**
-     * The expected entity after mutation.
-     * It is checked against the actual entity in the database using `toEqual`, which means it can contain matchers.
-     * A function can be provided to generate the expected entity from the actual entity.
-     */
-    expectedEntity: ((actual: T) => T) | T;
-    /**
-     * If set, checks that an event has been published to the corresponding Pub/Sub topic with the entity as `data`.
-     */
-    expectedEvent?: {
-        /**
-         * The name of the topic.
-         */
-        topic: string;
-        /**
-         * The `name` of the expected published event.
-         */
-        name: string;
-        /**
-         * Attributes expected to have been set on the published event.
-         */
-        attributes?: Record<string, string>;
-    };
-    /**
-     * If set, the passed object is checked to be equal to a "plain object" (e.g. with `Date`s converted to `string`s)
-     * version of the fetched entity.
-     * This can contain a parsed HTTP response body which is expected to return the entity.
-     *
-     * {@link serializeAsJavaScriptObject} is used to serialize the fetched entity.
-     */
-    matchesHttpResponse?: object;
-};
-/**
- * A fixture for testing a NestJS application that uses Google Cloud Platform services.
- *
- * It manages the setup and teardown of resources in GCP emulators, and provides utilities for testing versioned
- * entities.
- */
-export declare class GoogleAppFixture {
-    readonly app: INestApplication;
-    readonly spanner: Spanner;
-    readonly database: Database;
-    readonly entityManager: SpannerEntityManager;
-    readonly pubSub: PubSubFixture;
-    readonly users: AuthUsersFixture;
-    readonly request: TestAgent<Test>;
-    readonly pubSubRequest: EventRequester;
-    readonly entities: Type[];
-    readonly firestoreDocuments: Type[];
-    /**
-     * Creates a new {@link GoogleAppFixture} instance.
-     *
-     * @param app The NestJS application.
-     * @param spanner The {@link Spanner} client managed by the fixture.
-     * @param database The temporary Spanner database.
-     * @param entityManager The {@link SpannerEntityManager} for the temporary database.
-     * @param pubSub The {@link PubSubFixture} managing temporary topics.
-     * @param users The {@link AuthUsersFixture}.
-     * @param request The {@link SuperTest} instance for the NestJS application.
-     * @param pubSubRequest The {@link EventRequester} to make requests to Pub/Sub push endpoints in the application.
-     * @param entities The entities to clear from the database when calling {@link GoogleAppFixture.clear}.
-     * @param firestoreDocuments The Firestore documents to clear when calling {@link GoogleAppFixture.clear}.
-     */
-    private constructor();
-    /**
-     * Returns the temporary Firestore collection (as set up by the fixture) for a given document type.
-     *
-     * @param document The type of document to get the collection for.
-     * @returns The Firestore collection.
-     */
-    firestoreCollection<T>(document: Type<T>): CollectionReference<T>;
-    /**
-     * Runs a test on a versioned entity, checking that it has been mutated as expected.
-     * Optionally, checks that an event has been published to the corresponding Pub/Sub topic.
-     * Also, a serialized version of the entity (e.g. an HTTP response) can be checked against the expected entity.
-     *
-     * @param entity Describes the entity to fetch using the {@link SpannerEntityManager}.
-     * @param tests The tests to run on the entity and its event.
-     * @returns The entity fetched from the database.
-     */
-    expectMutatedVersionedEntity<T extends Pick<VersionedEntity, 'updatedAt'>>(entity: EntityToFetch<T>, tests: VersionedEntityTests<T>): Promise<T>;
-    /**
-     * Ensures the specified entity has not been mutated.
-     * Optionally, checks that no event has been published to the corresponding Pub/Sub topic.
-     * Also, a serialized version of the entity (e.g. an HTTP response) can be checked against the expected entity.
-     *
-     * @param entity Describes the entity to fetch using the {@link SpannerEntityManager}.
-     * @param tests The tests to run on the entity.
-     */
-    expectNonMutatedVersionedEntity<T extends Pick<VersionedEntity, 'updatedAt'>>(entity: EntityToFetch<T>, tests: Omit<VersionedEntityTests<T>, 'expectedEvent'> & {
-        expectedEntity: object;
-        /**
-         * If set, checks that no event has been published to the corresponding Pub/Sub topic.
-         */
-        expectNoEventInTopic?: string;
-    }): Promise<void>;
-    /**
-     * Clears all entities from the test database.
-     *
-     * The tables to clear should be specified in the `entities` property of the options passed to
-     * {@link GoogleAppFixture.create}.
-     */
-    clearSpanner(): Promise<void>;
-    /**
-     * Clears all documents from the test Firestore collections.
-     *
-     * The collections to clear should be specified in the `firestoreDocuments` property of the options passed to
-     * {@link GoogleAppFixture.create}.
-     */
-    clearFirestore(): Promise<void>;
-    /**
-     * Clears all entities from the test database and all documents from the test Firestore collections.
-     * Also clears all messages read from the test Pub/Sub topics up to now.
-     *
-     * This does **not** delete Identity Platform users, which are only deleted when calling {
-     * @link GoogleAppFixture.delete}.
-     */
-    clear(): Promise<void>;
-    /**
-     * Deletes all resources created by the fixture.
-     */
-    delete(): Promise<void>;
-    /**
-     * Creates a NestJS application using the specified module, and sets up the fixture.
-     *
-     * @param appModule The NestJS module to create the application from.
-     * @param options Options when creating the GCP resources for the fixture.
-     * @returns The {@link GoogleAppFixture}.
-     */
-    static create(appModule: any, options?: {
-        /**
-         * Temporary Pub/Sub topics to create using the {@link PubSubFixture}.
-         */
-        pubSubTopics?: Record<string, Type>;
-        /**
-         * Temporary Firestore collections to create and to clear during teardown.
-         */
-        firestoreDocuments?: Type[];
-        /**
-         * Spanner entities to clear during teardown.
-         */
-        entities?: Type[];
-        /**
-         * Options for the {@link makeTestAppFactory} function.
-         */
-        appFactoryOptions?: MakeTestAppFactoryOptions;
-        /**
-         * Options passed to the NestJS application factory.
-         */
-        nestApplicationOptions?: NestApplicationOptions;
-        /**
-         * Whether the `AppCheckGuard` should be disabled.
-         * Defaults to `true`.
-         */
-        disableAppCheck?: boolean;
-    }): Promise<GoogleAppFixture>;
-}
-export {};

package/dist/testing/google-app-fixture.js

@@ -1,200 +0,0 @@
-import { createApp } from '@causa/runtime/nestjs';
-import { makeTestAppFactory, } from '@causa/runtime/nestjs/testing';
-import { serializeAsJavaScriptObject } from '@causa/runtime/testing';
-import { Database, Spanner } from '@google-cloud/spanner';
-import { CollectionReference } from 'firebase-admin/firestore';
-import supertest, { Test } from 'supertest';
-import TestAgent from 'supertest/lib/agent.js';
-import { overrideAppCheck } from '../app-check/testing.js';
-import { overrideFirebaseApp } from '../firebase/testing.js';
-import { clearFirestoreCollection, getFirestoreCollectionFromModule, overrideFirestoreCollections, } from '../firestore/testing.js';
-import { AuthUsersFixture } from '../identity-platform/testing.js';
-import { PubSubFixture, makePubSubRequester, } from '../pubsub/testing/index.js';
-import { SpannerEntityManager } from '../spanner/index.js';
-import { createDatabase, overrideDatabase } from '../spanner/testing.js';
-/**
- * A fixture for testing a NestJS application that uses Google Cloud Platform services.
- *
- * It manages the setup and teardown of resources in GCP emulators, and provides utilities for testing versioned
- * entities.
- */
-export class GoogleAppFixture {
-    app;
-    spanner;
-    database;
-    entityManager;
-    pubSub;
-    users;
-    request;
-    pubSubRequest;
-    entities;
-    firestoreDocuments;
-    /**
-     * Creates a new {@link GoogleAppFixture} instance.
-     *
-     * @param app The NestJS application.
-     * @param spanner The {@link Spanner} client managed by the fixture.
-     * @param database The temporary Spanner database.
-     * @param entityManager The {@link SpannerEntityManager} for the temporary database.
-     * @param pubSub The {@link PubSubFixture} managing temporary topics.
-     * @param users The {@link AuthUsersFixture}.
-     * @param request The {@link SuperTest} instance for the NestJS application.
-     * @param pubSubRequest The {@link EventRequester} to make requests to Pub/Sub push endpoints in the application.
-     * @param entities The entities to clear from the database when calling {@link GoogleAppFixture.clear}.
-     * @param firestoreDocuments The Firestore documents to clear when calling {@link GoogleAppFixture.clear}.
-     */
-    constructor(app, spanner, database, entityManager, pubSub, users, request, pubSubRequest, entities, firestoreDocuments) {
-        this.app = app;
-        this.spanner = spanner;
-        this.database = database;
-        this.entityManager = entityManager;
-        this.pubSub = pubSub;
-        this.users = users;
-        this.request = request;
-        this.pubSubRequest = pubSubRequest;
-        this.entities = entities;
-        this.firestoreDocuments = firestoreDocuments;
-    }
-    /**
-     * Returns the temporary Firestore collection (as set up by the fixture) for a given document type.
-     *
-     * @param document The type of document to get the collection for.
-     * @returns The Firestore collection.
-     */
-    firestoreCollection(document) {
-        return getFirestoreCollectionFromModule(this.app, document);
-    }
-    /**
-     * Runs a test on a versioned entity, checking that it has been mutated as expected.
-     * Optionally, checks that an event has been published to the corresponding Pub/Sub topic.
-     * Also, a serialized version of the entity (e.g. an HTTP response) can be checked against the expected entity.
-     *
-     * @param entity Describes the entity to fetch using the {@link SpannerEntityManager}.
-     * @param tests The tests to run on the entity and its event.
-     * @returns The entity fetched from the database.
-     */
-    async expectMutatedVersionedEntity(entity, tests) {
-        const storedEntity = await this.entityManager.findOneByKeyOrFail(entity.type, entity.id, { includeSoftDeletes: entity.includeSoftDeletes });
-        const expectedEntity = typeof tests.expectedEntity === 'function'
-            ? tests.expectedEntity(storedEntity)
-            : tests.expectedEntity;
-        expect(storedEntity).toEqual(expectedEntity);
-        const { expectedEvent } = tests;
-        if (expectedEvent) {
-            await this.pubSub.expectEventInTopic(expectedEvent.topic, {
-                id: expect.any(String),
-                name: expectedEvent.name,
-                producedAt: storedEntity.updatedAt,
-                data: storedEntity,
-            }, { attributes: expectedEvent.attributes });
-        }
-        if (tests.matchesHttpResponse) {
-            const expectedResponse = await serializeAsJavaScriptObject(storedEntity);
-            expect(tests.matchesHttpResponse).toEqual(expectedResponse);
-        }
-        return storedEntity;
-    }
-    /**
-     * Ensures the specified entity has not been mutated.
-     * Optionally, checks that no event has been published to the corresponding Pub/Sub topic.
-     * Also, a serialized version of the entity (e.g. an HTTP response) can be checked against the expected entity.
-     *
-     * @param entity Describes the entity to fetch using the {@link SpannerEntityManager}.
-     * @param tests The tests to run on the entity.
-     */
-    async expectNonMutatedVersionedEntity(entity, tests) {
-        const storedEntity = await this.entityManager.findOneByKeyOrFail(entity.type, entity.id, { includeSoftDeletes: entity.includeSoftDeletes });
-        expect(storedEntity).toEqual(tests.expectedEntity);
-        if (tests.expectNoEventInTopic) {
-            await this.pubSub.expectNoMessageInTopic(tests.expectNoEventInTopic);
-        }
-        if (tests.matchesHttpResponse) {
-            const expectedResponse = await serializeAsJavaScriptObject(storedEntity);
-            expect(tests.matchesHttpResponse).toEqual(expectedResponse);
-        }
-    }
-    /**
-     * Clears all entities from the test database.
-     *
-     * The tables to clear should be specified in the `entities` property of the options passed to
-     * {@link GoogleAppFixture.create}.
-     */
-    async clearSpanner() {
-        await this.entityManager.transaction(async (transaction) => {
-            for (const entity of this.entities) {
-                await this.entityManager.clear(entity, { transaction });
-            }
-        });
-    }
-    /**
-     * Clears all documents from the test Firestore collections.
-     *
-     * The collections to clear should be specified in the `firestoreDocuments` property of the options passed to
-     * {@link GoogleAppFixture.create}.
-     */
-    async clearFirestore() {
-        await Promise.all(this.firestoreDocuments.map((d) => clearFirestoreCollection(this.firestoreCollection(d))));
-    }
-    /**
-     * Clears all entities from the test database and all documents from the test Firestore collections.
-     * Also clears all messages read from the test Pub/Sub topics up to now.
-     *
-     * This does **not** delete Identity Platform users, which are only deleted when calling {
-     * @link GoogleAppFixture.delete}.
-     */
-    async clear() {
-        this.pubSub.clear();
-        await Promise.all([this.clearSpanner(), this.clearFirestore()]);
-    }
-    /**
-     * Deletes all resources created by the fixture.
-     */
-    async delete() {
-        await this.app.close();
-        await Promise.all([
-            this.users.deleteAll(),
-            this.pubSub.deleteAll(),
-            this.database.delete(),
-        ]);
-        this.spanner.close();
-    }
-    /**
-     * Creates a NestJS application using the specified module, and sets up the fixture.
-     *
-     * @param appModule The NestJS module to create the application from.
-     * @param options Options when creating the GCP resources for the fixture.
-     * @returns The {@link GoogleAppFixture}.
-     */
-    static async create(appModule, options = {}) {
-        const entities = options.entities ?? [];
-        const firestoreDocuments = options.firestoreDocuments ?? [];
-        const disableAppCheck = options.disableAppCheck ?? true;
-        const spanner = new Spanner();
-        const database = await createDatabase({ spanner });
-        const entityManager = new SpannerEntityManager(database);
-        const pubSubFixture = new PubSubFixture();
-        const overridePubSub = await pubSubFixture.createWithOverrider(options.pubSubTopics ?? {});
-        const usersFixture = new AuthUsersFixture();
-        const appFactoryOptions = options.appFactoryOptions ?? {};
-        const additionalOverrides = appFactoryOptions.overrides && !Array.isArray(appFactoryOptions.overrides)
-            ? [appFactoryOptions.overrides]
-            : (appFactoryOptions.overrides ?? []);
-        const app = await createApp(appModule, {
-            nestApplicationOptions: options.nestApplicationOptions,
-            appFactory: makeTestAppFactory({
-                ...appFactoryOptions,
-                overrides: [
-                    overrideDatabase(database),
-                    overridePubSub,
-                    overrideFirebaseApp,
-                    overrideFirestoreCollections(...firestoreDocuments),
-                    ...(disableAppCheck ? [overrideAppCheck] : []),
-                    ...additionalOverrides,
-                ],
-            }),
-        });
-        const request = supertest(app.getHttpServer());
-        const pubSubRequest = makePubSubRequester(app);
-        return new GoogleAppFixture(app, spanner, database, entityManager, pubSubFixture, usersFixture, request, pubSubRequest, entities, firestoreDocuments);
-    }
-}

package/dist/testing/index.d.ts

@@ -1 +0,0 @@
-export { GoogleAppFixture } from './google-app-fixture.js';

package/dist/testing/index.js

@@ -1 +0,0 @@
-export { GoogleAppFixture } from './google-app-fixture.js';

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

@@ -1,2 +0,0 @@
-export { SpannerPubSubTransactionModule } from './module.js';
-export { SpannerPubSubTransactionRunner } from './runner.js';

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

@@ -1,2 +0,0 @@
-export { SpannerPubSubTransactionModule } from './module.js';
-export { SpannerPubSubTransactionRunner } from './runner.js';

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

@@ -1,14 +0,0 @@
-import type { DynamicModule } from '@nestjs/common';
-/**
- * The module exposing the {@link SpannerPubSubTransactionRunner}.
- * This modules assumes that the `SpannerModule` and `PubSubPublisherModule` are available.
- */
-export declare 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(): DynamicModule;
-}

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