Is a repository pattern with generics possible?

[kevinvdburgt]

Is there a way to use generics for repository patterns using a base repository (example A), or should i do it just like example B, where i have to duplicate all the create, update, e.d. methods?

Example A

// src/repositories/UserRepository.ts
import { User, UserCreateInput } from "@prisma/client";
import { Service } from "typedi";
import PrismaRepository from "./base/PrismaRepository";

@Service()
class UserRepository extends PrismaRepository<User, UserCreateInput> { };

export default UserRepository;

// src/repositories/base/PrismaRepository.ts
import prisma from "../../library/prisma";

abstract class PrismaRepository<T, TC> {
  public async create(data: TC): Promise<T> {
    return await prisma.user.create({ // Is there a way to replace 'user' with a generic?
      data,
    });
  };
};

export default PrismaRepository;

Example B

import { User, UserCreateInput } from "@prisma/client";
import { Service } from "typedi";
import prisma from "../library/prisma";

@Service()
class UserRepository{
  public async create(data: UserCreateInput): Promise<User> {
    return await prisma.user.create({
      data,
    });
  };
};

export default UserRepository;

[ryands17]

Hey @kevinvdburgt 👋
Prisma is quite different from traditional ORM's in the case that it doesn't offser any way to inherit or extend methods as therer are no classes involved. You directly get the data in the form of a simple JavaScript object and not an instance of any class.

The example that you mentioned above, it unlikely with Prisma as you are trying to replace User with a generic. That would require a lot of efffort especially with TypeScript as it would need to know what data needs to be passed based on the model specified.

I have given a similar answer here on Slack which is quite similar to the pattern that you're following. Do give it a read and let me know if that answers your question :)

[nikolasburk]

Just for the record, here's a screenshot of the convo on Slack:

[mitsos1os]

Hi there!
Is Prisma in the same condition as stated above regarding service extendability?

I am considering a switch of a project to Prisma, but for example with 4-5 DB Entities that share a common CRUD model, having to create the same Service - Controller patter (Filter - Query, Create, Update, Delete) again and again, just to use the right prisma generated model, seems to me like it violates the DRY principle and also feels a bit unoptimal....

Having a generilization of some kind that would allow to reuse the same code feels more natural.
What do you think?

[ryands17]

@mitsos1os 👋

We will be introducing a CRUD wrapper soon so you can follow this request for more info: #5273

There's also a workaround for this mentioned in the above request, so it's entirely possible but TypeScript doesn't play well with dynamic models.

[mitsos1os]

Thanks for the reference

[FelipeCavichiolliSilvestre]

Into

Prisma does not support a repository pattern out of the box (for the time being) and i did not like any of the solutions in #5273, so a find a way a better way to code the example B (in my opnion).

Better solution for example B

import { Injectable } from '@nestjs/common';
import { PrismaService } from '../../prisma.service';

@Injectable()
export class UserRepository {
  constructor(private prisma: PrismaService) {}

  get create() {
    return this.prisma.user.create;
  }

  get delete() {
    return this.prisma.user.delete;
  }

  get deleteMany() {
    return this.prisma.user.deleteMany;
  }
  
  // And so on...
}

Drawbacks

• It is not a generic, so you will have to repeat yourself.
• All the "methods" are not methods anymore, but properties that map to a method

Advantages

• You do not need to import any of Prisma's type
• You do not need to create any type

So it boils down to your preference, a messier typing, or a messier repository.

[josejavierpaez]

Do you have a repository where you implement this?, or can you give a more extensive example?, please

[FelipeCavichiolliSilvestre]

This is the implementation. It is not a generic or a interface.

Supose you import the prisma client from a file.

import { prisma } from './prismaClient.js'

then you class will be like that:

export class UserRepository {
  get create() {
    return prisma.user.create
  }
}

Note the use of "get", this is the key difference. In Typescript using "get" make the method act like a property wich value is the return value of the method.

Example:

class Foo {
  get bar() {
    return 'This is the value of the property';
  }
}

const foo = new Foo();
console.log(foo.bar); // Logs 'This is the value of the property' in the console

