@koalarx/nest 3.1.12 → 3.1.14

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

@@ -2,7 +2,13 @@ import { EntityBase } from './entity.base';
 type EntityProps<T> = Omit<{
     [K in keyof T as T[K] extends Function ? never : K]: T[K];
 }, '_id' | '_action'>;
-export declare function Entity<T extends new (...args: any[]) => EntityBase<any>>(id?: keyof EntityProps<InstanceType<T>>): (target: T) => {
+export type CompositeId = readonly (string | number)[];
+export interface IdConfig<T extends EntityProps<any>> {
+    single?: keyof T;
+    composite?: readonly (keyof T)[];
+    custom?: (props: T) => string | number | CompositeId;
+}
+export declare function Entity<T extends new (...args: any[]) => EntityBase<any>>(id?: keyof EntityProps<InstanceType<T>> | IdConfig<EntityProps<InstanceType<T>>>): (target: T) => {
     new (...args: any[]): {
         _id: import("../utils/interfaces/icomparable").IComparableId;
         _action: import("./entity.base").EntityActionType;

package/core/database/entity.decorator.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Entity = Entity;
+function normalizeIdConfig(id) {
+    if (!id)
+        return undefined;
+    if (typeof id === 'string' || typeof id === 'symbol') {
+        return { single: id };
+    }
+    return id;
+}
 function Entity(id) {
     return function (target) {
         class NewConstructor extends target {
@@ -17,7 +25,8 @@ function Entity(id) {
             value: target.name,
             writable: false,
         });
-        Reflect.defineMetadata('entity:id', id, NewConstructor.prototype);
+        const idConfig = normalizeIdConfig(id);
+        Reflect.defineMetadata('entity:id', idConfig, NewConstructor.prototype);
         return NewConstructor;
     };
 }

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

@@ -15,7 +15,9 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>
     private readonly _includeFindMany?;
     constructor({ context, modelName }: RepositoryInitProps<TEntity, TContext>);
     private getIdPropName;
+    private getWhereByIdSchema;
     private getConnectPrismaSchemaForRelation;
+    private checkIdHasValue;
     private getSelectRootPrismaSchema;
     private getSelectWithRelationsId;
     private getPropNameFromEntitySource;
@@ -26,6 +28,7 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>
     private findManySchema;
     private createEntity;
     private orphanRemoval;
+    private getIdOnEntity;
     private loadRelationForEntity;
     private enrichEntityWithRelations;
     private persistRelations;

package/core/database/repository.base.js

@@ -22,16 +22,40 @@ class RepositoryBase {
         });
     }
     getIdPropName(entity) {
-        return (Reflect.getMetadata('entity:id', entity ? entity.constructor.prototype : this._modelName.prototype) ?? 'id');
+        const idConfig = Reflect.getMetadata('entity:id', entity ? entity.constructor.prototype : this._modelName.prototype);
+        if (idConfig) {
+            if (idConfig.single) {
+                return idConfig.single;
+            }
+            else if (idConfig.composite) {
+                return idConfig.composite;
+            }
+        }
+        return 'id';
     }
-    getConnectPrismaSchemaForRelation(entity, data) {
+    getWhereByIdSchema(entity, value) {
         const propIdName = this.getIdPropName(entity);
+        if (Array.isArray(propIdName)) {
+            const whereSchema = {};
+            propIdName.forEach((propName) => {
+                whereSchema[propName] =
+                    typeof value === 'object' ? value[propName] : value;
+            });
+            return whereSchema;
+        }
         return {
-            connect: {
-                [propIdName]: (data ?? entity)[propIdName],
-            },
+            [propIdName]: typeof value === 'object' ? value[propIdName] : value,
         };
     }
+    getConnectPrismaSchemaForRelation(entity, data) {
+        return {
+            connect: this.getWhereByIdSchema(entity, data ?? entity),
+        };
+    }
+    checkIdHasValue(entity, value) {
+        const result = this.getWhereByIdSchema(entity, value);
+        return Object.values(result).every((val) => val !== undefined && val !== null);
+    }
     getSelectRootPrismaSchema(entity) {
         const selectSchema = {};
         Object.keys(entity)
@@ -62,18 +86,14 @@ class RepositoryBase {
             }
             if (instance instanceof entity_base_1.EntityBase) {
                 selectSchema[prop.name] = {
-                    select: {
-                        [this.getIdPropName(entity[prop.name])]: true,
-                    },
+                    select: this.getWhereByIdSchema(instance, true),
                 };
             }
             else if (instance instanceof list_1.List) {
                 const list = new entity()[prop.name];
                 const entityInstance = list.entityType;
                 selectSchema[prop.name] = {
-                    select: {
-                        [this.getIdPropName(entityInstance)]: true,
-                    },
+                    select: this.getWhereByIdSchema(new entityInstance(), true),
                 };
             }
             else {
@@ -174,12 +194,10 @@ class RepositoryBase {
             .forEach((key) => {
             if (entity[key] instanceof entity_base_1.EntityBase) {
                 if (entity[key]._action === entity_base_1.EntityActionType.create) {
-                    if (entity[key][this.getIdPropName(entity)]) {
+                    if (entity[key] && this.checkIdHasValue(entity, entity[key])) {
                         prismaSchema[key] = {
                             connectOrCreate: {
-                                where: {
-                                    [this.getIdPropName(entity)]: entity[key][this.getIdPropName(entity)],
-                                },
+                                where: this.getWhereByIdSchema(entity[key].constructor, entity[key]),
                                 create: this.entityToPrisma(entity[key]),
                             },
                         };
@@ -237,15 +255,28 @@ class RepositoryBase {
             .forEach((key) => (where[key] = entity[key]));
         return client[(0, KlString_1.toCamelCase)(entity.constructor.name)].delete({ where });
     }
-    async loadRelationForEntity(where, entity) {
+    getIdOnEntity(entity, data) {
+        const propIdName = this.getIdPropName(entity);
+        if (Array.isArray(propIdName)) {
+            const idValues = [];
+            propIdName.forEach((propName) => {
+                idValues.push(data[propName]);
+            });
+            return idValues.join('-');
+        }
+        return data[propIdName];
+    }
+    async loadRelationForEntity(where, entity, cache) {
         return this._context[(0, KlString_1.toCamelCase)((0, KlString_1.toCamelCase)(entity.name))]
-            .findUnique({
+            .findFirst({
             select: this.getSelectWithRelationsId(entity),
             where,
         })
-            .then((data) => this.enrichEntityWithRelations(entity, data));
+            .then((data) => this.enrichEntityWithRelations(entity, data, cache));
     }
-    async enrichEntityWithRelations(entity, data) {
+    async enrichEntityWithRelations(entity, data, cache = new Map()) {
+        if (!data)
+            return data;
         const relationQueries = [];
         const relationKeys = [];
         const allProps = auto_mapping_list_1.AutoMappingList.getAllProps(entity);
@@ -258,17 +289,27 @@ class RepositoryBase {
                 relationKeys.push(propName);
                 const items = [];
                 data[propName].forEach((item) => {
-                    items.push(this.loadRelationForEntity(item, entityInstance));
+                    const cacheKey = `${entity.constructor.name}-${propName}-${this.getIdOnEntity(new entityInstance(), item)}`;
+                    if (cache.has(cacheKey)) {
+                        items.push(Promise.resolve(cache.get(cacheKey)));
+                        return;
+                    }
+                    cache.set(cacheKey, item);
+                    items.push(this.loadRelationForEntity(item, entityInstance, cache));
                 });
                 relationQueries.push(Promise.all(items));
                 return;
             }
             const relationEntity = auto_mapping_list_1.AutoMappingList.getSourceByName(propDef?.type ?? '');
-            if (relationEntity) {
+            if (relationEntity && data[propName]) {
+                const cacheKey = `${entity.constructor.name}-${propName}-${this.getIdOnEntity(new relationEntity(), data[propName])}`;
+                if (cache.has(cacheKey)) {
+                    data[propName] = cache.get(cacheKey);
+                    return;
+                }
+                cache.set(cacheKey, data[propName]);
                 relationKeys.push(propName);
-                relationQueries.push(this.loadRelationForEntity({
-                    [this.getIdPropName(relationEntity)]: data[propName][this.getIdPropName(relationEntity)],
-                }, relationEntity));
+                relationQueries.push(this.loadRelationForEntity(this.getWhereByIdSchema(relationEntity, data[propName]), relationEntity, cache));
             }
         });
         if (relationQueries.length > 0) {
@@ -285,6 +326,9 @@ class RepositoryBase {
             ...relationCreates.map((relationCreate) => transaction[relationCreate.modelName]
                 .create(relationCreate.schema)
                 .then((response) => {
+                if (relationCreate.relations.length === 0) {
+                    return Promise.all([]);
+                }
                 return Promise.all(relationCreate.relations.map((relation) => {
                     const relationPropName = this.getPropNameFromEntitySource(relation, relationCreate.entityInstance);
                     if (relationPropName &&
@@ -298,8 +342,15 @@ class RepositoryBase {
                         select: this.getSelectRootPrismaSchema(relation),
                     })
                         .then((response) => {
-                        relation[this.getIdPropName(relation)] =
-                            response[this.getIdPropName(relation)];
+                        const idPropName = this.getIdPropName(relation);
+                        if (!Array.isArray(idPropName)) {
+                            relation[idPropName] = response[idPropName];
+                        }
+                        else {
+                            idPropName.forEach((propName) => {
+                                relation[propName] = response[propName];
+                            });
+                        }
                         return this.persistRelations(transaction, relation);
                     });
                 }));
@@ -321,11 +372,13 @@ class RepositoryBase {
     async findById(id) {
         const data = await this.context().findFirst({
             select: this.getSelectWithRelationsId(this._modelName.prototype.constructor),
-            where: { [this.getIdPropName()]: id },
+            where: this.getWhereByIdSchema(this._modelName.prototype.constructor, {
+                id,
+            }),
         });
         if (!data)
             return null;
-        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, data);
+        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, { ...data });
         return this.createEntity(enrichedEntity);
     }
     async findFirst(where) {
@@ -335,7 +388,7 @@ class RepositoryBase {
         });
         if (!data)
             return null;
-        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, data);
+        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, { ...data });
         return this.createEntity(enrichedEntity);
     }
     async findUnique(where) {
@@ -345,7 +398,7 @@ class RepositoryBase {
         });
         if (!data)
             return null;
-        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, data);
+        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, { ...data });
         return this.createEntity(enrichedEntity);
     }
     async findMany(where, pagination) {
@@ -370,7 +423,15 @@ class RepositoryBase {
                 include: this.getInclude(),
             })
                 .then((response) => {
-                entity[this.getIdPropName()] = response[this.getIdPropName()];
+                const idPropName = this.getIdPropName(entity);
+                if (!Array.isArray(idPropName)) {
+                    entity[idPropName] = response[idPropName];
+                }
+                else {
+                    idPropName.forEach((propName) => {
+                        entity[propName] = response[propName];
+                    });
+                }
                 return this.persistRelations(client, entity).then(() => entity);
             }));
         }

package/package.json

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