@koalarx/nest 1.6.3 → 1.7.0

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

@@ -1,14 +1,19 @@
 import { IComparable, IComparableId } from '../utils/interfaces/icomparable';
 import { Overwrite } from '..';
+export declare enum EntityActionType {
+    create = 1,
+    update = 2
+}
 export type EntityProps<T extends IComparable<T>> = Overwrite<Omit<{
     [K in keyof T as T[K] extends Function ? never : K]: T[K];
-}, '_id'>, {
+}, '_id' | '_action'>, {
     id?: T extends {
         id: infer U;
     } ? U : never;
 }>;
 export declare abstract class EntityBase<T extends IComparable<T>> implements IComparable<T> {
     _id: IComparableId;
+    _action: EntityActionType;
     automap(props?: EntityProps<T>): void;
     equals(obj: EntityBase<T>): boolean;
 }

package/core/database/entity.base.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityBase = void 0;
+exports.EntityBase = exports.EntityActionType = void 0;
 const auto_mapping_list_1 = require("../mapping/auto-mapping-list");
 const list_1 = require("../utils/list");
+var EntityActionType;
+(function (EntityActionType) {
+    EntityActionType[EntityActionType["create"] = 1] = "create";
+    EntityActionType[EntityActionType["update"] = 2] = "update";
+})(EntityActionType || (exports.EntityActionType = EntityActionType = {}));
 class EntityBase {
     _id;
+    _action = EntityActionType.create;
     automap(props) {
         if (props) {
             for (const key of Object.keys(props)) {
@@ -18,6 +24,7 @@ class EntityBase {
                     if (this[key].entityType) {
                         value = value.map((item) => {
                             const entity = new this[key].entityType();
+                            entity._action = this._action;
                             entity.automap(item);
                             return entity;
                         });
@@ -26,6 +33,7 @@ class EntityBase {
                 }
                 else if (EntityOnPropKey) {
                     const entity = new EntityOnPropKey();
+                    entity._action = this._action;
                     entity.automap(props[key]);
                     this[key] = entity;
                 }

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

@@ -24,8 +24,7 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>
     protected findUnique<T>(where: T): Promise<any>;
     protected findMany<T>(where: T, pagination?: PaginationDto): Promise<any>;
     protected findManyAndCount<T>(where: T, pagination?: PaginationDto): Promise<ListResponse<TEntity>>;
-    protected insert(entity: TEntity): any;
-    protected edit<TWhere = any>(entity: TEntity, updateWhere?: TWhere): Promise<any>;
+    protected saveChanges<TWhere = any>(entity: TEntity, updateWhere?: TWhere): any;
     protected remove<TWhere = any>(where: TWhere, externalServices?: Promise<any>): Promise<any>;
     private listToRelationActionList;
     private entityToPrisma;

package/core/database/repository.base.js

@@ -72,26 +72,27 @@ class RepositoryBase {
         }
         return { items: [], count };
     }
-    insert(entity) {
-        const prismaEntity = this.entityToPrisma(entity, true);
-        return this.context().create({
-            data: prismaEntity,
-        });
-    }
-    edit(entity, updateWhere) {
-        const prismaEntity = this.entityToPrisma(entity, false);
-        return this.withTransaction((client) => this.context(client)
-            .update({
-            where: updateWhere ?? { id: entity._id },
-            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)),
-            ]);
-        }));
+    saveChanges(entity, updateWhere) {
+        const prismaEntity = this.entityToPrisma(entity);
+        if (entity._action === entity_base_1.EntityActionType.create) {
+            return this.context().create({
+                data: prismaEntity,
+            });
+        }
+        else {
+            return this.withTransaction((client) => this.context(client)
+                .update({
+                where: updateWhere ?? { id: entity._id },
+                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)),
+                ]);
+            }));
+        }
     }
     async remove(where, externalServices) {
         const entity = await this.findUnique(where);
@@ -126,7 +127,7 @@ class RepositoryBase {
                             modelName: (0, string_1.toCamelCase)(modelName),
                             schema: {
                                 where: { id: item._id },
-                                data: this.entityToPrisma(item, false),
+                                data: this.entityToPrisma(item),
                             },
                         });
                     });
@@ -135,10 +136,10 @@ class RepositoryBase {
         });
         return { relationUpdates, relationDeletes };
     }
