@koalarx/nest 3.1.28 → 3.1.29

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

@@ -14,6 +14,7 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>
     private readonly _modelName;
     private readonly _includeFindMany?;
     constructor({ context, modelName }: RepositoryInitProps<TEntity, TContext>);
+    private get entityInstance();
     private getIdPropName;
     private getWhereByIdSchema;
     private getConnectPrismaSchemaForRelation;
@@ -30,6 +31,7 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>
     private orphanRemoval;
     private getIdOnEntity;
     private loadRelationForEntity;
+    private loadEntityFromCache;
     private enrichEntityWithRelations;
     private persistRelations;
     protected context(transactionalClient?: TContext): TContext[TModelKey];

package/core/database/repository.base.js

@@ -6,9 +6,10 @@ const pagination_dto_1 = require("../dtos/pagination.dto");
 const koala_global_vars_1 = require("../koala-global-vars");
 const auto_mapping_list_1 = require("../mapping/auto-mapping-list");
 const generate_prisma_include_schema_1 = require("../utils/generate-prisma-include-schema");
+const hydrate_entity_from_cache_1 = require("../utils/hydrate-entity-from-cache");
 const list_1 = require("../utils/list");
-const entity_base_1 = require("./entity.base");
 const proxy_1 = require("../utils/proxy");
+const entity_base_1 = require("./entity.base");
 class RepositoryBase {
     _context;
     _modelName;
@@ -22,6 +23,9 @@ class RepositoryBase {
             entity: this._modelName,
         });
     }
+    get entityInstance() {
+        return this._modelName.prototype.constructor;
+    }
     getIdPropName(entity) {
         const idConfig = Reflect.getMetadata('entity:id', entity ? entity.constructor.prototype : this._modelName.prototype);
         if (idConfig) {
@@ -310,6 +314,24 @@ class RepositoryBase {
         })
             .then((data) => this.enrichEntityWithRelations(entity, (0, proxy_1.createProxy)(data), cache));
     }
