@koalarx/nest 3.1.13 → 3.1.15

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

@@ -28,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

@@ -17,23 +17,35 @@ class RepositoryBase {
         this._modelName = modelName;
         this._includeFindMany = (0, generate_prisma_include_schema_1.generateIncludeSchema)({
             forList: true,
-            deepLimit: 1,
+            deepLimit: 2,
             entity: this._modelName,
         });
     }
     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';
     }
     getWhereByIdSchema(entity, value) {
         const propIdName = this.getIdPropName(entity);
         if (Array.isArray(propIdName)) {
             const whereSchema = {};
             propIdName.forEach((propName) => {
-                whereSchema[propName] = value[propName];
+                whereSchema[propName] =
+                    typeof value === 'object' ? value[propName] : value;
             });
             return whereSchema;
         }
-        return { [propIdName]: value[propIdName] };
+        return {
+            [propIdName]: typeof value === 'object' ? value[propIdName] : value,
+        };
     }
     getConnectPrismaSchemaForRelation(entity, data) {
         return {
@@ -74,14 +86,14 @@ class RepositoryBase {
             }
             if (instance instanceof entity_base_1.EntityBase) {
                 selectSchema[prop.name] = {
-                    select: this.getSelectRootPrismaSchema(instance),
+                    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.getSelectRootPrismaSchema(new entityInstance()),
+                    select: this.getWhereByIdSchema(new entityInstance(), true),
                 };
             }
             else {
@@ -171,6 +183,22 @@ class RepositoryBase {
                     });
                 }
             }
+            else if (entity[key] instanceof entity_base_1.EntityBase) {
+                const entityInstance = entity[key];
+                const modelName = entity[key].constructor.name;
+                if (entity[key]._action === entity_base_1.EntityActionType.update) {
+                    relationUpdates.push({
+                        modelName: (0, KlString_1.toCamelCase)(modelName),
+                        entityInstance,
+                        schema: {
+                            where: { id: entityInstance._id },
+                            data: this.entityToPrisma(entityInstance),
+                            select: this.getSelectRootPrismaSchema(entityInstance),
+                        },
+                        relations: this.listRelationEntities(entityInstance),
+                    });
+                }
+            }
         });
         return { relationCreates, relationUpdates, relationDeletes };
     }
