@koalarx/nest 0.1.0 → 1.0.0

package/core/koala-nest-http.module.js

@@ -9,9 +9,8 @@ var KoalaNestHttpModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KoalaNestHttpModule = void 0;
 const common_1 = require("@nestjs/common");
-const automapper_classes_1 = require("automapper-classes");
-const automapper_nestjs_1 = require("automapper-nestjs");
-const env_service_1 = require("../services/env/env.service");
+const env_service_1 = require("../env/env.service");
+const auto_mapping_module_1 = require("./mapping/auto-mapping.module");
 let KoalaNestHttpModule = exports.KoalaNestHttpModule = class KoalaNestHttpModule {
     static { KoalaNestHttpModule_1 = this; }
     static _config;
@@ -19,12 +18,9 @@ let KoalaNestHttpModule = exports.KoalaNestHttpModule = class KoalaNestHttpModul
         this._config = config;
         return {
             module: KoalaNestHttpModule_1,
-            imports: [
-                automapper_nestjs_1.AutomapperModule.forRoot({
-                    strategyInitializer: (0, automapper_classes_1.classes)(),
-                }),
-            ],
-            providers: [config.automapperProfile, env_service_1.EnvService],
+            imports: [auto_mapping_module_1.AutoMappingModule.register(config.automapperProfile)],
+            providers: [env_service_1.EnvService],
+            exports: [auto_mapping_module_1.AutoMappingModule],
         };
     }
     configure(consumer) {

package/core/koala-nest.module.js

@@ -10,9 +10,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.KoalaNestModule = void 0;
 const common_1 = require("@nestjs/common");
 const config_1 = require("@nestjs/config");
-const env_1 = require("../services/env/env");
-const env_module_1 = require("../services/env/env.module");
-const env_service_1 = require("../services/env/env.service");
+const env_1 = require("../env/env");
+const env_module_1 = require("../env/env.module");
+const env_service_1 = require("../env/env.service");
 const ilogging_service_1 = require("../services/logging/ilogging.service");
 const logging_service_1 = require("../services/logging/logging.service");
 const iredis_service_1 = require("../services/redis/iredis.service");
@@ -39,6 +39,7 @@ let KoalaNestModule = exports.KoalaNestModule = KoalaNestModule_1 = class KoalaN
                 { provide: ired_lock_service_1.IRedLockService, useClass: red_lock_service_1.RedLockService },
                 env_service_1.EnvService,
             ],
+            exports: [ilogging_service_1.ILoggingService, iredis_service_1.IRedisService, ired_lock_service_1.IRedLockService],
         };
     }
 };

package/core/mapping/auto-mapping-class-context.d.ts

@@ -0,0 +1,15 @@
+import { Type } from '@nestjs/common';
+import { IComparable, IComparableId } from '../utils/interfaces/icomparable';
+import { List } from '../utils/list';
+export declare class AutoMappingClassContext implements IComparable<AutoMappingClassContext> {
+    _id: IComparableId;
+    source: Type<any>;
+    props: List<{
+        name: string;
+        type: any;
+        compositionType?: Type<any> | undefined;
+        compositionAction?: "onlySet" | "addTo" | undefined;
+    }>;
+    constructor(source: Type<any>);
+    equals(obj: AutoMappingClassContext): boolean;
+}

package/core/mapping/auto-mapping-class-context.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMappingClassContext = void 0;
+const list_1 = require("../utils/list");
+const crypto_1 = require("crypto");
+class AutoMappingClassContext {
+    _id;
+    source;
+    props = new list_1.List();
+    constructor(source) {
+        this._id = (0, crypto_1.randomUUID)();
+        this.source = source;
+    }
+    equals(obj) {
+        return obj._id === this._id && this.source instanceof obj.source;
+    }
+}
+exports.AutoMappingClassContext = AutoMappingClassContext;

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

