test(transactional): added test for extra providers in custom transactional adapters

Author: Anurag9977

docs/docs/06_plugins/01_available-plugins/01-transactional/99-creating-custom-adapter.md

@@ -125,9 +125,11 @@ As seen above, we'll need to define the following types:
 While the adapter itself can be any object that implements the `TransactionalAdapter` interface, we'll create a class that implements it.
 
 ```ts
-export class MyTransactionalAdapterKnex
-    implements TransactionalAdapter<Knex, Knex, Knex.TransactionConfig>
-{
+export class MyTransactionalAdapterKnex implements TransactionalAdapter<
+    Knex,
+    Knex,
+    Knex.TransactionConfig
+> {
     // implement the property for the connection token
     connectionToken: any;
 
@@ -147,6 +149,7 @@ export class MyTransactionalAdapterKnex
     ) {
         this.connectionToken = myKnexInstanceToken;
         this.defaultTxOptions = defaultTxOptions;
+        this.extraProviderTokens = extraProviderTokens;
     }
 
     //
@@ -211,8 +214,8 @@ ClsModule.forRoot({
             // highlight-start
             adapter: new MyTransactionalAdapterKnex({
                 connectionToken: KNEX_TOKEN,
-                defaultTxOptions: { isolationLevel: 'serializable' }
-                extraProviderTokens: [SomeExtraProvider]
+                defaultTxOptions: { isolationLevel: 'serializable' },
+                extraProviderTokens: [SomeExtraProvider],
             }),
             // highlight-end
         }),

packages/transactional/src/lib/interfaces.ts

@@ -33,7 +33,7 @@ export interface MergedTransactionalAdapterOptions<
 
 export type TransactionalOptionsAdapterFactory<TConnection, TTx, TOptions> = (
     connection: TConnection,
-    extraProviders?: any[],
+    extraProviders: any[],
 ) => TransactionalAdapterOptions<TTx, TOptions>;
 
 export type OptionalLifecycleHooks = Partial<
@@ -82,7 +82,8 @@ export interface TransactionalAdapter<
     /**
      * An array of extra tokens to be provided to the adapter.
      * 
-     * To inject custom providers to the adapter 
+     * To inject custom providers to a transactional adapter
+     * which can be used to perform additional logic within the transactions
 
      */
     extraProviderTokens?: any[];

packages/transactional/src/lib/plugin-transactional.ts

@@ -35,12 +35,18 @@ export class ClsPluginTransactional extends ClsPluginBase {
             },
             {
                 provide: TRANSACTIONAL_ADAPTER_OPTIONS,
-                inject: [TRANSACTION_CONNECTION],
+                inject: [
+                    TRANSACTION_CONNECTION,
+                    ...(options.adapter.extraProviderTokens ?? []),
+                ],
                 useFactory: (
                     connection: any,
+                    ...extraProviders: any[]
                 ): MergedTransactionalAdapterOptions<any, any> => {
-                    const adapterOptions =
-                        options.adapter.optionsFactory(connection);
+                    const adapterOptions = options.adapter.optionsFactory(
+                        connection,
+                        extraProviders,
+                    );
                     return {
                         ...adapterOptions,
                         ...this.bindLifecycleHooks(options),

packages/transactional/test/extra-providers.spec.ts

@@ -0,0 +1,138 @@
+import { ClsModule } from 'nestjs-cls';
+import {
+    ClsPluginTransactional,
+    TransactionalAdapter,
+    TransactionHost,
+} from '../src';
+import { Injectable, Module } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+
+const MOCK_TOKEN = 'MOCK_TOKEN';
+// --- EXTRA SERVICE AND MODULE ---
+@Injectable()
+export class MyProviderService {
+    private value: string = 'initial value';
+
+    getValue() {
+        return this.value;
+    }
+    setValue(newValue: string) {
+        this.value = newValue;
+    }
+}
+
+@Module({
+    providers: [MyProviderService],
+    exports: [MyProviderService],
+})
+export class MyProviderModule {}
+
+// --- CUSTOM TRANSACTIONAL ADAPTER ---
+interface CustomTransactionalAdapterOptions {
+    txToken: any;
+    defaultTxOptions?: any;
+    extraProviderTokens?: any[];
+}
+
+export class MyCustomTransactionalAdapter implements TransactionalAdapter<
+    any,
+    any,
+    any
+> {
+    connectionToken: any;
+    defaultTxOptions?: any;
+    extraProviderTokens?: any[];
+
+    constructor(options: CustomTransactionalAdapterOptions) {
+        this.connectionToken = options.txToken;
+        this.defaultTxOptions = options.defaultTxOptions;
+        this.extraProviderTokens = options.extraProviderTokens;
+    }
+
+    optionsFactory(
+        _connection: any,
+        [extraProviders]: [MyProviderService] | any[],
+    ) {
+        return {
+            wrapWithTransaction: async (
+                _options: any,
+                fn: (...args: any[]) => Promise<any>,
+                _setTx: (tx?: any) => void,
+            ) => {
+                const result = await fn();
+                console.log('Accessing Extra Provider instance');
+                extraProviders.setValue('after test');
+                return result;
+            },
+            getFallbackInstance: () => null,
+        };
+    }
+}
+
+// --- APPLICATION LOGIC (REPO & SERVICE) ---
+@Injectable()
+class CallingService {
+    constructor(
+        private readonly txHost: TransactionHost<MyCustomTransactionalAdapter>,
+    ) {}
+
+    async mockTransaction() {
+        console.log('Before Transaction');
+        await this.txHost.withTransaction(async () => {
+            console.log('In Transaction');
+        });
+    }
+}
+
+@Module({
+    providers: [
+        {
+            provide: MOCK_TOKEN,
+            useValue: 'MOCK_TOKEN',
+        },
+    ],
+    exports: [MOCK_TOKEN],
+})
+export class MockModule {}
+
+@Module({
+    imports: [
+        MockModule,
+        MyProviderModule,
+        ClsModule.forRoot({
+            plugins: [
+                new ClsPluginTransactional({
+                    imports: [MockModule, MyProviderModule],
+                    adapter: new MyCustomTransactionalAdapter({
+                        txToken: MOCK_TOKEN,
+                        defaultTxOptions: {},
+                        extraProviderTokens: [MyProviderService],
+                    }),
+                }),
+            ],
+        }),
+    ],
+    providers: [CallingService],
+})
+class AppModule {}
+
+// --- TEST SUITE ---
+describe('Custom Transactional Adapter With Custom Provider', () => {
+    let module: TestingModule;
+    let customProviderService: MyProviderService;
+    let callingService: CallingService;
+    beforeEach(async () => {
+        module = await Test.createTestingModule({
+            imports: [AppModule],
+        }).compile();
+        await module.init();
+        customProviderService = module.get(MyProviderService);
+        callingService = module.get(CallingService);
+        customProviderService.setValue('before test');
+    });
+
+    it('should use the injected custom provider instance and return the updated value from the transaction method', async () => {
+        await callingService.mockTransaction();
+        expect(customProviderService.getValue()).toBe('after test');
+    });
+});