So, when, in the original example, we return the prisma function using the get method we are, essencialy, just renaming it. Because:

import { prisma } from './prismaClient.js'

export class UserRepository {
  get create() {
    return prisma.user.create;
  }

  get delete() {
    return prisma.user.delete;
  }

  // And so on...
}

const userRepo = new UserRepository();
console.log(userRepo.create == prisma.user.create); // Logs true to console
console.log(userRepo.delete == prisma.user.delete); // Logs true to console

If you are having trouble to understand how to complete the example

Just follow the pattern, prisma.user has many methods, you just need to write a get method for every one of them, wich return will be prisma.user.< method >.

List of methods (the upsert method got out of frame):

[Zebedeu]

seems interesting to me. I will test your solution...

[webafra]

hi

I did it like this:

create an interface:

export interface BaseRepositoryInterface {
    findAll(params: any): Promise<any>;
}

create a base repository class:

export class BaseRepository implements BaseRepositoryInterface {

    protected _model;

    constructor(model) {
        this._model = model;
    }

    async findAll(params: {
        skip?: number;
        take?: number;
        cursor?: any;
        where?: any;
        orderBy?: any;
    }) {
        const { skip, take, cursor, where, orderBy } = params;

        return await this._model.findMany({
            skip,
            take,
            cursor,
            where,
            orderBy,
        });
    }
}

and finally: create repository class for witch model:
for example: user model

@Injectable()
export class UserRepository extends BaseRepository {
    constructor(
        private prisma: PrismaService
    ) {
        super(prisma.user)
    }
}

this work for me :)

[AlanMorel]

hi

I did it like this:

create an interface:

export interface BaseRepositoryInterface {
    findAll(params: any): Promise<any>;
}

create a base repository class:

export class BaseRepository implements BaseRepositoryInterface {

    protected _model;

    constructor(model) {
        this._model = model;
    }

    async findAll(params: {
        skip?: number;
        take?: number;
        cursor?: any;
        where?: any;
        orderBy?: any;
    }) {
        const { skip, take, cursor, where, orderBy } = params;

        return await this._model.findMany({
            skip,
            take,
            cursor,
            where,
            orderBy,
        });
    }
}

and finally: create repository class for witch model: for example: user model

@Injectable()
export class UserRepository extends BaseRepository {
    constructor(
        private prisma: PrismaService
    ) {
        super(prisma.user)
    }
}

this work for me :)

What's the type of _model?

[webafra]

Unfortunately, you cannot define a type for it because Prisma models are not of a specific type.

Therefore, you should consider the type of this variable as any.

[AlanMorel]

Got it, thanks for your help! Hopefully Prisma can provide a working solution to bring in type safety in your example

[kaiquye]

import { _Repository } from "./types";
import { PrismaService } from "../prisma/connection";

export abstract class Repository<T> implements _Repository<T> {
  private table: string;
  private ORM: PrismaService;
  constructor(table: string, database: PrismaService) {
    this.table = table;
    this.ORM = database;
  }

  _create<Includes = T>(data: Includes): Promise<void | T | any> {
    return this.ORM[this.table].create({ ...data });
  }

  _delete(id: number): Promise<boolean | void | T> {
    return this.ORM[this.table].delete({
      where: { id },
    });
  }

  _exists<Includes = Partial<T>>(data: Includes): Promise<boolean | T> {
    return this.ORM[this.table].findFirst({
      where: data,
    });
  }

  _findAll(): Promise<any> {
    return this.ORM[this.table].findMany();
  }

  _findById(id: number): Promise<void | T> {
    return this.ORM[this.table].findFirst({
      where: {
        id,
      },
    });
  }
}

[aislanspeedio]

This PrismaService comes from NestJs service?

Can you offer a repo demo for this?

[Gemy95]

I think that is a bad solution because when you are using a user repository from your custom base repository you will not be able to access user properties inside where conditions object or anything like it (because of there is no type for model) . @kaiquye

[revmischa]

I'm trying something like this, which gives you the proper args and return types

