ClsPluginModule Error

[PazminoJose]

When I register the ClsModule in app.module.ts like in the documentation:

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    PrismaModule,
    ClsModule.forRoot({
      plugins: [
        new ClsPluginTransactional({
          imports: [PrismaModule],
          adapter: new TransactionalAdapterPrisma({
            prismaInjectionToken: PrismaClient
          })
        })
      ]
    }),

It gives the following error

 Nest can't resolve dependencies of the Symbol(TRANSACTION_CONNECTION) (?). Please make sure that the argument t at index [0] is available in the ClsPluginModule context.

Potential solutions:
- Is ClsPluginModule a valid NestJS module?
- If t is a provider, is it part of the current ClsPluginModule?
- If t is exported from a separate @Module, is that module imported within ClsPluginModule?
  @Module({
    imports: [ /* the Module containing t */ ]
  })

In my prisma module I have something like this:
prisma.module.ts

import { Global, Module } from "@nestjs/common";
import { PrismaService } from "./prisma.service";

@Global()
@Module({
  providers: [PrismaService],
  exports: [PrismaService]
})
export class PrismaModule {}

prisma.service.ts

import { Global, Module } from "@nestjs/common";
import { PrismaService } from "./prisma.service";

@Global()
@Module({
  providers: [PrismaService],
  exports: [PrismaService]
})
export class PrismaModule {}

I don't really know which problem is, if someone could give any clue I'd appreciate.

[Papooch]

Before going any further, please see if you're on the latest versions of nestjs-cls, @nestjs-cls/transactional and @nestjs-cls/transactional-adapter-prisma. There might have been some inconsistencies in the implementation in the early releases.

If that does not help, I'd like to ask you to share a minimal reproduction so I can investigate.

[PazminoJose]

All dependencies are in last version except reflect-metadata because it conflict with some other nest dependencies Here is a reproduction example it has all the dependencies that I use in a large project where i'm implementing @nestjs-cls/transactional but not all are used, still it throw the same error just starting the project

[Papooch]

@PazminoJose Thank you for the reproduction, I have tried it locally and now I see where the problem is.

In your PrismaModule, you're providing the PrimsaService, which is an extended PrismaClient.
You pass PrismaClient as prismaInjectionToken to the TransactionalAdapterPrisma, but there is nothing provided under the PrismaClient injection token (which is the "argument t at index [0]").

So the fix to your problem is the following simple change:

 adapter: new TransactionalAdapterPrisma({
-  prismaInjectionToken: PrismaClient
+  prismaInjectionToken: PrismaService
 })

I'll go ahead and clarify it in the docs so it doesn't confuse people.

[PazminoJose]

Oh sorry my bad, I followed the nestjs documentation about prisma so i didn't think about that detail, thank you for your help.

[OleksiiMandrichenko]

Hi guys, I have the exact same error message as you but using the nestjs-kysely package.
I just can't figure out if I used the correct 'injection token' or what I did wrong...

ERROR [ExceptionHandler] Nest can't resolve dependencies of the Symbol(TRANSACTION_CONNECTION) (?). Please make sure that the argument "pg" at index [0] is available in the ClsPluginModule context.

Potential solutions:
- Is ClsPluginModule a valid NestJS module?
- If "pg" is a provider, is it part of the current ClsPluginModule?
- If "pg" is exported from a separate @Module, is that module imported within ClsPluginModule?
  @Module({
    imports: [ /* the Module containing "pg" */ ]
  })

part of app.module.ts imports section looks like:

    DatabaseModule,
    ClsModule.forRoot({
      global: true,
      plugins: [
        new ClsPluginTransactional({
          imports: [
            // module in which Kysely is provided
            DatabaseModule,
          ],
          adapter: new TransactionalAdapterKysely({
            // the injection token of the Kysely client instance
            kyselyInstanceToken: 'pg',
          }),
        }),
      ],
    }),

and in database.module.ts looks like:

import { KyselyModule } from 'nestjs-kysely';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { PostgresDialect } from 'kysely';
import { Pool } from 'pg';
import { Module } from '@nestjs/common';
import { IConfigService, PostgresConfig } from '../config/config.interface';
import { DatabaseLoggerService } from '../logger/database.logger.service';
import { LoggerModule } from '../logger/logger.module';

@Module({
 imports: [
   KyselyModule.forRootAsync({
     namespace: 'pg',
     imports: [ConfigModule, LoggerModule],
     inject: [ConfigService, DatabaseLoggerService],
     useFactory: (
       configService: ConfigService<IConfigService, true>,
       databaseLoggerService: DatabaseLoggerService,
     ) => ({
       dialect: new PostgresDialect({
         pool: new Pool({
           ...configService.get<PostgresConfig>('postgres'),
         }),
       }),
       log: databaseLoggerService.log,
     }),
   }),
 ],
 exports: [KyselyModule],
})
export class DatabaseModule {}

I'm new to in nestjs and have already spent two days trying to figure out how to make it work, so any help would be greatly appreciated

[PazminoJose]

As shown in the correct answer, my mistake was using the wrong class. In that case I should use my PrismaService which extends the client that provides the connection, the PrismaService looks like this:

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit {
  async onModuleInit() {
    await this.$connect();
  }
}

Doesn't your DatabaseModule have a service or a class that exposes the connection client?

[Papooch]

Hi, it seems like you're using the nestjs-kysley package. I have not used that one, but it seems that in order to inject the Kysely instance, you need to use the @InjectKysely decorator.

@Controller()
export class AppController {
  constructor(
    @InjectKysely('mysql') private readonly mysql: Kysely<unknown>,

This makes things a little bit complicated, because the library doesn't expose the injection token directly.

However, looking at the implementation of InjectKysely, we can see that it creates a new injection token by passing the namespace name to a function:

export const InjectKysely = (namespace?: string) => Inject(KYSELY_MODULE_CONNECTION_TOKEN(namespace));

This means, the token used to inject the Kysely instance is equal to KYSELY_MODULE_CONNECTION_TOKEN(namespace).

Therefore, in your TransactionalAdapterKysely, you should use:

 adapter: new TransactionalAdapterKysely({
   // the injection token of the Kysely client instance
   kyselyInstanceToken: KYSELY_MODULE_CONNECTION_TOKEN("pg"),
}),

[OleksiiMandrichenko]

Thank you guys so much! KYSELY_MODULE_CONNECTION_TOKEN(namespace) works like a charm
I suspected that I needed to find and use exposed service, but I couldn't find its name. I tried reading the source code for nestjs-kysely but I couldn't find anything suitable on my own.
Thanks a lot for KYSELY_MODULE_CONNECTION_TOKEN! I may have even tried substituting it but didn't realize I needed to add ("pg") at the end.

Thanks a lot again 🙏