@koalarx/nest 1.18.13 → 1.18.15

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

@@ -19,6 +19,16 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>
     private readonly _modelName;
     private readonly _include?;
     constructor({ context, modelName, include, }: RepositoryInitProps<TEntity, TContext>);
+    private listRelationEntities;
+    private listToRelationActionList;
+    private entityToPrisma;
+    private findManySchema;
+    private createEntity;
+    private orphanRemoval;
+    private getIdPropName;
+    private getInclude;
+    private getPropNameFromEntitySource;
+    private persistRelations;
     protected context(transactionalClient?: TContext): TContext[TModelKey];
     protected findById(id: IComparableId): Promise<TEntity | null>;
     protected findFirst<T>(where: T): Promise<TEntity | null>;
@@ -29,13 +39,6 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<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 findManySchema;
-    private createEntity;
-    private orphanRemoval;
-    private getIdPropName;
-    private getInclude;
     withTransaction(fn: (prisma: TContext) => Promise<any>): Promise<any>;
 }
 export {};

package/core/database/repository.base.js

@@ -15,6 +15,183 @@ class RepositoryBase {
         this._modelName = modelName;
         this._include = include;
     }
+    listRelationEntities(entity) {
+        const relationEntities = [];
+        Object.keys(entity).forEach((key) => {
+            if (entity[key] instanceof list_1.List) {
+                const list = entity[key];
+                list.toArray('added').forEach((item) => {
+                    relationEntities.push(item);
+                    relationEntities.push(...this.listRelationEntities(item));
+                });
+                list.toArray('updated').forEach((item) => {
+                    relationEntities.push(item);
+                    relationEntities.push(...this.listRelationEntities(item));
+                });
+            }
+            else if (entity[key] instanceof entity_base_1.EntityBase) {
+                relationEntities.push(entity[key]);
+                relationEntities.push(...this.listRelationEntities(entity[key]));
+            }
+        });
+        return relationEntities;
+    }
+    listToRelationActionList(entity) {
+        const relationCreates = [];
+        const relationUpdates = [];
+        const relationDeletes = [];
+        Object.keys(entity).forEach((key) => {
+            if (entity[key] instanceof list_1.List) {
+                const list = entity[key];
+                const modelName = list.entityType?.name;
+                const parentModelName = entity.constructor.name;
+                if (modelName) {
+                    list.toArray('removed').forEach((item) => {
+                        relationDeletes.push({
+                            modelName: (0, KlString_1.toCamelCase)(modelName),
+                            schema: { where: { id: item._id } },
+                            relations: [],
+                        });
+                    });
+                    list.toArray('added').forEach((item) => {
+                        relationCreates.push({
+                            modelName: (0, KlString_1.toCamelCase)(modelName),
+                            schema: {
+                                data: {
+                                    ...this.entityToPrisma(item),
+                                    [(0, KlString_1.toCamelCase)(parentModelName)]: {
+                                        connect: {
+                                            [this.getIdPropName(entity)]: entity[this.getIdPropName(entity)],
+                                        },
+                                    },
+                                },
+                            },
+                            relations: this.listRelationEntities(item),
+                        });
+                    });
+                    list.toArray('updated').forEach((item) => {
+                        relationUpdates.push({
+                            modelName: (0, KlString_1.toCamelCase)(modelName),
+                            schema: {
+                                where: { id: item._id },
+                                data: this.entityToPrisma(item),
+                            },
+                            relations: this.listRelationEntities(item),
+                        });
+                    });
+                }
+            }
+        });
+        return { relationCreates, relationUpdates, relationDeletes };
+    }
+    entityToPrisma(entity) {
+        const prismaSchema = {};
+        Object.keys(entity)
+            .filter((key) => !['id', '_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) {
+                if (entity[key]._action === entity_base_1.EntityActionType.create) {
+                    if (entity[key][this.getIdPropName()]) {
+                        prismaSchema[key] = {
+                            connectOrCreate: {
+                                where: {
+                                    [this.getIdPropName()]: entity[key][this.getIdPropName()],
+                                },
+                                create: this.entityToPrisma(entity[key]),
+                            },
+                        };
+                    }
+                    else {
+                        prismaSchema[key] = {
+                            create: this.entityToPrisma(entity[key]),
+                        };
+                    }
+                }
+                else {
+                    prismaSchema[key] = {
+                        update: this.entityToPrisma(entity[key]),
+                    };
+                }
+            }
+            else {
+                prismaSchema[key] = entity[key];
+            }
+        });
+        return prismaSchema;
+    }
+    findManySchema(where, pagination) {
+        return {
+            include: this.getInclude(),
+            where,
+            orderBy: pagination?.generateOrderBy(),
+            skip: pagination?.skip(),
+            take: (pagination?.limit ?? 0) > 0 ? pagination?.limit : undefined,
+        };
+    }
+    createEntity(data) {
+        const entity = new this._modelName();
+        entity._action = entity_base_1.EntityActionType.update;
+        entity.automap(data);
+        return entity;
+    }
+    orphanRemoval(client, entity) {
+        const where = {};
+        Object.keys(entity)
+            .filter((key) => key === 'id' || key.includes('Id'))
+            .forEach((key) => (where[key] = entity[key]));
+        return client[(0, KlString_1.toCamelCase)(entity.constructor.name)].delete({ where });
+    }
+    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;
+    }
+    getPropNameFromEntitySource(source, entity) {
+        return Object.keys(source).find((key) => {
+            if (source[key] instanceof entity_base_1.EntityBase) {
+                return source[key].constructor.name === entity.constructor.name;
+            }
+            else if (source[key] instanceof list_1.List) {
+                const list = source[key];
+                return list.entityType?.name === entity.constructor.name;
+            }
+            return false;
+        });
+    }
+    persistRelations(transaction, entity) {
+        const { relationCreates, relationUpdates, relationDeletes } = this.listToRelationActionList(entity);
+        return Promise.all([
+            ...relationCreates.map((relationCreate) => transaction[relationCreate.modelName]
+                .create(relationCreate.schema)
+                .then((response) => {
+                return Promise.all(relationCreate.relations.map((relation) => {
+                    const relationPropName = this.getPropNameFromEntitySource(entity, relation);
+                    if (!relationPropName) {
+                        throw new Error(`Propname not found for relation entity ${relation.constructor.name} on entity ${entity.constructor.name}`);
+                    }
+                    entity.automap(response);
+                    relation[relationPropName] = entity;
+                    return this.persistRelations(transaction, relation);
+                }));
+            })),
+            ...relationUpdates.map((relation) => transaction[relation.modelName].update(relation.schema)),
+            ...relationDeletes.map((relation) => this.removeMany(relation.schema)),
+        ]);
+    }
     context(transactionalClient) {
         const modelName = this._modelName.name;
         if (!modelName)
@@ -80,12 +257,17 @@ class RepositoryBase {
     async saveChanges(entity, updateWhere) {
         const prismaEntity = this.entityToPrisma(entity);
         if (entity._action === entity_base_1.EntityActionType.create) {
-            return this.context()
+            return this.withTransaction((client) => this.context(client)
                 .create({
                 data: prismaEntity,
                 include: this.getInclude(),
             })
-                .then((response) => this.createEntity(response));
+                .then((response) => {
+                entity[this.getIdPropName()] = response[this.getIdPropName()];
+                return this.persistRelations(client, entity).then(() => entity);
+            })).then((response) => this.findUnique({
+                [this.getIdPropName()]: response[this.getIdPropName()],
+            }));
         }
         else {
             const where = updateWhere ?? { id: entity._id };
@@ -94,13 +276,7 @@ class RepositoryBase {
                 where,
                 data: prismaEntity,
             })
-                .then(() => {
-                const { relationUpdates, relationDeletes } = this.listToRelationActionList(entity);
-                return Promise.all([
-                    ...relationUpdates.map((relation) => client[relation.modelName].updateMany(relation.schema)),
-                    ...relationDeletes.map((relation) => client[relation.modelName].deleteMany(relation.schema)),
-                ]);
-            })).then(() => this.findUnique(where));
+                .then(() => this.persistRelations(client, entity))).then(() => this.findUnique(where));
         }
     }
     async saveMany(entities, updateWhere) {
@@ -160,121 +336,6 @@ class RepositoryBase {
                 .then((response) => Promise.all(relationEntity.map((entity) => this.orphanRemoval(client, entity))).then(() => response));
         }));
     }