@@ -0,0 +1,11 @@
+import { Type } from '@nestjs/common';
+import { IComparable, IComparableId } from '../utils/interfaces/icomparable';
+import { ForMemberDefinition } from './for-member';
+export declare class AutoMappingContext implements IComparable<AutoMappingContext> {
+    source: Type<any>;
+    target: Type<any>;
+    forMemberDifinitions: ForMemberDefinition<any, any>;
+    _id: IComparableId;
+    constructor(source: Type<any>, target: Type<any>, forMemberDifinitions: ForMemberDefinition<any, any>);
+    equals(obj: AutoMappingContext): boolean;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMappingContext = void 0;
+const node_crypto_1 = require("node:crypto");
+class AutoMappingContext {
+    source;
+    target;
+    forMemberDifinitions;
+    _id;
+    constructor(source, target, forMemberDifinitions) {
+        this.source = source;
+        this.target = target;
+        this.forMemberDifinitions = forMemberDifinitions;
+        this._id = (0, node_crypto_1.randomUUID)();
+        this.source = source;
+        this.target = target;
+    }
+    equals(obj) {
+        return (obj._id === this._id &&
+            this.source instanceof obj.source &&
+            this.target instanceof obj.target);
+    }
+}
+exports.AutoMappingContext = AutoMappingContext;

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

@@ -0,0 +1,18 @@
+import { Type } from '@nestjs/common';
+import { AutoMappingContext } from './auto-mapping-context';
+import { AutoMappingClassContext } from './auto-mapping-class-context';
+import { ForMemberDefinition } from './for-member';
+interface AutoMappingGetContext {
+    mapContext: AutoMappingContext | null;
+    propSourceContext: AutoMappingClassContext | null;
+    propTargetContext: AutoMappingClassContext | null;
+}
+export declare class AutoMappingList {
+    private static _mappedPropList;
+    private static _mappingProfileList;
+    static add(source: Type<any>, target: Type<any>, ...forMember: ForMemberDefinition<any, any>): void;
+    static get(source: Type<any>, target: Type<any>): AutoMappingGetContext;
+    static getTargets(source: Type<any>): Type<any>[];
+    static addMappedProp(source: Type<any>, propName: string): void;
+}
+export {};

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

@@ -0,0 +1,46 @@
+"use strict";
+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");
+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);
+    static add(source, target, ...forMember) {
+        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));
+    }
+    static get(source, target) {
+        return {
+            mapContext: this._mappingProfileList.find((mp) => mp.source === source && mp.target === target),
+            propSourceContext: this._mappedPropList.find((mp) => mp.source === source),
+            propTargetContext: this._mappedPropList.find((mp) => mp.source === target),
+        };
+    }
+    static getTargets(source) {
+        return this._mappingProfileList
+            .filter((mp) => mp.source === source)
+            .map((mp) => mp.target)
+            .toArray();
+    }
+    static addMappedProp(source, propName) {
+        let mappedClass = this._mappedPropList.find((mp) => mp.source === source);
+        if (!mappedClass) {
+            mappedClass = new auto_mapping_class_context_1.AutoMappingClassContext(source);
+            this._mappedPropList.add(mappedClass);
+        }
+        const metadata = Reflect.getMetadata('design:type', source.prototype, propName);
+        const compositionType = Reflect.getMetadata('composition:type', source.prototype, propName);
+        const compositionAction = Reflect.getMetadata('composition:action', source.prototype, propName);
+        const type = metadata?.name;
+        mappedClass.props.add({
+            name: propName,
+            type,
+            compositionType,
+            compositionAction,
+        });
+    }
+}
+exports.AutoMappingList = AutoMappingList;

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

@@ -0,0 +1,3 @@
+export declare abstract class AutoMappingProfile {
+    abstract profile(): void;
+}

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMappingProfile = void 0;
+class AutoMappingProfile {
+}
+exports.AutoMappingProfile = AutoMappingProfile;

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

@@ -0,0 +1,9 @@
+import { Type } from '@nestjs/common';
+interface AutoMapConfig<T> {
+    type?: Type<T>;
+    isArray?: boolean | {
+        addTo: boolean;
+    };
+}
+export declare function AutoMap<T>(config?: AutoMapConfig<T>): (target: any, propertyKey: string) => void;
+export {};

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMap = void 0;
+const auto_mapping_list_1 = require("./auto-mapping-list");
+function AutoMap(config) {
+    return function (target, propertyKey) {
+        const isArray = config?.isArray;
+        let customMetadata = config?.type;
+        if (!customMetadata) {
+            customMetadata = isArray ? Array : undefined;
+        }
+        if (customMetadata) {
+            if (isArray) {
+                Reflect.defineMetadata('composition:type', customMetadata, target, propertyKey);
+                Reflect.defineMetadata('composition:action', `${isArray === true || !isArray.addTo ? 'onlySet' : 'addTo'}`, target, propertyKey);
+                if (customMetadata !== Array) {
+                    customMetadata = Array;
+                }
+            }
+            if (!Reflect.getMetadata('design:type', target, propertyKey) || !isArray) {
+                Reflect.defineMetadata('design:type', customMetadata, target, propertyKey);
+            }
+        }
+        auto_mapping_list_1.AutoMappingList.addMappedProp(target.constructor, propertyKey);
+    };
+}
+exports.AutoMap = AutoMap;

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

