@koalarx/nest 3.1.27 → 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,7 +6,9 @@ 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 proxy_1 = require("../utils/proxy");
 const entity_base_1 = require("./entity.base");
 class RepositoryBase {
     _context;
@@ -21,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) {
@@ -76,7 +81,7 @@ class RepositoryBase {
                 const list = new entity()[prop.name];
                 const entityInstance = list.entityType;
                 selectSchema[prop.name] = {
-                    select: this.getSelectRootPrismaSchema(entityInstance),
+                    select: this.getWhereByIdSchema(new entityInstance(), true),
                 };
             }
             else {
@@ -307,11 +312,30 @@ class RepositoryBase {
             select: this.getSelectRootPrismaSchema(entity),
             where,
         })
-            .then((data) => this.enrichEntityWithRelations(entity, data, cache));
+            .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 data;
+        if (!data) {
+            return null;
+        }
         const allProps = auto_mapping_list_1.AutoMappingList.getAllProps(entity);
         for (const prop of allProps) {
             const propName = prop.name;
@@ -319,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}-${propName}-${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}-${propName}-${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);
-                    return;
+                    continue;
                 }
                 cache.set(cacheKey, data[propName]);
-                data[propName] = await this.loadRelationForEntity(this.getWhereByIdSchema(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;
@@ -409,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, { ...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, { ...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, { ...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/core/utils/is-plain-object.d.ts

@@ -0,0 +1 @@
+export declare function isPlainObject(val: any): boolean;

package/core/utils/is-plain-object.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = isPlainObject;
+function isPlainObject(val) {
+    if (typeof val !== 'object' || val === null)
+        return false;
+    return Object.prototype.toString.call(val) === '[object Object]';
+}

package/core/utils/proxy.d.ts

@@ -0,0 +1 @@
+export declare function createProxy(target: any): any;

package/core/utils/proxy.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProxy = createProxy;
+const is_plain_object_1 = require("./is-plain-object");
+const handle = {
+    get(target, prop) {
+        if (prop === '__isProxy')
+            return true;
+        return target[prop];
+    },
+    set(target, prop, value) {
+        target[prop] = value;
+        return true;
+    },
+};
+function createProxy(target) {
+    const proxy = new Proxy(target, handle);
+    Object.keys(proxy).forEach((key) => {
+        if ((0, is_plain_object_1.isPlainObject)(proxy[key])) {
+            proxy[key] = new Proxy(proxy[key], handle);
+        }
+        else if (Array.isArray(proxy[key])) {
+            proxy[key] = proxy[key].map((item) => (0, is_plain_object_1.isPlainObject)(item) ? new Proxy(item, handle) : item);
+        }
+    });
+    return proxy;
+}

package/package.json

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