-    listToRelationActionList(entity) {
-        const relationUpdates = [];
-        const relationDeletes = [];
-        Object.keys(entity).forEach((key) => {
-            if (entity[key] instanceof list_1.List) {
-                const list = entity[key];
-                const modelName = list.entityType?.name;
-                if (modelName) {
-                    list.toArray('removed').forEach((item) => {
-                        relationDeletes.push({
-                            modelName: (0, KlString_1.toCamelCase)(modelName),
-                            schema: { where: { id: item._id } },
-                        });
-                    });
-                    list.toArray('updated').forEach((item) => {
-                        relationUpdates.push({
-                            modelName: (0, KlString_1.toCamelCase)(modelName),
-                            schema: {
-                                where: { id: item._id },
-                                data: this.entityToPrisma(item),
-                            },
-                        });
-                    });
-                }
-            }
-        });
-        return { relationUpdates, relationDeletes };
-    }
-    entityToPrisma(entity) {
-        const prismaSchema = {};
-        Object.keys(entity)
-            .filter((key) => !['id', '_id', '_action'].includes(key))
-            .filter((key) => !(entity[key] instanceof Function))
-            .forEach((key) => {
-            if (entity[key] instanceof list_1.List) {
-                if (entity[key].toArray('added').length > 0) {
-                    prismaSchema[key] = {
-                        createMany: {
-                            data: entity[key].toArray('added').map((item) => {
-                                return this.entityToPrisma(item);
-                            }),
-                        },
-                    };
-                }
-            }
-            else if (entity[key] instanceof entity_base_1.EntityBase) {
-                if (entity[key]._action === entity_base_1.EntityActionType.create) {
-                    if (entity[key][this.getIdPropName()]) {
-                        prismaSchema[key] = {
-                            connectOrCreate: {
-                                where: {
-                                    [this.getIdPropName()]: entity[key][this.getIdPropName()],
-                                },
-                                create: this.entityToPrisma(entity[key]),
-                            },
-                        };
-                    }
-                    else {
-                        prismaSchema[key] = {
-                            create: this.entityToPrisma(entity[key]),
-                        };
-                    }
-                }
-                else {
-                    prismaSchema[key] = {
-                        update: this.entityToPrisma(entity[key]),
-                    };
-                }
-            }
-            else {
-                prismaSchema[key] = entity[key];
-            }
-        });
-        return prismaSchema;
-    }
-    findManySchema(where, pagination) {
-        return {
-            include: this.getInclude(),
-            where,
-            orderBy: pagination?.generateOrderBy(),
-            skip: pagination?.skip(),
-            take: (pagination?.limit ?? 0) > 0 ? pagination?.limit : undefined,
-        };
-    }
-    createEntity(data) {
-        const entity = new this._modelName();
-        entity._action = entity_base_1.EntityActionType.update;
-        entity.automap(data);
-        return entity;
-    }
-    orphanRemoval(client, entity) {
-        const where = {};
-        Object.keys(entity)
-            .filter((key) => key === 'id' || key.includes('Id'))
-            .forEach((key) => (where[key] = entity[key]));
-        return client[(0, KlString_1.toCamelCase)(entity.constructor.name)].delete({ where });
-    }
-    getIdPropName() {
-        return Reflect.getMetadata('entity:id', 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;
-    }
     withTransaction(fn) {
         return this._context.withTransaction(async (client) => {
             return fn(new koala_global_vars_1.KoalaGlobalVars.dbTransactionContext(client));

package/core/mapping/auto-mapping.service.d.ts

@@ -5,6 +5,7 @@ export declare class AutoMappingService {
     constructor(automappingProfile: AutoMappingProfile);
     private getInstanceType;
     map<S, T>(data: any, source: Type<S>, target: Type<T>): T;
+    private getTarget;
     private mapNestedProp;
     private mapListToArray;
     private mapArrayToList;

package/core/mapping/auto-mapping.service.js

@@ -82,7 +82,7 @@ let AutoMappingService = class AutoMappingService {
         });
         return mappedTarget;
     }
-    mapNestedProp(data, source) {
+    getTarget(data, source) {
         if (this.isPrimitiveType(data)) {
             return data;
         }
@@ -90,7 +90,10 @@ let AutoMappingService = class AutoMappingService {
         if (targets.length === 0) {
             throw new Error(`No mapping context found for ${source.name}`);
         }
-        return this.map(data, source.prototype.constructor, targets[0]);
+        return targets[0];
+    }
+    mapNestedProp(data, source) {
+        return this.map(data, source.prototype.constructor, this.getTarget(data, source));
     }
     mapListToArray(value) {
         return value.toArray().map((item) => {
@@ -102,7 +105,7 @@ let AutoMappingService = class AutoMappingService {
         });
     }
     mapArrayToList(value, compositionType, onlySet = true) {
-        const list = new list_1.List(compositionType.prototype.constructor);
+        const list = new list_1.List(this.getTarget(value, compositionType.prototype.constructor));
         const mappedValue = value.map((item) => this.mapNestedProp(item, compositionType.prototype.constructor) ?? {});
         if (onlySet) {
             list.setList(mappedValue);

package/package.json

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