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

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

@@ -0,0 +1,36 @@
+import type { Type } from '@nestjs/common';
+import type { CollectionReference } from 'firebase-admin/firestore';
+import type { SoftDeletedFirestoreCollectionMetadata } from './soft-deleted-collection.decorator.js';
+/**
+ * The Firestore collections that should be used to create document references for a given document type.
+ */
+export type FirestoreCollectionsForDocumentType<T> = {
+    /**
+     * The regular collection, where documents are stored when they are not deleted.
+     */
+    readonly activeCollection: CollectionReference<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.
+     */
+    readonly softDelete: ({
+        /**
+         * The collection where soft-deleted documents are stored.
+         */
+        collection: CollectionReference<T>;
+    } & Pick<SoftDeletedFirestoreCollectionMetadata, 'expirationDelay' | 'expirationField'>) | null;
+};
+/**
+ * A resolver that returns the Firestore collections for a given document type.
+ * This allows using the {@link FirestoreStateTransaction} in various contexts, such as in a NestJS module. It also
+ * enables testing with temporary collections.
+ */
+export interface FirestoreCollectionResolver {
+    /**
+     * Returns the Firestore collections for a given document type.
+     *
+     * @param documentType The type of document.
+     * @returns The Firestore collections for the given document type.
+     */
+    getCollectionsForType<T>(documentType: Type<T>): FirestoreCollectionsForDocumentType<T>;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/transaction/index.d.ts

@@ -1,5 +1,2 @@
 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,5 +1,2 @@
 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/index.d.ts

@@ -1,5 +1,7 @@
 export { SpannerOutboxEvent } from './event.js';
 export { SpannerOutboxTransactionModule } from './module.js';
+export * from './readonly-transaction.js';
 export { SpannerOutboxTransactionRunner } from './runner.js';
-export type { SpannerOutboxTransaction, SpannerOutboxTransactionOption, } from './runner.js';
 export { SpannerOutboxSender } from './sender.js';
+export { SpannerStateTransaction } from './state-transaction.js';
+export * from './transaction.js';

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

@@ -1,4 +1,7 @@
 export { SpannerOutboxEvent } from './event.js';
 export { SpannerOutboxTransactionModule } from './module.js';
+export * from './readonly-transaction.js';
 export { SpannerOutboxTransactionRunner } from './runner.js';
 export { SpannerOutboxSender } from './sender.js';
+export { SpannerStateTransaction } from './state-transaction.js';
+export * from './transaction.js';

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

@@ -0,0 +1,22 @@
+import type { ReadOnlyStateTransaction, ReadOnlyTransactionOption } from '@causa/runtime';
+import type { Type } from '@nestjs/common';
+import { SpannerEntityManager, type SpannerReadOnlyTransaction, type SpannerReadWriteTransaction } from '../../spanner/index.js';
+/**
+ * Option for a function that accepts a {@link SpannerReadOnlyStateTransaction}.
+ */
+export type SpannerReadOnlyStateTransactionOption = ReadOnlyTransactionOption<SpannerReadOnlyStateTransaction>;
+/**
+ * A {@link ReadOnlyStateTransaction} that uses Spanner for state storage.
+ */
+export declare class SpannerReadOnlyStateTransaction implements ReadOnlyStateTransaction {
+    readonly entityManager: SpannerEntityManager;
+    readonly spannerTransaction: SpannerReadWriteTransaction | SpannerReadOnlyTransaction;
+    /**
+     * Creates a new {@link SpannerReadOnlyStateTransaction}.
+     *
+     * @param entityManager The {@link SpannerEntityManager} to use to access entities in the state.
+     * @param spannerTransaction The {@link SpannerReadWriteTransaction} or {@link SpannerReadOnlyTransaction} to use.
+     */
+    constructor(entityManager: SpannerEntityManager, spannerTransaction: SpannerReadWriteTransaction | SpannerReadOnlyTransaction);
+    get<T extends object>(type: Type<T>, entity: Partial<T>): Promise<T | undefined>;
+}

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

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

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

@@ -1,28 +1,17 @@
-import { OutboxTransactionRunner, type OutboxEvent, type OutboxEventTransaction } from '@causa/runtime';
+import { OutboxTransactionRunner, type OutboxEvent, type OutboxEventTransaction, type ReadWriteTransactionOptions, type TransactionFn } from '@causa/runtime';
 import { Logger } from '@causa/runtime/nestjs';
 import type { Type } from '@nestjs/common';
 import { SpannerEntityManager } from '../../spanner/index.js';
-import { SpannerTransaction } from '../spanner-transaction.js';
+import { SpannerReadOnlyStateTransaction } from './readonly-transaction.js';
 import { SpannerOutboxSender } from './sender.js';
+import { SpannerOutboxTransaction } from './transaction.js';
 /**
- * A {@link SpannerTransaction} that uses an {@link OutboxEventTransaction}.
- */
-export type SpannerOutboxTransaction = SpannerTransaction<OutboxEventTransaction>;
-/**
- * Option for a function that accepts a {@link SpannerOutboxTransaction}.
- */
-export type SpannerOutboxTransactionOption = {
-    /**
-     * The transaction to use.
-     */
-    readonly transaction?: SpannerOutboxTransaction;
-};
-/**
- * An {@link OutboxTransactionRunner} that uses a {@link SpannerTransaction} to run transactions.
+ * An {@link OutboxTransactionRunner} that uses a {@link SpannerOutboxTransaction} to run transactions.
  * Events are stored in a Spanner table before being published.
  */
-export declare class SpannerOutboxTransactionRunner extends OutboxTransactionRunner<SpannerOutboxTransaction> {
+export declare class SpannerOutboxTransactionRunner extends OutboxTransactionRunner<SpannerOutboxTransaction, SpannerReadOnlyStateTransaction> {
     readonly entityManager: SpannerEntityManager;
     constructor(entityManager: SpannerEntityManager, outboxEventType: Type<OutboxEvent>, sender: SpannerOutboxSender, logger: Logger);
-    protected runStateTransaction<RT>(eventTransactionFactory: () => OutboxEventTransaction, runFn: (transaction: SpannerOutboxTransaction) => Promise<RT>): Promise<RT>;
+    protected runReadOnly<RT>(runFn: TransactionFn<SpannerReadOnlyStateTransaction, RT>): Promise<RT>;
+    protected runStateTransaction<RT>(eventTransactionFactory: () => OutboxEventTransaction, options: ReadWriteTransactionOptions, runFn: TransactionFn<SpannerOutboxTransaction, RT>): Promise<RT>;
 }

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

@@ -1,12 +1,13 @@
 import { OutboxTransactionRunner, } from '@causa/runtime';
 import { Logger } from '@causa/runtime/nestjs';
 import { SpannerEntityManager } from '../../spanner/index.js';
-import { SpannerStateTransaction } from '../spanner-state-transaction.js';
-import { SpannerTransaction } from '../spanner-transaction.js';
-import { throwRetryableInTransactionIfNeeded } from '../spanner-utils.js';
+import { SpannerReadOnlyStateTransaction } from './readonly-transaction.js';
 import { SpannerOutboxSender } from './sender.js';
+import { throwRetryableInTransactionIfNeeded } from './spanner-utils.js';
+import { SpannerStateTransaction } from './state-transaction.js';
+import { SpannerOutboxTransaction } from './transaction.js';
 /**
- * An {@link OutboxTransactionRunner} that uses a {@link SpannerTransaction} to run transactions.
+ * An {@link OutboxTransactionRunner} that uses a {@link SpannerOutboxTransaction} to run transactions.
  * Events are stored in a Spanner table before being published.
  */
 export class SpannerOutboxTransactionRunner extends OutboxTransactionRunner {
@@ -15,11 +16,17 @@ export class SpannerOutboxTransactionRunner extends OutboxTransactionRunner {
         super(outboxEventType, sender, logger);
         this.entityManager = entityManager;
     }
-    async runStateTransaction(eventTransactionFactory, runFn) {
+    async runReadOnly(runFn) {
+        return await this.entityManager.snapshot(async (dbTransaction) => {
+            const transaction = new SpannerReadOnlyStateTransaction(this.entityManager, dbTransaction);
+            return await runFn(transaction);
+        });
+    }
+    async runStateTransaction(eventTransactionFactory, options, runFn) {
         return await this.entityManager.transaction(async (dbTransaction) => {
             const stateTransaction = new SpannerStateTransaction(this.entityManager, dbTransaction);
             const eventTransaction = eventTransactionFactory();
-            const transaction = new SpannerTransaction(stateTransaction, eventTransaction);
+            const transaction = new SpannerOutboxTransaction(stateTransaction, eventTransaction, options.publishOptions);
             try {
                 return await runFn(transaction);
             }

package/dist/transaction/{spanner-utils.js → spanner-outbox/spanner-utils.js}

@@ -1,6 +1,6 @@
 import { TransactionOldTimestampError } from '@causa/runtime';
 import { setTimeout } from 'timers/promises';
-import { TemporarySpannerError } from '../spanner/index.js';
+import { TemporarySpannerError } from '../../spanner/index.js';
 /**
  * The delay, in milliseconds, over which a timestamp issue is deemed irrecoverable.
  */

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

@@ -0,0 +1,20 @@
+import type { StateTransaction } from '@causa/runtime';
+import type { Type } from '@nestjs/common';
+import { SpannerEntityManager, type SpannerReadWriteTransaction } from '../../spanner/index.js';
+import { SpannerReadOnlyStateTransaction } from './readonly-transaction.js';
+/**
+ * A {@link StateTransaction} that uses Spanner for state storage.
+ */
+export declare class SpannerStateTransaction extends SpannerReadOnlyStateTransaction implements StateTransaction {
+    readonly entityManager: SpannerEntityManager;
+    readonly spannerTransaction: SpannerReadWriteTransaction;
+    /**
+     * Creates a new {@link SpannerStateTransaction}.
+     *
+     * @param entityManager The {@link SpannerEntityManager} to use to access entities in the state.
+     * @param spannerTransaction The {@link SpannerReadWriteTransaction} to use for the transaction.
+     */
+    constructor(entityManager: SpannerEntityManager, spannerTransaction: SpannerReadWriteTransaction);
+    set<T extends object>(entity: T): Promise<void>;
+    delete<T extends object>(typeOrEntity: Type<T> | T, key?: Partial<T>): Promise<void>;
+}

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

@@ -0,0 +1,34 @@
+import { SpannerEntityManager, } from '../../spanner/index.js';
+import { SpannerReadOnlyStateTransaction } from './readonly-transaction.js';
+/**
+ * A {@link StateTransaction} that uses Spanner for state storage.
+ */
+export class SpannerStateTransaction extends SpannerReadOnlyStateTransaction {
+    entityManager;
+    spannerTransaction;
+    /**
+     * Creates a new {@link SpannerStateTransaction}.
+     *
+     * @param entityManager The {@link SpannerEntityManager} to use to access entities in the state.
+     * @param spannerTransaction The {@link SpannerReadWriteTransaction} to use for the transaction.
+     */
+    constructor(entityManager, spannerTransaction) {
+        super(entityManager, spannerTransaction);
+        this.entityManager = entityManager;
+        this.spannerTransaction = spannerTransaction;
+    }
+    async set(entity) {
+        await this.entityManager.replace(entity, {
+            transaction: this.spannerTransaction,
+        });
+    }
+    async delete(typeOrEntity, key) {
+        const type = (key === undefined ? typeOrEntity.constructor : typeOrEntity);
+        key ??= typeOrEntity;
+        const primaryKey = this.entityManager.getPrimaryKey(key, type);
+        await this.entityManager.delete(type, primaryKey, {
+            transaction: this.spannerTransaction,
+            includeSoftDeletes: true,
+        });
+    }
+}

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

@@ -0,0 +1,28 @@
+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 { SpannerStateTransaction } from './state-transaction.js';
+/**
+ * Option for a function that accepts a {@link SpannerOutboxTransaction}.
+ */
+export type SpannerOutboxTransactionOption = TransactionOption<SpannerOutboxTransaction>;
+/**
+ * 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 {
+    readonly stateTransaction: SpannerStateTransaction;
+    readonly eventTransaction: OutboxEventTransaction;
+    constructor(stateTransaction: SpannerStateTransaction, eventTransaction: OutboxEventTransaction, publishOptions?: PublishOptions);
+    /**
+     * The underlying {@link SpannerTransaction} used by the state transaction.
+     */
+    get spannerTransaction(): SpannerReadWriteTransaction;
+    /**
+     * The underlying {@link SpannerEntityManager} used by the state transaction.
+     */
+    get entityManager(): SpannerEntityManager;
+    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 | undefined>;
+    publish(topic: string, event: object, options?: PublishOptions): Promise<void>;
+}

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

@@ -0,0 +1,38 @@
+import { OutboxEventTransaction, Transaction, } from '@causa/runtime';
+import { SpannerEntityManager, } from '../../spanner/index.js';
+/**
+ * A {@link Transaction} that uses Spanner for state (and outbox) storage, and Pub/Sub for event publishing.
+ */
+export class SpannerOutboxTransaction extends Transaction {
+    stateTransaction;
+    eventTransaction;
+    constructor(stateTransaction, eventTransaction, publishOptions = {}) {
+        super(publishOptions);
+        this.stateTransaction = stateTransaction;
+        this.eventTransaction = eventTransaction;
+    }
+    /**
+     * The underlying {@link SpannerTransaction} used by the state transaction.
+     */
+    get spannerTransaction() {
+        return this.stateTransaction.spannerTransaction;
+    }
+    /**
+     * The underlying {@link SpannerEntityManager} used by the state transaction.
+     */
+    get entityManager() {
+        return this.stateTransaction.entityManager;
+    }
+    set(entity) {
+        return this.stateTransaction.set(entity);
+    }
+    delete(type, key) {
+        return this.stateTransaction.delete(type, key);
+    }
+    get(type, entity) {
+        return this.stateTransaction.get(type, entity);
+    }
+    publish(topic, event, options) {
+        return this.eventTransaction.publish(topic, event, options);
+    }
+}

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@causa/runtime-google",
-  "version": "0.39.1",
+  "version": "1.0.0-rc.1",
   "description": "An extension to the Causa runtime SDK (`@causa/runtime`), providing Google-specific features.",
-  "repository": "github:causa-io/runtime-typescript-google",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/causa-io/runtime-typescript-google.git"
+  },
   "license": "ISC",
   "type": "module",
   "engines": {
-    "node": ">=16"
+    "node": ">=20"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,49 +32,49 @@
     "test:cov": "npm run test -- --coverage"
   },
   "dependencies": {
-    "@causa/runtime": ">= 0.27.1 < 1.0.0",
-    "@google-cloud/precise-date": "^4.0.0",
-    "@google-cloud/pubsub": "^4.10.0",
-    "@google-cloud/spanner": "^7.18.1",
-    "@google-cloud/tasks": "^5.5.2",
-    "@grpc/grpc-js": "^1.12.6",
-    "@nestjs/common": "^11.0.11",
-    "@nestjs/config": "^4.0.1",
-    "@nestjs/core": "^11.0.11",
+    "@causa/runtime": ">= 1.0.0-rc",
+    "@google-cloud/precise-date": "^5.0.0",
+    "@google-cloud/pubsub": "^5.1.0",
+    "@google-cloud/spanner": "^8.0.0",
+    "@google-cloud/tasks": "^6.1.0",
+    "@grpc/grpc-js": "^1.13.4",
+    "@nestjs/common": "^11.1.3",
+    "@nestjs/config": "^4.0.2",
+    "@nestjs/core": "^11.1.3",
     "@nestjs/passport": "^11.0.5",
     "@nestjs/terminus": "^11.0.0",
     "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.1",
-    "express": "^5.0.1",
-    "firebase-admin": "^13.1.0",
+    "class-validator": "^0.14.2",
+    "express": "^5.1.0",
+    "firebase-admin": "^13.4.0",
     "jsonwebtoken": "^9.0.2",
     "passport-http-bearer": "^1.0.1",
-    "pino": "^9.6.0",
+    "pino": "^9.7.0",
     "reflect-metadata": "^0.2.2"
   },
   "devDependencies": {
-    "@nestjs/testing": "^11.0.11",
-    "@swc/core": "^1.11.7",
-    "@swc/jest": "^0.2.37",
-    "@tsconfig/node22": "^22.0.0",
-    "@types/jest": "^29.5.14",
-    "@types/jsonwebtoken": "^9.0.9",
-    "@types/node": "^22.13.9",
+    "@nestjs/testing": "^11.1.3",
+    "@swc/core": "^1.12.11",
+    "@swc/jest": "^0.2.39",
+    "@tsconfig/node22": "^22.0.2",
+    "@types/jest": "^30.0.0",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^22.16.2",
     "@types/passport-http-bearer": "^1.0.41",
-    "@types/supertest": "^6.0.2",
+    "@types/supertest": "^6.0.3",
     "@types/uuid": "^10.0.0",
-    "dotenv": "^16.4.7",
-    "eslint": "^9.21.0",
-    "eslint-config-prettier": "^10.0.2",
-    "eslint-plugin-prettier": "^5.2.3",
-    "jest": "^29.7.0",
-    "jest-extended": "^4.0.2",
+    "dotenv": "^17.1.0",
+    "eslint": "^9.30.1",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.5.1",
+    "jest": "^30.0.4",
+    "jest-extended": "^6.0.0",
     "rimraf": "^6.0.1",
-    "supertest": "^7.0.0",
-    "ts-jest": "^29.2.6",
+    "supertest": "^7.1.3",
+    "ts-jest": "^29.4.0",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.26.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.36.0",
     "uuid": "^11.1.0"
   }
 }

package/dist/pubsub/testing/index.d.ts

@@ -1,4 +0,0 @@
-export { PubSubFixture } from './fixture.js';
-export type { ReceivedPubSubEvent } from './fixture.js';
-export { makePubSubRequester } from './requester.js';
-export type { EventRequester, EventRequesterOptions } from './requester.js';

package/dist/pubsub/testing/index.js

@@ -1,2 +0,0 @@
-export { PubSubFixture } from './fixture.js';
-export { makePubSubRequester } from './requester.js';

package/dist/pubsub/testing/requester.d.ts

@@ -1,50 +0,0 @@
-import { type ObjectSerializer } from '@causa/runtime';
-import { type INestApplication } from '@nestjs/common';
-/**
- * Options when making a request to an endpoint handling Pub/Sub events using an {@link EventRequester}.
- */
-export type EventRequesterOptions = {
-    /**
-     * The attributes to add to the Pub/Sub message.
-     * Using `undefined` values allows removing the attributes set by default.
-     */
-    attributes?: Record<string, string | undefined>;
-    /**
-     * The expected status code when making the request.
-     * Default is `200`.
-     */
-    expectedStatus?: number;
-    /**
-     * The time to set as the publication time of the Pub/Sub message.
-     */
-    publishTime?: Date;
-};
-/**
- * A function that makes a query to an endpoint handling Pub/Sub events and tests the response.
- */
-export type EventRequester = (endpoint: string, event: object, options?: EventRequesterOptions) => Promise<void>;
-/**
- * Creates an {@link EventRequester} for a NestJS HTTP application handling Pub/Sub messages.
- * If the `event` passed to the {@link EventRequester} conforms to the `Event` interface (if it has `producedAt`, `name`
- * and / or `id` properties), the default attributes are set in the Pub/Sub message. Default attributes can be
- * overridden (or removed by passing `undefined`) using {@link EventRequesterOptions.attributes}.
- *
- * @param app The NestJS application handling events.
- * @param options Options when creating the requester.
- * @returns The {@link EventRequester}.
- */
-export declare function makePubSubRequester(app: INestApplication, options?: {
-    /**
-     * The prefix added to all routes handling events.
-     * Used when constructing the request to the HTTP application.
-     */
-    routePrefix?: string;
-    /**
-     * The serializer to use to serialize events.
-     */
-    serializer?: ObjectSerializer;
-    /**
-     * The default expected status code when making a request.
-     */
-    expectedStatus?: number;
-}): EventRequester;

package/dist/pubsub/testing/requester.js

@@ -1,53 +0,0 @@
-import { JsonObjectSerializer } from '@causa/runtime';
-import { HttpStatus } from '@nestjs/common';
-import supertest from 'supertest';
-import * as uuid from 'uuid';
-/**
- * Creates an {@link EventRequester} for a NestJS HTTP application handling Pub/Sub messages.
- * If the `event` passed to the {@link EventRequester} conforms to the `Event` interface (if it has `producedAt`, `name`
- * and / or `id` properties), the default attributes are set in the Pub/Sub message. Default attributes can be
- * overridden (or removed by passing `undefined`) using {@link EventRequesterOptions.attributes}.
- *
- * @param app The NestJS application handling events.
- * @param options Options when creating the requester.
- * @returns The {@link EventRequester}.
- */
-export function makePubSubRequester(app, options = {}) {
-    const request = supertest(app.getHttpServer());
-    const routePrefix = options.routePrefix ?? '';
-    const serializer = options.serializer ?? new JsonObjectSerializer();
-    return async (endpoint, event, requestOptions) => {
-        const messageId = uuid.v4();
-        const publishTime = (requestOptions?.publishTime ?? new Date()).toISOString();
-        const buffer = await serializer.serialize(event);
-        const data = buffer.toString('base64');
-        // Default attributes if the event conforms to the `Event` interface.
-        const defaultAttributes = {};
-        if ('producedAt' in event && event.producedAt instanceof Date) {
-            defaultAttributes.producedAt = event.producedAt.toISOString();
-        }
-        if ('name' in event && typeof event.name === 'string') {
-            defaultAttributes.eventName = event.name;
-        }
-        if ('id' in event && typeof event.id === 'string') {
-            defaultAttributes.eventId = event.id;
-        }
-        const attributes = { ...defaultAttributes, ...requestOptions?.attributes };
-        await request
-            .post(`${routePrefix}${endpoint}`)
-            .send({
-            message: {
-                messageId,
-                message_id: messageId,
-                publishTime,
-                publish_time: publishTime,
-                attributes,
-                data,
-            },
-            subscription: 'subscription',
-        })
-            .expect(requestOptions?.expectedStatus ??
-            options.expectedStatus ??
-            HttpStatus.OK);
-    };
-}