@@ -243,15 +271,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);
@@ -264,15 +305,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 && 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.getWhereByIdSchema(relationEntity, data[propName]), relationEntity));
+                relationQueries.push(this.loadRelationForEntity(this.getWhereByIdSchema(relationEntity, data[propName]), relationEntity, cache));
             }
         });
         if (relationQueries.length > 0) {
@@ -341,7 +394,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 findFirst(where) {
@@ -351,7 +404,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) {
@@ -361,7 +414,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) {

package/core/utils/generate-prisma-include-schema.js

@@ -2,33 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateIncludeSchema = generateIncludeSchema;
 const entity_base_1 = require("../database/entity.base");
-const list_1 = require("./list");
 const auto_mapping_list_1 = require("../mapping/auto-mapping-list");
+const list_1 = require("./list");
 function generateIncludeSchema({ forList, entity, deepIncludeCount = 0, deepLimit, }) {
     if (deepIncludeCount >= deepLimit) {
         return true;
     }
     const includeSchema = {};
+    const props = auto_mapping_list_1.AutoMappingList.getAllProps(entity);
     const entityInstance = new entity();
-    Object.keys(entityInstance)
-        .filter((key) => !['_id', '_action'].includes(key))
-        .forEach((key) => {
+    props.forEach((prop) => {
+        let instance;
+        try {
+            instance = new (prop.type())();
+        }
+        catch {
+            instance = null;
+        }
         let includes;
-        if (entityInstance[key] instanceof list_1.List) {
+        if (instance instanceof list_1.List) {
             if (forList) {
-                includeSchema[key] = true;
+                includeSchema[prop.name] = true;
             }
             else {
                 includes = generateIncludeSchema({
                     forList,
-                    entity: entityInstance[key].entityType,
+                    entity: instance.entityType,
                     deepLimit,
                     deepIncludeCount: deepIncludeCount > 0 ? deepIncludeCount + 1 : 1,
                 });
             }
         }
         else {
-            const propDefinitions = auto_mapping_list_1.AutoMappingList.getPropDefinitions(entityInstance.constructor, key);
+            const propDefinitions = auto_mapping_list_1.AutoMappingList.getPropDefinitions(entityInstance.constructor, prop.name);
             if (propDefinitions) {
                 const source = auto_mapping_list_1.AutoMappingList.getSourceByName(propDefinitions.type);
                 if (source?.prototype instanceof entity_base_1.EntityBase) {
@@ -43,10 +49,10 @@ function generateIncludeSchema({ forList, entity, deepIncludeCount = 0, deepLimi
         }
         if (includes) {
             if (includes === true || Object.keys(includes).length > 0) {
-                includeSchema[key] = includes;
+                includeSchema[prop.name] = includes;
             }
             else {
-                includeSchema[key] = true;
+                includeSchema[prop.name] = true;
             }
         }
     });

package/package.json

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

package/test/utils/create-e2e-database.d.ts

@@ -1,2 +1,7 @@
+import { Type } from '@nestjs/common';
 import 'dotenv/config';
-export declare function createE2EDatabase(runtime?: 'node' | 'bun'): Promise<`${string}-${string}-${string}-${string}-${string}`>;
+import { E2EDatabaseClient } from './e2e-database-client';
+export declare function createE2EDatabase<T extends E2EDatabaseClient>(runtime: "node" | "bun" | undefined, clientInstance: Type<T>): Promise<{
+    client: T;
+    schemaId: `${string}-${string}-${string}-${string}-${string}`;
+}>;

package/test/utils/create-e2e-database.js

@@ -4,7 +4,6 @@ exports.createE2EDatabase = createE2EDatabase;
 require("dotenv/config");
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
-const pg_1 = require("pg");
 function generateUniqueDatabaseURL() {
     const schemaId = (0, node_crypto_1.randomUUID)();
     if (!process.env.DATABASE_URL) {
@@ -17,31 +16,23 @@ function generateUniqueDatabaseURL() {
         schemaId,
     };
 }
-async function createE2EDatabase(runtime = 'node') {
+async function createE2EDatabase(runtime = 'node', clientInstance) {
     const { url, schemaId } = generateUniqueDatabaseURL();
     process.env.DATABASE_URL = url;
-    process.env.DIRECT_URL = url;
     process.env.PRISMA_SCHEMA_DISABLE_ADVISORY_LOCK = 'true';
     try {
-        const baseUrl = new URL(process.env.DATABASE_URL);
-        baseUrl.pathname = '/postgres';
-        const pool = new pg_1.Pool({ connectionString: baseUrl.toString() });
-        try {
-            await pool.query(`CREATE DATABASE "${schemaId}"`);
-        }
-        finally {
-            await pool.end();
-        }
+        const client = new clientInstance(url, schemaId);
+        await client.createDatabase(schemaId);
         const env = { ...process.env, DATABASE_URL: url, DIRECT_URL: url };
         (0, node_child_process_1.execSync)(`${runtime}x prisma migrate deploy`, {
             cwd: process.cwd(),
             env,
             stdio: 'inherit',
         });
+        return { client, schemaId };
     }
     catch (error) {
         console.error('Erro ao criar banco de dados e2e:', error);
         throw error;
     }
-    return schemaId;
 }

package/test/utils/e2e-database-client.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class E2EDatabaseClient {
+    protected readonly url: string;
+    protected readonly schemaName: string;
+    constructor(url: string, schemaName: string);
+    abstract createDatabase(schemaName: string): Promise<void>;
+    abstract dropDatabase(): Promise<void>;
+}

package/test/utils/e2e-database-client.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E2EDatabaseClient = void 0;
+class E2EDatabaseClient {
+    url;
+    schemaName;
+    constructor(url, schemaName) {
+        this.url = url;
+        this.schemaName = schemaName;
+    }
+}
+exports.E2EDatabaseClient = E2EDatabaseClient;