@@ -0,0 +1,5 @@
+import { DynamicModule, Type } from '@nestjs/common';
+import { AutoMappingProfile } from './auto-mapping-profile';
+export declare class AutoMappingModule {
+    static register(profile: Type<AutoMappingProfile>): DynamicModule;
+}

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

@@ -0,0 +1,28 @@
+"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 AutoMappingModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMappingModule = void 0;
+const common_1 = require("@nestjs/common");
+const auto_mapping_profile_1 = require("./auto-mapping-profile");
+const auto_mapping_service_1 = require("./auto-mapping.service");
+let AutoMappingModule = exports.AutoMappingModule = AutoMappingModule_1 = class AutoMappingModule {
+    static register(profile) {
+        return {
+            module: AutoMappingModule_1,
+            providers: [
+                { provide: auto_mapping_profile_1.AutoMappingProfile, useClass: profile },
+                auto_mapping_service_1.AutoMappingService,
+            ],
+            exports: [auto_mapping_service_1.AutoMappingService],
+        };
+    }
+};
+exports.AutoMappingModule = AutoMappingModule = AutoMappingModule_1 = __decorate([
+    (0, common_1.Module)({})
+], AutoMappingModule);

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

@@ -0,0 +1,10 @@
+import { Type } from '@nestjs/common';
+import { AutoMappingProfile } from './auto-mapping-profile';
+export declare class AutoMappingService {
+    private readonly _contextList;
+    constructor(automappingProfile: AutoMappingProfile);
+    map<S, T>(data: any, source: Type<S>, target: Type<T>): T;
+    private mapNestedProp;
+    private mapListToArray;
+    private mapArrayToList;
+}

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

@@ -0,0 +1,93 @@
+"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.AutoMappingService = void 0;
+const common_1 = require("@nestjs/common");
+const list_1 = require("../utils/list");
+const auto_mapping_list_1 = require("./auto-mapping-list");
+const auto_mapping_profile_1 = require("./auto-mapping-profile");
+let AutoMappingService = exports.AutoMappingService = class AutoMappingService {
+    _contextList = auto_mapping_list_1.AutoMappingList;
+    constructor(automappingProfile) {
+        automappingProfile.profile();
+    }
+    map(data, source, target) {
+        const { mapContext, propSourceContext, propTargetContext } = this._contextList.get(source, target);
+        if (!mapContext) {
+            throw new Error(`No mapping context found for ${source.name} to ${target.name}`);
+        }
+        const mappedTarget = new target.prototype.constructor();
+        propSourceContext?.props.forEach((propSource) => {
+            const value = data[propSource.name];
+            const compositionType = propSource.compositionType;
+            const compositionAction = propSource.compositionAction;
+            if (value) {
+                const targetProp = propTargetContext?.props.find((tp) => tp.name === propSource.name);
+                if (targetProp) {
+                    const listToArray = propSource.type === list_1.List.name &&
+                        targetProp.type === Array.name &&
+                        value instanceof list_1.List;
+                    const arrayToList = propSource.type === Array.name &&
+                        targetProp.type === list_1.List.name &&
+                        value instanceof Array &&
+                        !!compositionType;
+                    let mappedValue = value;
+                    if (listToArray) {
+                        mappedValue = this.mapListToArray(value);
+                    }
+                    else if (arrayToList) {
+                        mappedValue = this.mapArrayToList(value, compositionType, compositionAction === 'onlySet');
+                    }
+                    mappedTarget[targetProp.name] = mappedValue;
+                }
+            }
+        });
+        Object.keys(mappedTarget).forEach((key) => {
+            const formMemberDefinition = mapContext.forMemberDifinitions?.find((def) => def[key])?.[key];
+            if (formMemberDefinition) {
+                mappedTarget[key] = formMemberDefinition(data);
+            }
+        });
+        return mappedTarget;
+    }
+    mapNestedProp(data, source) {
+        const targets = this._contextList.getTargets(source.prototype.constructor);
+        if (targets.length >= 1) {
+            return this.map(data, source.prototype.constructor, targets[0]);
+        }
+    }
+    mapListToArray(value) {
+        return value
+            .toArray()
+            .map((item) => {
+            const entityOnList = value.entityType?.prototype.constructor;
+            if (entityOnList) {
+                return this.mapNestedProp(item, entityOnList) ?? {};
+            }
+            return {};
+        });
+    }
+    mapArrayToList(value, compositionType, onlySet = true) {
+        const list = new list_1.List(compositionType.prototype.constructor);
+        const mappedValue = value.map((item) => this.mapNestedProp(item, compositionType.prototype.constructor) ?? {});
+        if (onlySet) {
+            list.setList(mappedValue);
+        }
+        else {
+            list.update(mappedValue);
+        }
+        return list;
+    }
+};
+exports.AutoMappingService = AutoMappingService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [auto_mapping_profile_1.AutoMappingProfile])
+], AutoMappingService);