// something that looks like a prisma model
// define what we need to be able to call
type PrismaDelegate<T> = T extends {
  findUnique: (args: infer FindUniqueArgs) => infer FindUniqueReturn;
  findUniqueOrThrow: (args: infer FindUniqueOrThrowArgs) => infer FindUniqueOrThrowReturn;
  update: (args: infer UpdateArgs) => infer UpdateReturn;
}
  ? {
      findUnique: (args: FindUniqueArgs) => FindUniqueReturn;
      findUniqueOrThrow: (args: FindUniqueOrThrowArgs) => FindUniqueOrThrowReturn;
      update: (args: UpdateArgs) => UpdateReturn;
    }
  : never;

[aislanspeedio]

Can you show an example using PrismaDelegate in the context of repository pattern ?

[Froncast]

I did the following, maybe it will be useful to someone

import { PrismaClient } from "@prisma/client";
import { PrismaService } from "../prisma.service";

export class PrismaRepository<K extends Exclude<keyof PrismaClient, symbol | `$${string}`>> {
  private readonly model!: K

  constructor(private readonly prisma: PrismaService) {}

  aggregate(...args: Parameters<PrismaClient[K]['aggregate']>) {
    return (this.prisma[this.model].aggregate as any)(...args);
  }

  count(...args: Parameters<PrismaClient[K]['count']>) {
    return (this.prisma[this.model].count as any)(...args);
  }

  create(...args: Parameters<PrismaClient[K]['create']>) {
    return (this.prisma[this.model].create as any)(...args);
  }

  createMany(...args: Parameters<PrismaClient[K]['createMany']>) {
    return (this.prisma[this.model].createMany as any)(...args);
  }

  delete(...args: Parameters<PrismaClient[K]['delete']>) {
    return (this.prisma[this.model].delete as any)(...args);
  }

  findFirst(...args: Parameters<PrismaClient[K]['findFirst']>) {
    return (this.prisma[this.model].findFirst as any)(...args);
  }

  findFirstOrThrow(...args: Parameters<PrismaClient[K]['findFirstOrThrow']>) {
    return (this.prisma[this.model].findFirstOrThrow as any)(...args);
  }

  findMany(...args: Parameters<PrismaClient[K]['findMany']>) {
    return (this.prisma[this.model].findMany as any)(...args);
  }

  findUnique(...args: Parameters<PrismaClient[K]['findUnique']>) {
    return (this.prisma[this.model].findUnique as any)(...args);
  }

  findUniqueOrThrow(...args: Parameters<PrismaClient[K]['findUniqueOrThrow']>) {
    return (this.prisma[this.model].findUniqueOrThrow as any)(...args);
  }

  update(...args: Parameters<PrismaClient[K]['update']>) {
    return (this.prisma[this.model].update as any)(...args);
  }

  updateMany(...args: Parameters<PrismaClient[K]['updateMany']>) {
    return (this.prisma[this.model].updateMany as any)(...args);
  }
  
  upsert(...args: Parameters<PrismaClient[K]['upsert']>) {
    return (this.prisma[this.model].upsert as any)(...args);
  }
}

Usage example

class UserRepository extends PrismaRepository<'user'> {}
const userRepository = new UserRepository(new PrismaService())

userRepository.create({
  data: {
    email: "[email protected]"
  }
})

[Froncast]

Here is another repository implementation with preservation of all types (not yet tested with NestJS)

import { Prisma, PrismaClient } from '@prisma/client'

class Decorator<Interface> {
  private target!: Interface;
}

export type DecoratorClass<Interface> = {
  new (target: Interface): Decorator<Interface> & Interface;
  prototype: Decorator<Interface> & Interface;
}

export function createDecoratorProxy<Interface>(methods: ReadonlyArray<keyof Interface>): DecoratorClass<Interface> {

  class Decorator {
      constructor(private target: Interface) {}
  }    

  for (const key of methods) {
      (Decorator.prototype as any)[key] = function (...args: any[]) {
          return this.target[key](...args);
      }
  }

  return Decorator as any
}