-    entityToPrisma(entity, isCreate) {
+    entityToPrisma(entity) {
         const prismaSchema = {};
         Object.keys(entity)
-            .filter((key) => !['id', '_id'].includes(key))
+            .filter((key) => !['id', '_id', '_action'].includes(key))
             .filter((key) => !(entity[key] instanceof Function))
             .forEach((key) => {
             if (entity[key] instanceof list_1.List) {
@@ -146,16 +147,17 @@ class RepositoryBase {
                     prismaSchema[key] = {
                         createMany: {
                             data: entity[key].toArray('added').map((item) => {
-                                return this.entityToPrisma(item, isCreate);
+                                return this.entityToPrisma(item);
                             }),
                         },
                     };
                 }
             }
             else if (entity[key] instanceof entity_base_1.EntityBase) {
-                prismaSchema[key] = isCreate
-                    ? { create: this.entityToPrisma(entity[key], isCreate) }
-                    : { update: this.entityToPrisma(entity[key], isCreate) };
+                prismaSchema[key] =
+                    entity[key]._action === entity_base_1.EntityActionType.create
+                        ? { create: this.entityToPrisma(entity[key]) }
+                        : { update: this.entityToPrisma(entity[key]) };
             }
             else {
                 prismaSchema[key] = entity[key];
@@ -183,6 +185,7 @@ class RepositoryBase {
     }
     createEntity(data) {
         const entity = new this._modelName();
+        entity._action = entity_base_1.EntityActionType.update;
         entity.automap(data);
         return entity;
     }

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

@@ -21,5 +21,6 @@ export declare class AutoMappingList {
     } | null | undefined;
     static getTargets(source: Type<any>): Type<any>[];
     static addMappedProp(source: Type<any>, propName: string): void;
+    static addExtendedPropsIntoSubClass(source: Type<any>): void;
 }
 export {};

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

@@ -11,17 +11,23 @@ class AutoMappingList {
         this._mappingProfileList.add(new auto_mapping_context_1.AutoMappingContext(source, target, forMember));
         this._mappedPropList.add(new auto_mapping_class_context_1.AutoMappingClassContext(source));
         this._mappedPropList.add(new auto_mapping_class_context_1.AutoMappingClassContext(target));
+        this.addExtendedPropsIntoSubClass(source);
+        this.addExtendedPropsIntoSubClass(target);
     }
     static get(source, target) {
         return {
-            mapContext: this._mappingProfileList.find((mp) => mp.source === source && mp.target === target),
+            mapContext: this._mappingProfileList.find((mp) => (mp.source === source ||
+                Object.getPrototypeOf(mp.source.prototype.constructor) ===
+                    source) &&
+                mp.target === target),
             propSourceContext: this._mappedPropList.find((mp) => mp.source === source),
             propTargetContext: this._mappedPropList.find((mp) => mp.source === target),
         };
     }
     static getSourceByName(sourceName) {
-        return this._mappingProfileList.find((mp) => mp.source.name === sourceName)
-            ?.source;
+        return this._mappingProfileList.find((mp) => mp.source.name === sourceName ||
+            Object.getPrototypeOf(mp.source.prototype.constructor).name ===
+                sourceName)?.source;
     }
     static getPropDefinitions(source, propName) {
         return this._mappedPropList
@@ -30,7 +36,8 @@ class AutoMappingList {
     }
     static getTargets(source) {
         return this._mappingProfileList
-            .filter((mp) => mp.source === source)
+            .filter((mp) => mp.source === source ||
+            Object.getPrototypeOf(mp.source.prototype.constructor) === source)
             .map((mp) => mp.target)
             .toArray();
     }
@@ -38,6 +45,10 @@ class AutoMappingList {
         let mappedClass = this._mappedPropList.find((mp) => mp.source === source);
         if (!mappedClass) {
             mappedClass = new auto_mapping_class_context_1.AutoMappingClassContext(source);
+            const mappedExtendedClass = this._mappedPropList.find((mp) => mp.source === Object.getPrototypeOf(source.prototype.constructor));
+            if (mappedExtendedClass) {
+                mappedClass.props.setList(mappedExtendedClass.props.toArray());
+            }
             this._mappedPropList.add(mappedClass);
         }
         const metadata = Reflect.getMetadata('design:type', source.prototype, propName);
@@ -51,5 +62,16 @@ class AutoMappingList {
             compositionAction,
         });
     }
+    static addExtendedPropsIntoSubClass(source) {
+        const mappedExtendedClass = this._mappedPropList.find((mp) => mp.source === Object.getPrototypeOf(source.prototype.constructor));
+        if (mappedExtendedClass) {
+            const mappedClass = this._mappedPropList.find((mp) => mp.source === source);
+            if (mappedClass) {
+                mappedExtendedClass.props
+                    .toArray()
+                    .forEach((prop) => mappedClass.props.add(prop));
+            }
+        }
+    }
 }
 exports.AutoMappingList = AutoMappingList;

package/core/utils/list.js

@@ -46,7 +46,6 @@ class List {
             this._list.splice(index, 1);
             if (!this.contains(item, this._removedItemsList)) {
                 this._removedItemsList.push(item);
-                console.log(this._removedItemsList);
             }
         }
         return this;

package/package.json

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

package/test/repositories/in-memory-base.repository.d.ts

@@ -1,5 +1,4 @@
 import { PaginationDto } from '@koalarx/nest/core/dtos/pagination.dto';
-import { CreatedRegistreResponseBase } from '../../core/controllers/created-registre-response.base';
 import { ListResponseBase } from '../../core/controllers/list-response.base';
 import { EntityBase } from '../../core/database/entity.base';
 import { IComparableId } from '../../core/utils/interfaces/icomparable';
@@ -10,8 +9,9 @@ export declare abstract class InMemoryBaseRepository<TClass extends EntityBase<a
     protected findById(id: IComparableId): Promise<TClass | null>;
     protected findMany<T extends PaginationDto>(query: T, predicate?: (value: TClass, index: number, array: TClass[]) => unknown): Promise<TClass[]>;
     protected findManyAndCount<T extends PaginationDto>(query: T, predicate?: (value: TClass, index: number, array: TClass[]) => unknown): Promise<ListResponseBase<TClass>>;
-    protected insert(item: TClass): Promise<CreatedRegistreResponseBase<any>>;
-    protected edit(item: TClass, updateWhere?: (item: TClass) => boolean): Promise<void>;
+    protected saveChanges(item: TClass, updateWhere?: (item: TClass) => boolean): Promise<{
+        id: IComparableId;
+    } | undefined>;
     protected remove(predicate: (value: TClass, index: number, obj: TClass[]) => unknown): Promise<void>;
     private getNewId;
 }

package/test/repositories/in-memory-base.repository.js

@@ -4,6 +4,7 @@ exports.InMemoryBaseRepository = void 0;
 const query_params_1 = require("../../core/constants/query-params");
 const array_1 = require("@koalarx/utils/operators/array");
 const node_crypto_1 = require("node:crypto");
+const entity_base_1 = require("../../core/database/entity.base");
 class InMemoryBaseRepository {
     typeId;
     items = [];
@@ -11,7 +12,11 @@ class InMemoryBaseRepository {
         this.typeId = typeId;
     }
     async findById(id) {
-        return this.items.find((item) => item._id === id) ?? null;
+        const entity = this.items.find((item) => item._id === id) ?? null;
+        if (entity) {
+            entity._action = entity_base_1.EntityActionType.update;
+        }
+        return entity;
     }
     async findMany(query, predicate) {
         const page = query.page ?? query_params_1.QUERY_FILTER_PARAMS.page;
@@ -19,7 +24,11 @@ class InMemoryBaseRepository {
         return (0, array_1.klArray)(predicate ? this.items.filter(predicate) : this.items)
             .orderBy(query.orderBy ?? '', query.direction === 'desc')
             .getValue()
-            .slice(page * limit, (page + 1) * limit);
+            .slice(page * limit, (page + 1) * limit)
+            .map((item) => {
+            item._action = entity_base_1.EntityActionType.update;
+            return item;
+        });
     }
     async findManyAndCount(query, predicate) {
         const items = await this.findMany(query, predicate);
@@ -28,13 +37,13 @@ class InMemoryBaseRepository {
             count: items.length,
         };
     }
-    async insert(item) {
-        const id = this.typeId === 'number' ? this.getNewId() : (0, node_crypto_1.randomUUID)();
-        item.automap({ ...item, id });
-        this.items.push(item);
-        return { id: item._id };
-    }
-    async edit(item, updateWhere) {
+    async saveChanges(item, updateWhere) {
+        if (item._action === entity_base_1.EntityActionType.create) {
+            const id = this.typeId === 'number' ? this.getNewId() : (0, node_crypto_1.randomUUID)();
+            item.automap({ ...item, id });
+            this.items.push(item);
+            return { id: item._id };
+        }
         const predicate = updateWhere ?? ((itemDB) => itemDB.equals(item));
         const itemIndex = this.items.findIndex(predicate);
         if (itemIndex > -1) {