package/core/mapping/create-map.d.ts

@@ -0,0 +1,3 @@
+import { Type } from '@nestjs/common';
+import { ForMemberDefinition } from './for-member';
+export declare function createMap<TSource, TTarget>(source: Type<TSource>, target: Type<TTarget>, ...formMember: ForMemberDefinition<TTarget, TSource>): void;

package/core/mapping/create-map.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMap = void 0;
+const auto_mapping_list_1 = require("./auto-mapping-list");
+function createMap(source, target, ...formMember) {
+    auto_mapping_list_1.AutoMappingList.add(source, target, ...formMember);
+}
+exports.createMap = createMap;

package/core/mapping/for-member.d.ts

@@ -0,0 +1,5 @@
+export type ForMemberResult<TTarget, TSource> = {
+    [Key in keyof TTarget]: (source: TSource) => TTarget[Key];
+};
+export type ForMemberDefinition<TTarget, TSource> = Array<Partial<ForMemberResult<TTarget, TSource>>>;
+export declare function forMember<TTarget, TSource>(targetProp: keyof TTarget, map: (source: TSource) => TTarget[keyof TTarget]): Partial<ForMemberResult<TTarget, TSource>>;

package/core/mapping/for-member.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forMember = void 0;
+function forMember(targetProp, map) {
+    return {
+        [targetProp]: map,
+    };
+}
+exports.forMember = forMember;

package/{common → core}/models/pagination-params.d.ts

@@ -4,6 +4,9 @@ export declare const QueryFilterParams: {
     page: number;
     limit: number;
 };
