@koalarx/nest 1.6.4 → 1.8.0

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

@@ -1,14 +1,20 @@
-import { IComparable, IComparableId } from '../utils/interfaces/icomparable';
 import { Overwrite } from '..';
+import { IComparable, IComparableId } from '../utils/interfaces/icomparable';
+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;
+    constructor(props?: EntityProps<T>);
     automap(props?: EntityProps<T>): void;
     equals(obj: EntityBase<T>): boolean;
 }

package/core/database/entity.base.js

@@ -1,10 +1,21 @@
 "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;
+    constructor(props) {
+        if (props) {
+            this.automap(props);
+        }
+    }
     automap(props) {
         if (props) {
             for (const key of Object.keys(props)) {
@@ -17,16 +28,16 @@ class EntityBase {
                     let value = props[key];
                     if (this[key].entityType) {
                         value = value.map((item) => {
-                            const entity = new this[key].entityType();
-                            entity.automap(item);
+                            const entity = new this[key].entityType(item);
+                            entity._action = this._action;
                             return entity;
                         });
                     }
                     this[key].setList(value);
                 }
                 else if (EntityOnPropKey) {
-                    const entity = new EntityOnPropKey();
-                    entity.automap(props[key]);
+                    const entity = new EntityOnPropKey(props[key]);
+                    entity._action = this._action;
                     this[key] = entity;
                 }
                 else if (propDefinitions) {

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

@@ -0,0 +1,9 @@
+import { EntityBase } from './entity.base';
+export declare function Entity<T extends new (...args: any[]) => EntityBase<any>>(): (target: T) => {
+    new (...args: any[]): {
+        _id: import("../utils/interfaces/icomparable").IComparableId;
+        _action: import("./entity.base").EntityActionType;
+        automap(props?: import("./entity.base").EntityProps<any> | undefined): void;
+        equals(obj: EntityBase<any>): boolean;
+    };
+} & T;

package/core/database/entity.decorator.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+function Entity() {
+    return function (target) {
+        const originalConstructor = target;
+        class NewConstructor extends target {
+            constructor(...args) {
+                super(...args);
+                if (typeof this.automap === 'function') {
+                    this.automap(args[0]);
+                }
+            }
+        }
+        const newConstructor = function (...args) {
+            const instance = Reflect.construct(originalConstructor, args, newConstructor);
+            if (typeof instance.automap === 'function') {
+                instance.automap(args[0]);
+            }
+            return instance;
+        };
+        Object.setPrototypeOf(NewConstructor.prototype, target.prototype);
+        Object.setPrototypeOf(NewConstructor, target);
+        Object.defineProperty(NewConstructor, 'name', {
+            value: target.name,
+            writable: false,
+        });
+        return NewConstructor;
+    };
+}
+exports.Entity = Entity;

package/core/database/entity.decorator.spec.d.ts

@@ -0,0 +1,17 @@
+import { List } from '../utils/list';
+import { EntityBase } from './entity.base';
+export declare class PersonAddress extends EntityBase<PersonAddress> {
+    id: number;
+    address: string;
+}
+export declare class PersonPhone extends EntityBase<PersonPhone> {
+    id: number;
+    phone: string;
+}
+export declare class Person extends EntityBase<Person> {
+    id: number;
+    name: string;
+    phones: List<PersonPhone>;
+    address: PersonAddress;
+    active: boolean;
+}

package/core/database/entity.decorator.spec.js

@@ -0,0 +1,104 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Person = exports.PersonPhone = exports.PersonAddress = void 0;
+const faker_1 = require("@faker-js/faker");
+const auto_mapping_decorator_1 = require("../mapping/auto-mapping.decorator");
+const list_1 = require("../utils/list");
+const entity_base_1 = require("./entity.base");
+const entity_decorator_1 = require("./entity.decorator");
+let PersonAddress = exports.PersonAddress = class PersonAddress extends entity_base_1.EntityBase {
+    id;
+    address;
+};
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", Number)
+], PersonAddress.prototype, "id", void 0);
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", String)
+], PersonAddress.prototype, "address", void 0);
+exports.PersonAddress = PersonAddress = __decorate([
+    (0, entity_decorator_1.Entity)()
+], PersonAddress);
+let PersonPhone = exports.PersonPhone = class PersonPhone extends entity_base_1.EntityBase {
+    id;
+    phone;
+};
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", Number)
+], PersonPhone.prototype, "id", void 0);
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", String)
+], PersonPhone.prototype, "phone", void 0);
+exports.PersonPhone = PersonPhone = __decorate([
+    (0, entity_decorator_1.Entity)()
+], PersonPhone);
+let Person = exports.Person = class Person extends entity_base_1.EntityBase {
+    id;
+    name;
+    phones = new list_1.List(PersonPhone);
+    address;
+    active;
+};
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", Number)
+], Person.prototype, "id", void 0);
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", String)
+], Person.prototype, "name", void 0);
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)({ type: list_1.List }),
+    __metadata("design:type", Object)
+], Person.prototype, "phones", void 0);
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)({ type: PersonAddress }),
+    __metadata("design:type", PersonAddress)
+], Person.prototype, "address", void 0);
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", Boolean)
+], Person.prototype, "active", void 0);
+exports.Person = Person = __decorate([
+    (0, entity_decorator_1.Entity)()
+], Person);
+describe('Entity decorator', () => {
+    it('should create an instance of Person', () => {
+        const phones = new list_1.List(PersonPhone);
+        phones.setList([
+            new PersonPhone({ phone: faker_1.faker.phone.number() }),
+            new PersonPhone({ phone: faker_1.faker.phone.number() }),
+        ]);
+        const person = new Person({
+            name: faker_1.faker.person.fullName(),
+            phones,
+            address: new PersonAddress({ address: faker_1.faker.location.streetAddress() }),
+            active: true,
+        });
+        expect(person).toBeInstanceOf(Person);
+        expect(person).toBeInstanceOf(entity_base_1.EntityBase);
+        expect(person.constructor.name).toBe('Person');
+        expect(person.phones).toBeInstanceOf(list_1.List);
+        expect(person.phones.toArray()[0]).toBeInstanceOf(PersonPhone);
+        expect(person.phones.toArray()[1]).toBeInstanceOf(PersonPhone);
+        expect(person.phones.toArray()[0].phone).toBeDefined();
+        expect(person.phones.toArray()[1].phone).toBeDefined();
+        expect(person.address).toBeInstanceOf(PersonAddress);
+        expect(person.address.address).toBeDefined();
+        expect(person.name).toBeDefined();
+        expect(person.active).toBe(true);
+    });
+});

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