class UserRepository extends createDecoratorProxy<Prisma.UserDelegate>([
  "aggregate",
  "count",
  "create",
  "createMany",
  "delete",
  "findFirst",
  "findFirstOrThrow",
  "findMany",
  "findUnique",
  "findUniqueOrThrow",
  "update",
  "updateMany",
  "upsert",
]) {}
class PostRepository extends createDecoratorProxy<Prisma.PostDelegate>([
  "aggregate",
  "count",
  "create",
  "createMany",
  "delete",
  "findFirst",
  "findFirstOrThrow",
  "findMany",
  "findUnique",
  "findUniqueOrThrow",
  "update",
  "updateMany",
  "upsert",
]) {}

const prisma = new PrismaClient()
const userRepository = new UserRepository(prisma.user)
const postRepository = new PostRepository(prisma.post)

async function main() {
  const newUserWithPost = await userRepository.create({
    data: {
      email: "[email protected]",
      name: "user",
      posts: {
        create: {
          title: "post 1",
          published: true
        }
      }
    },
    select: {
      id: true
    }
  })
  
  console.log("🚀 ~ file: index.ts:78 ~ main ~ newUserWithPost:", newUserWithPost)

  const users = await userRepository.findMany({
    include: {
      posts: {
        select: {
          id: true
        }
      }
    }
  })

  console.log("🚀 ~ file: index.ts:44 ~ main ~ users:", users)
}

main()
  .then(async () => {
    await prisma.$disconnect()
  })
  .catch(async (e) => {
    console.error(e)
    await prisma.$disconnect()
    process.exit(1)
  })

[Froncast]

I am currently considering switching from PrismaOrm to DrizzleORM

[Ericles-Miller]

Did you manage to do this implementation using drizzle? I tried with the drizzle, but I also managed

[Froncast]

I never got around to using Drizzle. But I tried Kysely and I liked this query builder more than any of ORM

[mkelley33]

I get an error in VS Code that This expression is not callable. Each member of the union type '(<T extends DefaultCollectionCreateArgs<DefaultArgs>>(args: SelectSubset<T, DefaultCollectionCreateArgs<DefaultArgs>>) => Prisma__DefaultCollectionClient<...>) | (<T extends QuoteCollectionCreateArgs<...>>(args: SelectSubset<...>) => Prisma__QuoteCollectionClient<...>)' has signatures, but none of those signatures are compatible with each other.ts(2349)

Does this work in the latest version of TypeScript? Thanks for any help @Froncast

[lodeli-lulu]

I have also been working on a solution for this for my team. We are satisfied with the solution for now, as almost all aspects are covered.

This example is a NestJs API.

Versions:

• Prisma: 5.1.1
• NestJs: 10.1.3

/* base.repository.ts */
import {
 IBaseRepository,
 ModelArgs,
 ModelName,
 ModelResult,
} from './base-repository.interface';
import { Prisma } from '@prisma/client';
import { ExtendedPrismaClient } from '@core/database';

export class BaseRepository<T extends ModelName> implements IBaseRepository<T> {
 constructor(
   private readonly _model: Uncapitalize<T>,
   private readonly _prismaService: ExtendedPrismaClient, // We are using Prisma Client Extensions
 ) {}

 findUnique<A extends ModelArgs<T, 'findUnique'>>(
   args: Prisma.SelectSubset<A, ModelArgs<T, 'findUnique'>>,
 ): ModelResult<T, A, 'findUnique'> {
   return this._prismaService[this._model as Prisma.ModelName].findUnique(
     args,
   );
 }

 findUniqueOrThrow<A extends ModelArgs<T, 'findUniqueOrThrow'>>(
   args?: Prisma.SelectSubset<A, ModelArgs<T, 'findUniqueOrThrow'>>,
 ): ModelResult<T, A, 'findUniqueOrThrow'> {
   return this._prismaService[
     this._model as Prisma.ModelName
   ].findUniqueOrThrow(args);
 }

 findFirst<A extends ModelArgs<T, 'findFirst'>>(
   args?: Prisma.SelectSubset<A, ModelArgs<T, 'findFirst'>>,
 ): ModelResult<T, A, 'findFirst'> {
   return this._prismaService[this._model as Prisma.ModelName].findFirst(args);
 }