+    loadEntityFromCache(entity, data, cache) {
+        return (0, hydrate_entity_from_cache_1.hydrateEntityFromCache)({
+            entity: entity,
+            data,
+            cache,
+            dependencies: {
+                getAllProps: (sourceEntity) => auto_mapping_list_1.AutoMappingList.getAllProps(sourceEntity),
+                getPropDefinitions: (sourceEntity, propName) => auto_mapping_list_1.AutoMappingList.getPropDefinitions(sourceEntity, propName),
+                getSourceByName: (sourceName) => auto_mapping_list_1.AutoMappingList.getSourceByName(sourceName),
+                getListEntityType: (sourceEntity, propName) => {
+                    const list = new sourceEntity()[propName];
+                    return list.entityType;
+                },
+                getIdOnEntity: (currentEntity, value) => this.getIdOnEntity(currentEntity, value),
+                createEntity: (sourceEntity) => new sourceEntity(),
+            },
+        });
+    }
     async enrichEntityWithRelations(entity, data, cache = new Map()) {
         if (!data) {
             return null;
@@ -321,31 +343,24 @@ class RepositoryBase {
             if (propDef?.type === list_1.List.name) {
                 const list = new entity()[prop.name];
                 const entityInstance = list.entityType;
-                const items = [];
                 for (const item of data[propName] || []) {
-                    const cacheKey = `${entity.name}-${this.getIdOnEntity(new entityInstance(), item)}`;
+                    const cacheKey = `${entityInstance.name}-${this.getIdOnEntity(new entityInstance(), item)}`;
                     if (cache.has(cacheKey)) {
-                        items.push(cache.get(cacheKey));
                         continue;
                     }
                     cache.set(cacheKey, item);
-                    const enrichedItem = await this.loadRelationForEntity(this.getWhereByIdSchema(new entityInstance(), item), entityInstance, cache);
-                    cache.set(cacheKey, enrichedItem);
-                    items.push(enrichedItem);
+                    await this.loadRelationForEntity(this.getWhereByIdSchema(new entityInstance(), item), entityInstance, cache).then((response) => cache.set(cacheKey, response));
                 }
-                data[propName] = items;
                 continue;
             }
             const relationEntity = auto_mapping_list_1.AutoMappingList.getSourceByName(propDef?.type ?? '');
             if (relationEntity && data[propName]) {
-                const cacheKey = `${entity.name}-${this.getIdOnEntity(new relationEntity(), data[propName])}`;
+                const cacheKey = `${relationEntity.name}-${this.getIdOnEntity(new relationEntity(), data[propName])}`;
                 if (cache.has(cacheKey)) {
-                    data[propName] = cache.get(cacheKey);
                     continue;
                 }
                 cache.set(cacheKey, data[propName]);
-                data[propName] = await this.loadRelationForEntity(this.getWhereByIdSchema(new relationEntity(), data[propName]), relationEntity, cache);
-                cache.set(cacheKey, data[propName]);
+                await this.loadRelationForEntity(this.getWhereByIdSchema(new relationEntity(), data[propName]), relationEntity, cache).then((response) => cache.set(cacheKey, response));
             }
         }
         return data;
@@ -411,35 +426,41 @@ class RepositoryBase {
     }
     async findById(id) {
         const data = await this.context().findFirst({
-            select: this.getSelectWithRelationsId(this._modelName.prototype.constructor),
-            where: this.getWhereByIdSchema(this._modelName.prototype.constructor, {
+            select: this.getSelectWithRelationsId(this.entityInstance),
+            where: this.getWhereByIdSchema(this.entityInstance, {
                 id,
             }),
         });
         if (!data)
             return null;
-        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, (0, proxy_1.createProxy)(data));
-        return this.createEntity(enrichedEntity);
+        const cache = new Map();
+        return this.enrichEntityWithRelations(this.entityInstance, (0, proxy_1.createProxy)(data), cache)
+            .then((response) => this.loadEntityFromCache(this.entityInstance, response, cache))
+            .then((response) => this.createEntity(response));
     }
     async findFirst(where) {
         const data = await this.context().findFirst({
-            select: this.getSelectWithRelationsId(this._modelName.prototype.constructor),
+            select: this.getSelectWithRelationsId(this.entityInstance),
             where,
         });
         if (!data)
             return null;
-        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, (0, proxy_1.createProxy)(data));
-        return this.createEntity(enrichedEntity);
+        const cache = new Map();
+        return this.enrichEntityWithRelations(this.entityInstance, (0, proxy_1.createProxy)(data), cache)
+            .then((response) => this.loadEntityFromCache(this.entityInstance, response, cache))
+            .then((response) => this.createEntity(response));
     }
     async findUnique(where) {
         const data = await this.context().findUnique({
-            select: this.getSelectWithRelationsId(this._modelName.prototype.constructor),
+            select: this.getSelectWithRelationsId(this.entityInstance),
             where,
         });
         if (!data)
             return null;
-        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, (0, proxy_1.createProxy)(data));
-        return this.createEntity(enrichedEntity);
+        const cache = new Map();
+        return this.enrichEntityWithRelations(this.entityInstance, (0, proxy_1.createProxy)(data), cache)
+            .then((response) => this.loadEntityFromCache(this.entityInstance, response, cache))
+            .then((response) => this.createEntity(response));
     }
     async findMany(where, pagination) {
         return this.context()

package/core/utils/hydrate-entity-from-cache.d.ts

@@ -0,0 +1,22 @@
+import { Type } from '@nestjs/common';
+export type GraphVisitState = 'loading' | 'loaded';
+export interface HydrateEntityFromCacheDependencies {
+    getAllProps(entity: Type<any>): Array<{
+        name: string;
+    }>;
+    getPropDefinitions(entity: Type<any>, propName: string): {
+        type?: string;
+    } | undefined;
+    getSourceByName(sourceName: string): Type<any> | undefined;
+    getListEntityType(entity: Type<any>, propName: string): Type<any> | undefined;
+    getIdOnEntity(entity: any, data: any): string;
+    createEntity(entity: Type<any>): any;
+}
+export interface HydrateEntityFromCacheParams {
+    entity: Type<any>;
+    data: any;
+    cache: Map<string, any>;
+    dependencies: HydrateEntityFromCacheDependencies;
+    visitState?: Map<string, GraphVisitState>;
+}
+export declare function hydrateEntityFromCache({ entity, data, cache, dependencies, visitState, }: HydrateEntityFromCacheParams): any;

package/core/utils/hydrate-entity-from-cache.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hydrateEntityFromCache = hydrateEntityFromCache;
+function mergeScalarProps(target, source) {
+    Object.keys(source || {}).forEach((key) => {
+        const value = source[key];
+        if (value === undefined) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            return;
+        }
+        if (value !== null && typeof value === 'object') {
+            return;
+        }
+        target[key] = value;
+    });
+}
+function getCacheKey(entity, data, dependencies) {
+    const entityId = dependencies.getIdOnEntity(dependencies.createEntity(entity), data);
+    return `${entity.name}-${entityId}`;
+}
+function hydrateEntityFromCache({ entity, data, cache, dependencies, visitState = new Map(), }) {
+    if (!data) {
+        return data;
+    }
+    const cacheKey = getCacheKey(entity, data, dependencies);
+    const sourceData = cache.get(cacheKey) ?? data;
+    let canonicalEntity = cache.get(cacheKey);
+    if (!canonicalEntity) {
+        canonicalEntity = sourceData;
+        cache.set(cacheKey, canonicalEntity);
+    }
+    mergeScalarProps(canonicalEntity, sourceData);
+    if (visitState.get(cacheKey) === 'loading') {
+        return canonicalEntity;
+    }
+    visitState.set(cacheKey, 'loading');
+    const allProps = dependencies.getAllProps(entity);
+    for (const prop of allProps) {
+        const propName = prop.name;
+        const propDefinition = dependencies.getPropDefinitions(entity, propName);
+        const sourcePropValue = sourceData[propName] ?? canonicalEntity[propName];
+        if (Array.isArray(sourcePropValue)) {
+            const listEntity = dependencies.getListEntityType(entity, propName);
+            if (!listEntity) {
+                canonicalEntity[propName] = sourcePropValue;
+                continue;
+            }
+            canonicalEntity[propName] = sourcePropValue.map((item) => hydrateEntityFromCache({
+                entity: listEntity,
+                data: item,
+                cache,
+                dependencies,
+                visitState,
+            }));
+            continue;
+        }
+        const relationEntity = dependencies.getSourceByName(propDefinition?.type ?? '');
+        if (relationEntity && sourcePropValue) {
+            canonicalEntity[propName] = hydrateEntityFromCache({
+                entity: relationEntity,
+                data: sourcePropValue,
+                cache,
+                dependencies,
+                visitState,
+            });
+            continue;
+        }
+        if (sourcePropValue !== undefined) {
+            canonicalEntity[propName] = sourcePropValue;
+        }
+    }
+    visitState.set(cacheKey, 'loaded');
+    return canonicalEntity;
+}

package/package.json

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