import { Prisma, PrismaClient } from '@repo/database';
export type ID = string | number;
export abstract class BaseRepository<  TModel,  TDelegate extends {    findMany: (...args: any) => any;    findUnique: (...args: any) => any;    create: (...args: any) => any;    update: (...args: any) => any;    delete: (...args: any) => any;    findFirst: (...args: any) => any;    aggregate: (...args: any) => any;    count: (...args: any) => any;    groupBy: (...args: any) => any;    upsert: (...args: any) => any;    updateMany: (...args: any) => any;    deleteMany: (...args: any) => any;    aggregateRaw: (...args: any) => any;  },> {  protected prisma: PrismaClient;  protected delegate: TDelegate;
  constructor(prisma: PrismaClient, delegate: TDelegate) {    this.prisma = prisma;    this.delegate = delegate;  }
  async findAll(    args?: Parameters<TDelegate['findMany']>[0]  ): Promise<TModel[]> {    return this.delegate.findMany(args);  }
  async findById(id: ID): Promise<TModel | null> {    return this.delegate.findUnique({ where: { id } });  }
  async findFirst(    args: Parameters<TDelegate['findFirst']>[0]  ): Promise<TModel | null> {    return this.delegate.findFirst(args);  }
  async findUnique(    args: Parameters<TDelegate['findUnique']>[0]  ): Promise<TModel | null> {    return this.delegate.findUnique(args);  }
  async findMany(    args: Parameters<TDelegate['findMany']>[0]  ): Promise<TModel[]> {    return this.delegate.findMany(args);  }
  async create<TSelect extends Prisma.UserSelect>(    data: Prisma.UserCreateArgs['data'],    select?: TSelect  ): Promise<Prisma.UserGetPayload<{ select: TSelect }>> {    return (this.delegate as any).create({      data,      select,    });  }
  async update(    id: ID,    data: Parameters<TDelegate['update']>[0]['data']  ): Promise<TModel | null> {    return this.delegate.update({ where: { id }, data });  }
  async delete(id: ID): Promise<TModel | null> {    return this.delegate.delete({ where: { id } });  }
  async checkExist(    where: Parameters<TDelegate['findUnique']>[0]  ): Promise<boolean> {    const result = await this.delegate.findUnique(where);    return !!result;  }
  async aggregate(args: Parameters<TDelegate['aggregate']>[0]): Promise<any> {    return this.delegate.aggregate(args as any);  }
  async count(args?: Parameters<TDelegate['count']>[0]): Promise<number> {    return this.delegate.count(args as any);  }
  async upsert(    args: Parameters<TDelegate['upsert']>[0]  ): Promise<TModel | null> {    return this.delegate.upsert(args as any);  }
  // async groupBy(args: Parameters<TDelegate['groupBy']>[0]): Promise<any> {  //   return this.delegate.groupBy(args as any);  // }  
  async updateMany(    args: Parameters<TDelegate['updateMany']>[0]  ): Promise<TModel[]> {    return this.delegate.updateMany(args);  }
  async deleteMany(    args: Parameters<TDelegate['deleteMany']>[0]  ): Promise<TModel[]> {    return this.delegate.deleteMany(args);  }
  async aggregateRaw(    args: Parameters<TDelegate['aggregateRaw']>[0]  ): Promise<any> {    return this.delegate.aggregateRaw(args);  }}

import { Prisma } from '@repo/database';import { BaseRepository, ID } from '../repository/BaseRepository';
export abstract class BaseService<  TModel,  TRepository extends BaseRepository<TModel, any>,> {  protected repository: TRepository;
  constructor(repository: TRepository) {    this.repository = repository;  }
  async findAll(    options?: Parameters<TRepository['findAll']>[0]  ): Promise<TModel[]> {    return this.repository.findAll(options);  }
  async findById(id: ID): Promise<TModel | null> {    return this.repository.findById(id);  }
  async create<TSelect extends Prisma.UserSelect>(    data: Parameters<TRepository['create']>[0],    select?: TSelect  ): Promise<Prisma.UserGetPayload<{ select: TSelect }>> {    return this.repository.create(data, select);  }
  async update(    id: any,    data: Parameters<TRepository['update']>[1]  ): Promise<TModel | null> {    return this.repository.update(id, data);  }
  async delete(id: ID): Promise<TModel | null> {    return this.repository.delete(id);  }
  async checkExistById(id: ID): Promise<boolean> {    return this.repository.checkExist({ id });  }
  async checkExist(    where: Parameters<TRepository['checkExist']>[0]  ): Promise<boolean> {    return this.repository.checkExist(where);  }
  async aggregate(args: Parameters<TRepository['aggregate']>[0]): Promise<any> {    return this.repository.aggregate(args);  }
  async count(args: Parameters<TRepository['count']>[0]): Promise<number> {    return this.repository.count(args);  }
  async upsert(    args: Parameters<TRepository['upsert']>[0]  ): Promise<TModel | null> {    return this.repository.upsert(args);  }
  // async groupBy(args: Parameters<TRepository['groupBy']>[0]): Promise<any> {  //   return this.repository.groupBy(args);  // }

  async findFirst(    args: Parameters<TRepository['findFirst']>[0]  ): Promise<TModel | null> {    return this.repository.findFirst(args);  }
  async aggregateRaw(    args: Parameters<TRepository['aggregateRaw']>[0]  ): Promise<any> {    return this.repository.aggregateRaw(args);  }
  async findMany(    args: Parameters<TRepository['findMany']>[0]  ): Promise<TModel[]> {    return this.repository.findMany(args);  }  async deleteMany(    args: Parameters<TRepository['deleteMany']>[0]  ): Promise<TModel[]> {    return this.repository.deleteMany(args);  }  async updateMany(    args: Parameters<TRepository['updateMany']>[0]  ): Promise<TModel[]> {    return this.repository.updateMany(args);  }  async findUnique(    args: Parameters<TRepository['findUnique']>[0]  ): Promise<TModel | null> {    return this.repository.findUnique(args);  }} 

tsimport { BaseRepository } from '@repo/core';import { Prisma, PrismaClient, User } from '@repo/database';
export class UserRepository extends BaseRepository<User, Prisma.UserDelegate> {  constructor(prisma: PrismaClient) {    super(prisma, prisma.user);  }}

export class UserServiceExtend extends BaseService<User, UserRepository> {  constructor(userRepository: UserRepository) {    super(userRepository);  }
  async fetchUserByEmail(email: string) {    return this.repository.findUnique({ where: { email } });  }}