Nest.js Setup for decoupled Firestore Transactions

FirestoreTransactionAdapter.ts

export class FirebaseTransactionAdapter implements TransactionProviderPort {
    private readonly logger = new Logger(FirebaseTransactionAdapter.name);

    constructor(
        @Inject(Firestore.prototype.runTransaction)
        private readonly runTransaction: TransactionRunner,
    ) {
    }

    async executeTransaction(
        callback: () => Promise<void>
    ): Promise<Result<void, DeleteErrorTypes>> {
        try {
            // transcations triggered down the stream will now all run via the same transaction workload
            const result = await this.runTransaction(callback);
            return ok(result);
        } catch (e) {
            const msg = "Error executing transaction";
            this.logger.error(msg, e);
            return err(new WriteError(msg));
        }
    }
}

util.module.ts

const adminApp = admin.initializeApp();
let transaction: Transaction | undefined;

export type TransactionLambda = (transaction: Transaction) => Promise<void>;
export type TransactionRunner = (callback: TransactionLambda) => Promise<void>;

@Global()
@Module({
    providers: [
        {
            provide: Firestore,
            useValue: (() => {
                    // must be value and not factory so that settings is only being called once
                    const firestore = adminApp.firestore();
                    firestore.settings({ignoreUndefinedProperties: true,});
                    return firestore;
                }
            )()
        },
        {
            provide: Firestore.prototype.runTransaction,
            inject: [Firestore],
            useFactory: (firestore: Firestore) => {
                return async (updateFunction: TransactionLambda) => {
                    if(transaction) {
                        // if a transaction has already been triggered, just execute the lambda with existing transaction
                        await updateFunction(transaction);
                    } else {
                        // if this is the start of a transaction, start a new one... 
                        await firestore.runTransaction(async (t) => {
                            // ... reference the transaction object
                            transaction = t;
                            // execute the lambda
                            await updateFunction(transaction);
                            // unset the transaction reference
                            transaction = undefined;
                        });
                    }
                };
            }
        }
    ],
    exports: [
        Firestore.prototype.runTransaction,
        Firestore,
    ]
})
export class UtilModule {
}