@@ -1,6 +1,6 @@
 import { Type } from '@nestjs/common';
-import { AutoMappingContext } from './auto-mapping-context';
 import { AutoMappingClassContext } from './auto-mapping-class-context';
+import { AutoMappingContext } from './auto-mapping-context';
 import { ForMemberDefinition } from './for-member';
 interface AutoMappingGetContext {
     mapContext: AutoMappingContext | null;

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoMappingList = void 0;
 const list_1 = require("../utils/list");
-const auto_mapping_context_1 = require("./auto-mapping-context");
 const auto_mapping_class_context_1 = require("./auto-mapping-class-context");
+const auto_mapping_context_1 = require("./auto-mapping-context");
 class AutoMappingList {
     static _mappedPropList = new list_1.List(auto_mapping_class_context_1.AutoMappingClassContext);
     static _mappingProfileList = new list_1.List(auto_mapping_context_1.AutoMappingContext);
@@ -31,7 +31,7 @@ class AutoMappingList {
     }
     static getPropDefinitions(source, propName) {
         return this._mappedPropList
-            .find((mp) => mp.source === source)
+            .find((mp) => mp.source.name === source.name)
             ?.props.find((prop) => prop.name === propName);
     }
     static getTargets(source) {

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/core/utils/list.spec.js

@@ -10,16 +10,13 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const entity_base_1 = require("../database/entity.base");
+const entity_decorator_1 = require("../database/entity.decorator");
 const auto_mapping_decorator_1 = require("../mapping/auto-mapping.decorator");
 const list_1 = require("./list");
-class EntityTest extends entity_base_1.EntityBase {
+let EntityTest = class EntityTest extends entity_base_1.EntityBase {
     id;
     value;
-    constructor(props) {
-        super();
-        this.automap(props);
-    }
-}
+};
 __decorate([
     (0, auto_mapping_decorator_1.AutoMap)(),
     __metadata("design:type", Number)
@@ -28,6 +25,9 @@ __decorate([
     (0, auto_mapping_decorator_1.AutoMap)(),
     __metadata("design:type", Number)
 ], EntityTest.prototype, "value", void 0);
+EntityTest = __decorate([
+    (0, entity_decorator_1.Entity)()
+], EntityTest);
 describe('List test', () => {
     let entity;
     beforeEach(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalarx/nest",
-  "version": "1.6.4",
+  "version": "1.8.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) {