 findFirstOrThrow<A extends ModelArgs<T, 'findFirstOrThrow'>>(
   args?: Prisma.SelectSubset<A, ModelArgs<T, 'findFirstOrThrow'>>,
 ): ModelResult<T, A, 'findFirstOrThrow'> {
   return this._prismaService[
     this._model as Prisma.ModelName
   ].findFirstOrThrow(args);
 }

 findMany<A extends ModelArgs<T, 'findMany'>>(
   args?: Prisma.SelectSubset<A, ModelArgs<T, 'findMany'>>,
 ): ModelResult<T, A, 'findMany'> {
   return this._prismaService[this._model as Prisma.ModelName].findMany(args);
 }

 create<A extends ModelArgs<T, 'create'>>(
   args: Prisma.SelectSubset<A, ModelArgs<T, 'create'>>,
 ): ModelResult<T, A, 'create'> {
   return this._prismaService[this._model as Prisma.ModelName].create(args);
 }

 createMany<A extends ModelArgs<T, 'createMany'>>(
   args?: Prisma.SelectSubset<A, ModelArgs<T, 'createMany'>>,
 ): ModelResult<T, A, 'createMany'> {
   return this._prismaService[this._model as Prisma.ModelName].createMany(
     args,
   );
 }

 update<A extends ModelArgs<T, 'update'>>(
   args: Prisma.SelectSubset<A, ModelArgs<T, 'update'>>,
 ): ModelResult<T, A, 'update'> {
   return this._prismaService[this._model as Prisma.ModelName].update(args);
 }

 updateMany<A extends ModelArgs<T, 'updateMany'>>(
   args: Prisma.SelectSubset<A, ModelArgs<T, 'updateMany'>>,
 ): ModelResult<T, A, 'updateMany'> {
   return this._prismaService[this._model as Prisma.ModelName].updateMany(
     args,
   );
 }

 delete<A extends ModelArgs<T, 'delete'>>(
   args: Prisma.SelectSubset<A, ModelArgs<T, 'delete'>>,
 ): ModelResult<T, A, 'delete'> {
   return this._prismaService[this._model as Prisma.ModelName].delete(args);
 }

 deleteMany<A extends ModelArgs<T, 'deleteMany'>>(
   args?: Prisma.SelectSubset<A, ModelArgs<T, 'deleteMany'>>,
 ): ModelResult<T, A, 'deleteMany'> {
   return this._prismaService[this._model as Prisma.ModelName].deleteMany(
     args,
   );
 }

 upsert<A extends ModelArgs<T, 'upsert'>>(
   args: Prisma.SelectSubset<A, ModelArgs<T, 'upsert'>>,
 ): ModelResult<T, A, 'upsert'> {
   return this._prismaService[this._model as Prisma.ModelName].upsert(args);
 }
}

/* base-repository.interface.ts */
import { Prisma, PrismaClient } from '@prisma/client';
import {
 GetResult as PrismaGetResult,
 Operation,
} from '@prisma/client/runtime/library';

interface Clients<
 T extends ModelName,
 A extends ModelArgs<T, O>,
 O extends Operation,
> {
 User: Prisma.Prisma__UserClient<GetResult<T, A, O>, never>;
 Post: Prisma.Prisma__PostClient<GetResult<T, A, O>, never>;
 Category: Prisma.Prisma__CategoryClient<GetResult<T, A, O>, never>;
}

type MethodsWithParams<T, M extends ModelName> = {
 [K in keyof T & Operation]: T[K] extends true
   ? <A extends ModelArgs<M, K>>(
       args?: Prisma.SelectSubset<A, ModelArgs<M, K>>,
     ) => ModelResult<M, A, K>
   : <A extends ModelArgs<M, K>>(
       args: Prisma.SelectSubset<A, ModelArgs<M, K>>,
     ) => ModelResult<M, A, K>;
};

export type IBaseRepository<T extends ModelName> = MethodsWithParams<
 Operation,
 T
>;

/* Prisma models */
export type ModelName = Prisma.ModelName;

