@koalarx/nest 3.0.9 → 3.0.11

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

@@ -13,21 +13,25 @@ interface RepositoryInitProps<TEntity extends EntityBase<TEntity>, TContext exte
     modelName: Type<TEntity>;
     transactionContext?: Type<TContext>;
     include?: RepositoryInclude<TEntity>;
+    includeFindMany?: RepositoryInclude<TEntity>;
 }
 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, TContext>);
+    private readonly _includeFindMany?;
+    constructor({ context, modelName, include, includeFindMany, }: RepositoryInitProps<TEntity, TContext>);
+    private getConnectPrismaSchemaForRelation;
+    private getSelectRootPrismaSchema;
     private getPropNameFromEntitySource;
     private listRelationEntities;
     private listToRelationActionList;
     private entityToPrisma;
+    private getInclude;
     private findManySchema;
     private createEntity;
     private orphanRemoval;
     private getIdPropName;
-    private getInclude;
     private persistRelations;
     protected context(transactionalClient?: TContext): TContext[TModelKey];
     protected findById(id: IComparableId): Promise<TEntity | null>;

package/core/database/repository.base.js

@@ -11,10 +11,38 @@ class RepositoryBase {
     _context;
     _modelName;
     _include;
-    constructor({ context, modelName, include, }) {
+    _includeFindMany;
+    constructor({ context, modelName, include, includeFindMany, }) {
         this._context = context;
         this._modelName = modelName;
         this._include = include;
+        this._includeFindMany =
+            includeFindMany ?? this.getSelectRootPrismaSchema(new modelName());
+    }
+    getConnectPrismaSchemaForRelation(entity, data) {
+        const propIdName = this.getIdPropName(entity);
+        return {
+            connect: {
+                [propIdName]: (data ?? entity)[propIdName],
+            },
+        };
+    }
+    getSelectRootPrismaSchema(entity) {
+        const selectSchema = {};
+        Object.keys(entity)
+            .filter((key) => !['_id', '_action'].includes(key))
+            .filter((key) => !(entity[key] instanceof Function || entity[key] instanceof list_1.List))
+            .forEach((key) => {
+            if (entity[key] instanceof entity_base_1.EntityBase) {
+                selectSchema[key] = {
+                    select: this.getSelectRootPrismaSchema(entity[key]),
+                };
+            }
+            else {
+                selectSchema[key] = true;
+            }
+        });
+        return selectSchema;
     }
     getPropNameFromEntitySource(source, entity) {
         return Object.keys(source).find((key) => {
@@ -76,12 +104,9 @@ class RepositoryBase {
                             schema: {
                                 data: {
                                     ...this.entityToPrisma(item),
-                                    [parentPropName]: {
-                                        connect: {
-                                            [this.getIdPropName(entity)]: entity[this.getIdPropName(entity)],
-                                        },
-                                    },
+                                    [parentPropName]: this.getConnectPrismaSchemaForRelation(entity),
                                 },
+                                select: this.getSelectRootPrismaSchema(item),
                             },
                             relations: this.listRelationEntities(item),
                         });
@@ -93,6 +118,7 @@ class RepositoryBase {
                             schema: {
                                 where: { id: item._id },
                                 data: this.entityToPrisma(item),
+                                select: this.getSelectRootPrismaSchema(item),
                             },
                             relations: this.listRelationEntities(item),
                         });
@@ -138,9 +164,24 @@ class RepositoryBase {
         });
         return prismaSchema;
     }
+    getInclude(include) {
+        include = include ?? this._include ?? {};
+        const result = {};
+        Object.keys(include).forEach((key) => {
+            if (typeof include[key] === 'boolean') {
+                result[key] = include[key];
+            }
+            else {
+                result[key] = {
+                    include: this.getInclude(include[key]),
+                };
+            }
+        });
+        return result;
+    }
     findManySchema(where, pagination) {
         return {
-            include: this.getInclude(),
+            include: this.getInclude(this._includeFindMany),
             where,
             orderBy: pagination?.generateOrderBy(),
             skip: pagination?.skip(),
@@ -163,21 +204,6 @@ class RepositoryBase {
     getIdPropName(entity) {
         return (Reflect.getMetadata('entity:id', entity ? entity.constructor.prototype : this._modelName.prototype) ?? 'id');
     }
-    getInclude(include) {
-        include = include ?? this._include ?? {};
-        const result = {};
-        Object.keys(include).forEach((key) => {
-            if (typeof include[key] === 'boolean') {
-                result[key] = include[key];
-            }
-            else {
-                result[key] = {
-                    include: this.getInclude(include[key]),
-                };
-            }
-        });
-        return result;
-    }
     persistRelations(transaction, entity) {
         const { relationCreates, relationUpdates, relationDeletes } = this.listToRelationActionList(entity);
         return Promise.all([
@@ -186,15 +212,15 @@ class RepositoryBase {
                 .then((response) => {
                 return Promise.all(relationCreate.relations.map((relation) => {
                     const relationPropName = this.getPropNameFromEntitySource(relation, relationCreate.entityInstance);
-                    if (relationPropName) {
-                        const relationEntity = this.createEntity(response, relationCreate.entityInstance);
-                        relationEntity._action = entity_base_1.EntityActionType.create;
-                        relation[relationPropName] = relationEntity;
+                    if (relationPropName &&
+                        !(relation[relationPropName] instanceof list_1.List)) {
+                        relation[relationPropName] =
+                            this.getConnectPrismaSchemaForRelation(relationCreate.entityInstance, response);
                     }
                     return transaction[(0, KlString_1.toCamelCase)(relation.constructor.name)]
                         .create({
                         data: this.entityToPrisma(relation),
-                        select: { [this.getIdPropName(relation)]: true },
+                        select: this.getSelectRootPrismaSchema(relation),
                     })
                         .then((response) => {
                         relation[this.getIdPropName(relation)] =

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalarx/nest",
-  "version": "3.0.9",
+  "version": "3.0.11",
   "description": "",
   "author": "Igor D. Rangel",
   "license": "MIT",