@koalarx/nest 1.18.7 → 1.18.9

package/core/database/prisma-transactional-client.d.ts

@@ -1,6 +1,7 @@
 import { Prisma } from 'prisma/generated/client';
 export declare abstract class PrismaTransactionalClient {
     protected readonly transactionalClient: Prisma.TransactionClient;
+    [key: symbol]: any;
     constructor(transactionalClient: Prisma.TransactionClient);
     withTransaction<F>(fn: (prisma: Prisma.TransactionClient) => Promise<F>): Promise<F>;
     $executeRaw(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;

package/core/database/repository.base.d.ts

@@ -8,33 +8,34 @@ import { PrismaTransactionalClient } from './prisma-transactional-client';
 type RepositoryInclude<TEntity> = Omit<{
     [K in keyof TEntity as TEntity[K] extends Function ? never : K]?: boolean | (TEntity[K] extends List<infer U> ? RepositoryInclude<U> : RepositoryInclude<TEntity[K]>);
 }, '_id' | '_action'>;
-interface RepositoryInitProps<TEntity extends EntityBase<TEntity>> {
-    context: PrismaTransactionalClient;
+interface RepositoryInitProps<TEntity extends EntityBase<TEntity>, TContext extends PrismaTransactionalClient> {
+    context: TContext;
     modelName: Type<TEntity>;
-    transactionContext?: Type<PrismaTransactionalClient>;
+    transactionContext?: Type<TContext>;
     include?: RepositoryInclude<TEntity>;
 }
-export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>> {
-    protected _context: PrismaTransactionalClient;
+export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>, TContext extends PrismaTransactionalClient = PrismaTransactionalClient, TModelKey extends keyof TContext = keyof TContext> {
+    protected _context: TContext;
     private readonly _modelName;
     private readonly _include?;
-    constructor({ context, modelName, include }: RepositoryInitProps<TEntity>);
-    withTransaction(fn: (prisma: PrismaTransactionalClient) => Promise<any>): Promise<any>;
+    constructor({ context, modelName, include, }: RepositoryInitProps<TEntity, TContext>);
+    protected context(transactionalClient?: TContext): TContext[TModelKey];
     protected findById(id: IComparableId): Promise<TEntity | null>;
     protected findFirst<T>(where: T): Promise<TEntity | null>;
     protected findUnique<T>(where: T): Promise<TEntity | null>;
     protected findMany<T>(where: T, pagination?: PaginationDto): Promise<TEntity[]>;
     protected findManyAndCount<T>(where: T, pagination?: PaginationDto): Promise<ListResponse<TEntity>>;
     protected saveChanges<TWhere = any>(entity: TEntity, updateWhere?: TWhere): Promise<TEntity>;
+    protected saveMany<TWhere = any>(entities: TEntity[], updateWhere?: TWhere): Promise<void>;
     protected remove<TWhere = any>(where: TWhere, externalServices?: Promise<any>, notCascadeEntityProps?: Array<keyof TEntity>): Promise<any>;
     protected removeMany<TWhere = any>(where: TWhere, externalServices?: Promise<any>, notCascadeEntityProps?: Array<keyof TEntity>): Promise<void>;
     private listToRelationActionList;
     private entityToPrisma;
-    private context;
     private findManySchema;
     private createEntity;
     private orphanRemoval;
     private getIdPropName;
     private getInclude;
+    withTransaction(fn: (prisma: TContext) => Promise<any>): Promise<any>;
 }
 export {};

package/core/database/repository.base.js

@@ -10,15 +10,20 @@ class RepositoryBase {
     _context;
     _modelName;
     _include;
-    constructor({ context, modelName, include }) {
+    constructor({ context, modelName, include, }) {
         this._context = context;
         this._modelName = modelName;
         this._include = include;
     }
-    withTransaction(fn) {
-        return this._context.withTransaction(async (client) => {
-            return fn(new koala_global_vars_1.KoalaGlobalVars.dbTransactionContext(client));
-        });
+    context(transactionalClient) {
+        const modelName = this._modelName.name;
+        if (!modelName)
+            throw new Error('modelName não informado no contrutor do repositorio');
+        const contextKey = (0, KlString_1.toCamelCase)(modelName);
+        if (transactionalClient) {
+            return transactionalClient[contextKey];
+        }
+        return this._context[contextKey];
     }
     async findById(id) {
         return this.context()
@@ -95,9 +100,26 @@ class RepositoryBase {
                     ...relationUpdates.map((relation) => client[relation.modelName].updateMany(relation.schema)),
                     ...relationDeletes.map((relation) => client[relation.modelName].deleteMany(relation.schema)),
                 ]);
-            })).then(() => this.findFirst(where));
+            })).then(() => this.findUnique(where));
         }
     }
+    async saveMany(entities, updateWhere) {
+        await this.withTransaction(async (client) => {
+            const prismaEntities = entities.map((entity) => this.entityToPrisma(entity));
+            return Promise.all([
+                this.context(client).createMany({
+                    data: prismaEntities,
+                    skipDuplicates: true,
+                }),
+                ...entities
+                    .filter((entity) => !!entity._id)
+                    .map((entity) => this.context(client).update({
+                    data: entity,
+                    where: updateWhere ?? { id: entity._id },
+                })),
+            ]);
+        });
+    }
     async remove(where, externalServices, notCascadeEntityProps) {
         const entity = await this.findUnique(where);
         if (!entity) {
@@ -213,15 +235,6 @@ class RepositoryBase {
         });
         return prismaSchema;
     }
-    context(transactionalClient) {
-        const modelName = this._modelName.name;
-        if (!modelName)
-            throw new Error('modelName não informado no contrutor do repositorio');
-        if (transactionalClient) {
-            return transactionalClient[(0, KlString_1.toCamelCase)(modelName)];
-        }
-        return this._context[modelName];
-    }
     findManySchema(where, pagination) {
         return {
             include: this.getInclude(),
@@ -262,5 +275,10 @@ class RepositoryBase {
         });
         return result;
     }
+    withTransaction(fn) {
+        return this._context.withTransaction(async (client) => {
+            return fn(new koala_global_vars_1.KoalaGlobalVars.dbTransactionContext(client));
+        });
+    }
 }
 exports.RepositoryBase = RepositoryBase;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalarx/nest",
-  "version": "1.18.7",
+  "version": "1.18.9",
   "description": "",
   "repository": {
     "type": "git",