/* Prisma model methods */
export type PrismaModelMethods<T extends ModelName> =
 keyof PrismaClient[Uncapitalize<T> extends keyof PrismaClient
   ? Uncapitalize<T>
   : never];

type PrismaModelMethod<T extends ModelName> = {
 [K in PrismaModelMethods<T>]: PrismaClient[Uncapitalize<T> extends keyof PrismaClient
   ? Uncapitalize<T>
   : never][K];
};

/* Prisma GetResult */
type GetResult<
 T extends ModelName,
 A extends ModelArgs<T, O>,
 O extends Operation,
> = PrismaGetResult<PrismaPayload<T>, A, O>;

/* Prisma payload */
export type PrismaPayload<T extends ModelName> =
 Prisma.TypeMap['model'][T]['payload'];

/* Prisma model arguments */
export type ModelArgs<
 T extends ModelName,
 O extends Operation,
> = PrismaModelMethod<T>[O extends keyof PrismaModelMethod<T>
 ? O
 : never] extends (args: infer A) => any
 ? A
 : never;

/* Prisma model return types */
export type ModelResult<
 T extends ModelName,
 A extends ModelArgs<T, O>,
 O extends Operation,
> = PrismaModelMethod<T> extends {
 [K in O]: (args: A) => any;
}
 ? Clients<T, A, O>[T extends keyof Clients<T, A, O> ? T : never]
 : never;

The only thing that needs to be adjusted when more models are added is the Clients interface. I have not yet been able to figure out how to get to it dynamically. Every try ended in wrong return types.

You can extend the BaseRepository class inside a service like this:

/* user.service.ts */
import { Inject, Injectable } from '@nestjs/common';
import {
 BaseRepository,
 ExtendedPrismaClient,
 PRISMA_MASTER_CONNECTION,
} from '@core/database';

@Injectable()
export class UserService extends BaseRepository<'User'> {
 private readonly _prisma: ExtendedPrismaClient;

 constructor(@Inject(PRISMA_MASTER_CONNECTION) prisma: ExtendedPrismaClient) {
   super('user', prisma);
   this._prisma = prisma;
 }
}

So in your resolver or controller you can directly access the Prisma methods via UserService. If further logic is required, then additional methods can be created within the UserService. If you need to access other resources you can inject for example PostService.

/* user.service.ts */
import { Inject, Injectable } from '@nestjs/common';
import {
 BaseRepository,
 ExtendedPrismaClient,
 PRISMA_MASTER_CONNECTION,
} from '@core/database';

@Injectable()
export class UserService extends BaseRepository<'User'> {
 private readonly _prisma: ExtendedPrismaClient;

 constructor(
   @Inject(PRISMA_MASTER_CONNECTION) prisma: ExtendedPrismaClient,
   private readonly _post: PostService,
 ) {
   super('user', prisma);
   this._prisma = prisma;
 }
 
 async myFunction() {
   const posts = await this._post.findMany();
   
   // Do some logic with posts
   
   return this.create(/* Data */);
 }
}

There are still some methods that are not type safe (e.g. groupBy). But the main methods are type safe with this example. Maybe this example will help someone.

I would appreciate feedback and suggestions for improvement or even other solutions.

Have a nice day!

[Froncast]

As for your implementation of the Repository pattern. Maybe I'm not completely understanding something, but it seems that UserService should not extend BaseRepository. This should be done by a separate class, which is subsequently injected into the UserService. Otherwise, you get a lot of extra code and then it's easier to inject PrismaClient

[lodeli-lulu]

We build GraphQL API's with NestJs and we are using following Package prisma-nestjs-graphql to auto generate object types, inputs, args, etc. from prisma schema file.

And yes you are right. You can also create an injectable repository. Let me explain what we have in mind by extend the repository.

We create a separate module with resolver and injectable service for each Prisma table (model). The injectable services are extended by base repository. So with this implementation, the logic of the individual models is separated from each other and it is clear for the developers when making adjustments or feature requests.

For Example the PostService implements only business logic based on posts. If the logic needs data of a user the PostService inject the UserService. Each service contains the operations for the associated model.

I hope I could explain this to you understandably.