+export type PaginatedRequestProps<T extends PaginationParams> = Omit<{
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+}, '_id'>;
 export declare class PaginationParams {
     page?: number;
     limit?: number;

package/{common/mediator → core/request-overflow}/request-handler.base.d.ts

@@ -1,4 +1,4 @@
-import { RequestResult } from '../../common/mediator/request-result';
+import { RequestResult } from './request-result';
 export declare abstract class RequestHandlerBase<TRequest, TResponse extends RequestResult<Error, any>> {
     abstract handle(req: TRequest): Promise<TResponse>;
 }

package/core/request-overflow/request-result.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/core/request-overflow/request-result.spec.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_result_1 = require("./request-result");
+function doSometing(shouldSuccess) {
+    if (shouldSuccess) {
+        return (0, request_result_1.ok)(10);
+    }
+    else {
+        return (0, request_result_1.failure)('error');
+    }
+}
+test('success result', () => {
+    const result = doSometing(true);
+    expect(result.isOk()).toBe(true);
+    expect(result.isFailure()).toBe(false);
+});
+test('error result', () => {
+    const result = doSometing(false);
+    expect(result.isFailure()).toBe(true);
+    expect(result.isOk()).toBe(false);
+});

package/{common/mediator → core/request-overflow}/request-validator.base.d.ts

@@ -2,6 +2,6 @@ import { ZodType } from 'zod';
 export declare abstract class RequestValidatorBase<TRequest> {
     private _request;
     constructor(_request: TRequest);
-    validate(): any;
+    validate(): TRequest;
     protected abstract get schema(): ZodType;
 }

package/core/utils/assing-object.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "@nestjs/common";
+export declare function assignObject<T>(target: Type<T>, source: T): T;

package/core/utils/assing-object.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignObject = void 0;
+function assignObject(target, source) {
+    return Object.assign(new target(), source);
+}
+exports.assignObject = assignObject;

package/core/utils/list.d.ts

@@ -1,4 +1,5 @@
 import { Type } from '@nestjs/common';
+import 'reflect-metadata';
 import { IComparableId } from './interfaces/icomparable';
 export type ListActionType = 'added' | 'updated' | 'removed';
 export interface ListProps<T> {
@@ -15,18 +16,20 @@ export declare class List<T> {
     get length(): number;
     findById(id: IComparableId): T | null;
     findByValue(value: any): T | null;
-    setList(list: T[]): void;
-    add(item: T): void;
-    remove(item: T): void;
-    update(items: T[]): void;
-    clear(): void;
-    forEach(callback: (item: T, index: number) => void): void;
-    forEachAsync(callback: (item: T, index: number) => Promise<void>): Promise<void[]>;
+    setList(list: T[]): this;
+    add(item: T): this | undefined;
+    remove(item: T): this;
+    update(items: T[]): this;
+    clear(): this;
+    forEach(callback: (item: T, index: number) => void): this;
+    forEachAsync(callback: (item: T, index: number) => Promise<void>): Promise<this>;
     map<U>(callback: (item: T, index: number) => U): List<U>;
     mapAsync<U>(callback: (item: T, index: number) => Promise<U>): Promise<List<U>>;
     filter(callback: (item: T, index: number) => boolean): List<T>;
     filterAsync(callback: (item: T, index: number) => Promise<boolean>): Promise<List<T>>;
+    find(callback: (item: T, index: number) => boolean): T | null;
     toArray(type?: ListActionType): T[];
     private indexOf;
     private contains;
+    private mapInternalIdIfIsEmpty;
 }

package/core/utils/list.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.List = void 0;
-const entity_1 = require("../database/entity");
+require("reflect-metadata");
+const entity_base_1 = require("../database/entity.base");
 class List {
     entityType;
     _list = [];
@@ -16,14 +17,16 @@ class List {
     }
     findById(id) {
         return (this._list
-            .filter((item) => item instanceof entity_1.Entity)
-            .find((item) => item.id === id) ?? null);
+            .filter((item) => item instanceof entity_base_1.EntityBase)
+            .find((item) => item._id === id || item.id === id) ??
+            null);
     }
     findByValue(value) {
         return this._list.find((item) => item === value) ?? null;
     }
     setList(list) {
-        this._list = list;
+        this._list = this.mapInternalIdIfIsEmpty(list);
+        return this;
     }
     add(item) {
         if (this.contains(item)) {
@@ -35,6 +38,7 @@ class List {
         }
         this._list.push(item);
         this._addedItemsList.push(item);
+        return this;
     }
     remove(item) {
         const index = this.indexOf(item);
@@ -44,22 +48,29 @@ class List {
                 this._removedItemsList.push(item);
             }
         }
+        return this;
     }
     update(items) {
+        items = this.mapInternalIdIfIsEmpty(items);
         items.forEach((item) => this.add(item));
         this._list
             .filter((item) => !this.contains(item, items))
             .forEach((item) => this.remove(item));
+        return this;
     }
     clear() {
+        this._addedItemsList = [];
+        this._updatedItemsList = [];
         this._removedItemsList = this._list;
         this._list = [];
+        return this;
     }
     forEach(callback) {
         this._list.forEach(callback);
+        return this;
     }
-    forEachAsync(callback) {
-        return Promise.all(this._list.map(callback));
+    async forEachAsync(callback) {
+        return Promise.all(this._list.map(callback)).then(() => this);
     }
     map(callback) {
         const mappedItems = this._list.map(callback);
@@ -89,6 +100,9 @@ class List {
             return list;
         });
     }
+    find(callback) {
+        return this._list.find(callback) ?? null;
+    }
     toArray(type) {
         switch (type) {
             case 'added':
@@ -102,18 +116,26 @@ class List {
         }
     }
     indexOf(item, list = this._list) {
-        if (item instanceof entity_1.Entity) {
+        if (item instanceof entity_base_1.EntityBase) {
             return list
-                .filter((i) => i instanceof entity_1.Entity)
+                .filter((i) => i instanceof entity_base_1.EntityBase)
                 .findIndex((i) => item._id === i._id ||
                 item.id === i.id);
         }
         return list
-            .filter((i) => !(i instanceof entity_1.Entity))
+            .filter((i) => !(i instanceof entity_base_1.EntityBase))
             .findIndex((i) => item === i);
     }
     contains(item, list = this._list) {
         return this.indexOf(item, list) > -1;
     }
+    mapInternalIdIfIsEmpty(list) {
+        return list.map((item) => {
+            if (item instanceof entity_base_1.EntityBase && !item._id) {
+                item._id = item.id;
+            }
+            return item;
+        });
+    }
 }
 exports.List = List;

package/core/utils/list.spec.d.ts

@@ -0,0 +1 @@
+export {};