[yashvesikar]

Do you mind sharing what Prisma Client Extensions you are using? Trying to work through this myself and running into some errors with the normal Prisma Client

[lodeli-lulu]

Sorry for the late reply. We use RLS policies at the database level and control the configuration with the Prisma Extension.

Here is an example:

/* prisma.extension.ts */
export const prismaExtensionFactory = (
  client: PrismaClient<Prisma.PrismaClientOptions, 'query'>,
  logger: Logger,
  config: ConfigService,
  store: ClsService<IClsStore>,
) => {
  if (config.get<string>(EnvEnum.PROFILE) === 'local') {
    client.$on('query', (event) => {
      logger.debug(`${event.query} - ${event.params} +${event.duration}ms`);
    });
  }

  return client.$extends({
    query: {
      $allModels: {
        async $allOperations({ args, query }) {
          const user = store.get<TUser>('user'); // nest-cls package

          const userType = store.get<UserTypeEnum>('userType');
          let setConfigSql: Sql;

          switch (userType) {
            case UserTypeEnum.ADMIN:
              setConfigSql = Prisma.sql`SELECT set_config('app.bypass_rls', 'on', TRUE)`;
              break;
            case UserTypeEnum.CUSTOMER:
              setConfigSql = Prisma.sql`SELECT set_config('app.current_customer_id', ${user.id}, TRUE)`;
              break;
          }

          const [, result] = await client.$transaction([
            client.$executeRaw(setConfigSql),
            query(args),
          ]);
          return result;
        },
      },
    },
  });
};

export type ExtendedPrismaClient = ReturnType<typeof prismaExtensionFactory>;

/* prisma.module.ts */
@Module({})
export class PrismaModule {
  private static readonly _prisma = new PrismaService({
    log: [
      { emit: 'event', level: 'query' },
      { emit: 'stdout', level: 'info' },
      { emit: 'stdout', level: 'warn' },
    ],
    errorFormat: 'minimal',
  });
  private static readonly _logger = new Logger(PRISMA_MASTER_CONNECTION);
  static forRoot(): DynamicModule {
    return {
      global: true,
      module: PrismaModule,
      imports: [ConfigModule, ClsModule],
      providers: [
        Logger,
        PrismaService,
        {
          provide: PRISMA_MASTER_CONNECTION,
          useFactory: (config: ConfigService, store: ClsService<IClsStore>) => {
            return prismaExtensionFactory(
              PrismaModule._prisma,
              PrismaModule._logger,
              config,
              store,
            );
          },
          inject: [ConfigService, ClsService<IClsStore>],
        },
      ],
      exports: [PRISMA_MASTER_CONNECTION],
    };
  }
}

If you have any questions, feel free to ask.

[ailinalbertoni]

Is this still working for you? Trying to use it in Prisma 5.11 but it raises a type error:

[antoniofisherman-job]

@lodeli-lulu I noticed that not all methods have correct types
For example I use findMany and include just has 'never' however with createOne it works perfect,

And there are the same in some other methods (findFirst, updateMany, createMany)

What can it depend on ?

Have I done something wrong, or you have the same issues ?

However when I highlight it shows correct type

[EriclesMillerEstudioHaus]

I partially managed to make the repository generic, but I can't get rid of this error. The searches work perfectly, however, I don't know if I will be able to build the application because of this error. Is there any way to fix this?

First I create my generic repository

Once this is done, I create the repositories that will extend from the base repository.

your interface

and I do the same for the trainings repository.

to define the repository type I do this

I used my addiction injections this way

but I get this error

This expression cannot be called.
Each member of the union type '(<T extends TrainingsFindUniqueArgs>(args: SelectSubset<T, TrainingsFindUniqueArgs>) => Prisma__TrainingsClient<...>) | (<T extends UsersFindUniqueArgs<...>>(args: SelectSubset<...>) => Prisma__UsersClient<...>)' has signatures, but none of these signatures are compatible with each other.ts(2349)

but when executing some method it works perfectly. What solution can I do to solve this

[zN3utr4l]

https://github.com/krsbx/prisma-repo-next
Is this a good choice?