@cheetah.js/orm 0.1.45 → 0.1.47

package/dist/SqlBuilder.js

@@ -1,13 +1,14 @@
 import { EntityStorage } from './domain/entities';
 import { Orm } from './orm';
-import { ValueObject } from './common/value-object';
-import { BaseEntity } from './domain/base-entity';
-import { extendsFrom } from './utils';
+import { ValueProcessor } from './utils/value-processor';
+import { SqlConditionBuilder } from './query/sql-condition-builder';
+import { ModelTransformer } from './query/model-transformer';
+import { SqlColumnManager } from './query/sql-column-manager';
+import { SqlJoinManager } from './query/sql-join-manager';
 export class SqlBuilder {
     constructor(model) {
         this.statements = {};
         this.aliases = new Set();
-        this.lastKeyNotOperator = '';
         this.updatedColumns = [];
         this.originalColumns = [];
         const orm = Orm.getInstance();
@@ -16,6 +17,13 @@ export class SqlBuilder {
         this.entityStorage = EntityStorage.getInstance();
         this.getEntity(model);
         this.statements.hooks = this.entity.hooks;
+        this.modelTransformer = new ModelTransformer(this.entityStorage);
+        this.columnManager = new SqlColumnManager(this.entityStorage, this.statements, this.entity);
+        const applyJoinWrapper = (relationship, value, alias) => {
+            return this.joinManager.applyJoin(relationship, value, alias);
+        };
+        this.conditionBuilder = new SqlConditionBuilder(this.entityStorage, applyJoinWrapper, this.statements);
+        this.joinManager = new SqlJoinManager(this.entityStorage, this.statements, this.entity, this.model, this.driver, this.logger, this.conditionBuilder, this.columnManager, this.modelTransformer, () => this.originalColumns, this.getAlias.bind(this));
     }
     select(columns) {
         const tableName = this.entity.tableName || this.model.name.toLowerCase();
@@ -37,25 +45,23 @@ export class SqlBuilder {
     }
     insert(values) {
         const { tableName, schema } = this.getTableName();
-        // @ts-ignore
-        values = processValuesForInsert(values, this.entity);
+        const processedValues = ValueProcessor.processForInsert(values, this.entity);
         this.statements.statement = 'insert';
-        this.statements.instance = upEntity(values, this.model, 'insert');
+        this.statements.instance = ValueProcessor.createInstance(processedValues, this.model, 'insert');
         this.statements.alias = this.getAlias(tableName);
         this.statements.table = `"${schema}"."${tableName}"`;
-        this.statements.values = this.withUpdatedValues(this.withDefaultValues(values, this.entity), this.entity);
+        this.statements.values = this.withUpdatedValues(this.withDefaultValues(processedValues, this.entity), this.entity);
         this.reflectToValues();
         return this;
     }
     update(values) {
         const { tableName, schema } = this.getTableName();
-        // @ts-ignore
-        values = processValuesForUpdate(values, this.entity);
+        const processedValues = ValueProcessor.processForUpdate(values, this.entity);
         this.statements.statement = 'update';
         this.statements.alias = this.getAlias(tableName);
         this.statements.table = `${schema}.${tableName}`;
-        this.statements.values = this.withUpdatedValues(values, this.entity);
-        this.statements.instance = upEntity(values, this.model, 'update');
+        this.statements.values = this.withUpdatedValues(processedValues, this.entity);
+        this.statements.instance = ValueProcessor.createInstance(processedValues, this.model, 'update');
         return this;
     }
     where(where) {
@@ -68,10 +74,10 @@ export class SqlBuilder {
                 newWhere[key] = where[key];
                 continue;
             }
-            newWhere[getColumnName(key, this.entity)] = where[key];
+            newWhere[ValueProcessor.getColumnName(key, this.entity)] = where[key];
         }
         where = newWhere;
-        this.statements.where = this.conditionToSql(where, this.statements.alias, this.model);
+        this.statements.where = this.conditionBuilder.build(where, this.statements.alias, this.model);
         return this;
     }
     orderBy(orderBy) {
@@ -91,7 +97,7 @@ export class SqlBuilder {
     }
     load(load) {
         load?.forEach(relationshipPath => {
-            this.addJoinForRelationshipPath(this.entity, relationshipPath);
+            this.joinManager.addJoinForRelationshipPath(relationshipPath);
         });
         if (this.statements.join) {
             this.statements.join = this.statements.join?.reverse();
@@ -101,34 +107,6 @@ export class SqlBuilder {
         }
         return this;
     }
-    addJoinForRelationshipPath(entity, relationshipPath) {
-        const relationshipNames = relationshipPath.split('.');
-        let currentEntity = entity;
-        let currentAlias = this.statements.alias;
-        let statement = this.statements.strategy === 'joined' ? this.statements.join : this.statements.selectJoin;
-        let nameAliasProperty = this.statements.strategy === 'joined' ? 'joinAlias' : 'alias';
-        relationshipNames.forEach((relationshipName, index) => {
-            const relationship = currentEntity.relations.find(rel => rel.propertyKey === relationshipName);
-            if (!relationship) {
-                // @ts-ignore
-                throw new Error(`Relationship "${relationshipName}" not found in entity "${currentEntity.name}"`);
-            }
-            const isLastRelationship = index === relationshipNames.length - 1;
-            if (index === (relationshipNames.length - 2 >= 0 ? relationshipNames.length - 2 : 0)) {
-                const join = statement?.find(j => j.joinProperty === relationshipName);
-                if (join) {
-                    // @ts-ignore
-                    currentAlias = join[nameAliasProperty];
-                }
-            }
-            if (relationship.relation === 'many-to-one' && isLastRelationship) {
-                this.applyJoin(relationship, {}, currentAlias);
-                statement = this.statements.strategy === 'joined' ? this.statements.join : this.statements.selectJoin;
-                currentAlias = statement[statement.length - 1][nameAliasProperty];
-            }
-            currentEntity = this.entityStorage.get(relationship.entity());
-        });
-    }
     getPrimaryKeyColumnName(entity) {
         // Lógica para obter o nome da coluna de chave primária da entidade
         // Aqui você pode substituir por sua própria lógica, dependendo da estrutura do seu projeto
@@ -138,14 +116,12 @@ export class SqlBuilder {
     }
     async execute() {
         if (!this.statements.columns) {
-            this.statements.columns = this.generateColumns();
+            this.statements.columns = this.columnManager.generateColumns(this.model, this.updatedColumns);
         }
         else {
-            this.extractAliasForColumns();
-            this.filterInvalidColumns();
+            this.statements.columns = [...this.columnManager.processUserColumns(this.statements.columns), ...this.updatedColumns];
         }
         this.statements.join = this.statements.join?.reverse();
-        this.includeUpdatedColumns();
         this.beforeHooks();
         const result = await this.driver.executeStatement(this.statements);
         this.logExecution(result);
@@ -178,9 +154,9 @@ export class SqlBuilder {
             return undefined;
         }
         const entities = result.query.rows[0];
-        const model = await this.transformToModel(this.model, this.statements, entities);
+        const model = await this.modelTransformer.transform(this.model, this.statements, entities);
         this.afterHooks(model);
-        await this.handleSelectJoin(entities, model);
+        await this.joinManager.handleSelectJoin(entities, model);
         return model;
     }
     async executeAndReturnFirstOrFail() {
@@ -190,9 +166,9 @@ export class SqlBuilder {
             throw new Error('Result not found');
         }
         const entities = result.query.rows[0];
-        const model = await this.transformToModel(this.model, this.statements, entities);
+        const model = await this.modelTransformer.transform(this.model, this.statements, entities);
         this.afterHooks(model);
-        await this.handleSelectJoin(entities, model);
+        await this.joinManager.handleSelectJoin(entities, model);
         return model;
     }
     async executeAndReturnAll() {
@@ -203,133 +179,16 @@ export class SqlBuilder {
         const rows = result.query.rows;
         const results = [];
         for (const row of rows) {
-            const models = this.transformToModel(this.model, this.statements, row);
+            const models = this.modelTransformer.transform(this.model, this.statements, row);
             this.afterHooks(models);
-            await this.handleSelectJoin(row, models);
+            await this.joinManager.handleSelectJoin(row, models);
             results.push(models);
         }
         return results;
     }
-    async handleSelectJoin(entities, models) {
-        if (!this.statements.selectJoin || this.statements.selectJoin.length === 0) {
-            return;
-        }
-        for (const join of this.statements.selectJoin.reverse()) {
-            let ids = entities[`${join.originAlias}_${join.primaryKey}`];
-            if (typeof ids === 'undefined') {
-                // get of models
-                const selectJoined = this.statements.selectJoin.find(j => j.joinEntity === join.originEntity);
-                if (!selectJoined) {
-                    continue;
-                }
-                ids = this.findIdRecursively(models, selectJoined, join);
-            }
-            if (Array.isArray(ids)) {
-                ids = ids.map((id) => this.t(id)).join(', ');
-            }
-            if (join.where) {
-                join.where = `${join.where} AND ${join.alias}."${join.fkKey}" IN (${ids})`;
-            }
-            else {
-                join.where = `${join.alias}."${join.fkKey}" IN (${ids})`;
-            }
-            if (join.columns && join.columns.length > 0) {
-                join.columns = join.columns.map(
-                // @ts-ignore
-                (column) => `${join.alias}."${column}" as "${join.alias}_${column}"`);
-            }
-            else {
-                join.columns = this.getColumnsEntity(join.joinEntity, join.alias);
-            }
-            const child = await this.driver.executeStatement(join);
-            this.logger.debug(`SQL: ${child.sql} [${Date.now() - child.startTime}ms]`);
-            const property = this.entityStorage.get(this.model).relations.find((rel) => rel.propertyKey === join.joinProperty);
-            const values = child.query.rows.map((row) => this.transformToModel(join.joinEntity, join, row));
-            const path = this.getPathForSelectJoin(join);
-            this.setValueByPath(models, path, property?.type === Array ? [...values] : values[0]);
-        }
-        return models;
-    }
-    getPathForSelectJoin(selectJoin) {
-        const path = this.getPathForSelectJoinRecursive(this.statements, selectJoin);
-        return path.reverse();
-    }
-    setValueByPath(obj, path, value) {
-        let currentObj = obj;
-        for (let i = 0; i < path.length - 1; i++) {
-            const key = path[i];
-            currentObj[key] = currentObj[key] || {};
-            currentObj = currentObj[key];
-        }
-        currentObj[path[path.length - 1]] = value;
-    }
-    getPathForSelectJoinRecursive(statements, selectJoin) {
-        const originJoin = this.statements.selectJoin.find(j => j.joinEntity === selectJoin.originEntity);
-        let pathInJoin = [];
-        if (!originJoin) {
-            return [selectJoin.joinProperty];
-        }
-        if (originJoin.originEntity !== statements.originEntity) {
-            pathInJoin = this.getPathForSelectJoinRecursive(statements, originJoin);
-        }
-        return [selectJoin.joinProperty, ...pathInJoin];
-    }
-    findIdRecursively(models, selectJoined, join) {
-        let ids = models[selectJoined.originProperty][join.primaryKey];
-        if (typeof ids === 'undefined') {
-            const nextSelectJoined = this.statements.selectJoin.find(j => j.joinEntity === selectJoined.originEntity);
-            if (nextSelectJoined) {
-                // Chamada recursiva para a próxima camada
-                ids = this.findIdRecursively(models, nextSelectJoined, join);
-            }
-        }
-        return ids;
-    }
-    generateColumns() {
-        let columns = [
-            ...this.getColumnsEntity(this.model, this.statements.alias),
-        ];
-        if (this.statements.join) {
-            columns = [
-                ...columns,
-                ...this.statements.join.flatMap(join => this.getColumnsEntity(join.joinEntity, join.joinAlias)),
-            ];
-        }
-        return columns;
-    }
-    extractAliasForColumns() {
-        // @ts-ignore
-        this.statements.columns = this.statements.columns.map((column) => {
-            return this.discoverColumnAlias(column);
-        }).flat();
-    }
-    filterInvalidColumns() {
-        this.statements.columns = this.statements.columns.filter(Boolean);
-    }
-    includeUpdatedColumns() {
-        this.statements.columns.push(...this.updatedColumns);
-    }
     logExecution(result) {
         this.logger.debug(`SQL: ${result.sql} [${Date.now() - result.startTime}ms]`);
     }
-    /**
-     * @deprecated Use inTransaction() instead
-     */
-    startTransaction() {
-        throw new Error('startTransaction() is deprecated. Use inTransaction() instead.');
-    }
-    /**
-     * @deprecated Use inTransaction() instead
-     */
-    commit() {
-        throw new Error('commit() is deprecated. Use inTransaction() instead.');
-    }
-    /**
-     * @deprecated Use inTransaction() instead
-     */
-    rollback() {
-        throw new Error('rollback() is deprecated. Use inTransaction() instead.');
-    }
     async inTransaction(callback) {
         return await this.driver.transaction(async (tx) => {
             // @ts-ignore
@@ -337,243 +196,32 @@ export class SqlBuilder {
         });
     }
     objectToStringMap(obj, parentKey = '') {
-        let result = [];
-        for (let key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                let fullKey = parentKey ? `${parentKey}.${key}` : key;
-                if (typeof obj[key] === 'object' && obj[key] !== null) {
-                    result = result.concat(this.objectToStringMap(obj[key], fullKey));
-                }
-                else {
-                    result.push(`${this.discoverColumnAlias(fullKey, true)} ${obj[key]}`);
-                }
-            }
-        }
-        return result;
+        return Object.keys(obj)
+            .filter(key => obj.hasOwnProperty(key))
+            .flatMap(key => this.mapObjectKey(obj, key, parentKey));
     }
-    discoverColumnAlias(column, onlyAlias = false) {
-        if (!column.includes('.')) {
-            if (onlyAlias) {
-                return `${this.statements.alias}."${column}"`;
-            }
-            return `${this.statements.alias}."${column}" as ${this.statements.alias}_${column}`;
+    mapObjectKey(obj, key, parentKey) {
+        const fullKey = parentKey ? `${parentKey}.${key}` : key;
+        if (this.isNestedObject(obj[key])) {
+            return this.objectToStringMap(obj[key], fullKey);
         }
-        if (typeof this.statements.join === 'undefined' && typeof this.statements.selectJoin === 'undefined') {
-            throw new Error('Join not found');
-        }
-        const entities = column.split('.');
-        let lastEntity = this.model;
-        let lastAlias = this.statements.alias;
-        const relationsMap = new Map(this.entity.relations.map(rel => [rel.propertyKey, rel]));
-        const joinMap = new Map();
-        const joinSelectMap = new Map();
-        this.statements.join?.forEach(join => joinMap.set(join.joinProperty, join));
-        this.statements.selectJoin?.forEach(join => joinSelectMap.set(join.joinProperty, join));
-        for (let i = 0; i < entities.length; i++) {
-            if (i === 0) {
-                const relation = relationsMap.get(entities[i]);
-                lastEntity = relation?.entity();
-                // @ts-ignore
-                if (joinMap.has(entities[i])) {
-                    lastAlias = joinMap.get(entities[i]).joinAlias;
-                }
-                else {
-                    lastAlias = joinSelectMap.get(entities[i])?.alias;
-                    return undefined;
-                }
-            }
-            else {
-                if ((i + 1) === entities.length) {
-                    if (onlyAlias) {
-                        return `${lastAlias}."${entities[i]}"`;
-                    }
-                    return `${lastAlias}."${entities[i]}" as ${lastAlias}_${entities[i]}`;
-                }
-                const lastStatement = joinMap.get(entities[i]);
-                lastEntity = lastStatement?.joinEntity;
-                // @ts-ignore
-                lastAlias = lastStatement?.joinAlias;
-            }
+        if (parentKey) {
+            return [`${this.columnManager.discoverAlias(fullKey, true)} ${obj[key]}`];
         }
-        return '';
+        const columnName = ValueProcessor.getColumnName(key, this.entity);
+        return [`${this.columnManager.discoverAlias(columnName, true)} ${obj[key]}`];
+    }
+    isNestedObject(value) {
+        return typeof value === 'object' && value !== null;
     }
     getTableName() {
         const tableName = this.entity.tableName || this.model.name.toLowerCase();
         const schema = this.entity.schema || 'public';
         return { tableName, schema };
     }
-    addSimpleConditionToSql(key, value, alias = null, operator = '=') {
-        const aliasToUse = alias || this.statements.alias;
-        const valueByType = (typeof value === 'string') ? `'${value}'` : value;
-        return `${aliasToUse}.${key} ${operator} ${valueByType}`;
-    }
-    addInConditionToSql(key, values, alias = null) {
-        const aliasToUse = alias || this.statements.alias;
-        return `${aliasToUse}.${key} IN (${values.map(val => (typeof val === 'string') ? `'${val}'` : val).join(", ")})`;
-    }
-    addLogicalOperatorToSql(conditions, operator) {
-        return `(${conditions.join(` ${operator} `)})`;
-    }
-    conditionToSql(condition, alias, model) {
-        const sqlParts = [];
-        const operators = ['$eq', '$ne', '$in', '$nin', '$like', '$gt', '$gte', '$lt', '$lte', '$and', '$or'];
-        for (let [key, value] of Object.entries(condition)) {
-            if (extendsFrom(ValueObject, value.constructor.prototype)) {
-                value = value.getValue();
-            }
-            if (!operators.includes(key)) {
-                this.lastKeyNotOperator = key;
-            }
-            const entity = this.entityStorage.get(model);
-            const relationShip = entity.relations?.find(rel => rel.propertyKey === key);
-            if (relationShip) {
-                const sql = this.applyJoin(relationShip, value, alias);
-                if (this.statements.strategy === 'joined') {
-                    sqlParts.push(sql);
-                }
-            }
-            else if (typeof value !== 'object' || value === null) {
-                if (key === '$eq') {
-                    sqlParts.push(this.addSimpleConditionToSql(this.lastKeyNotOperator, value, alias, '='));
-                    continue;
-                }
-                sqlParts.push(this.addSimpleConditionToSql(key, value, alias));
-            }
-            else if (!(operators.includes(key)) && Array.isArray(value)) {
-                sqlParts.push(this.addInConditionToSql(key, value, alias));
-            }
-            else {
-                if (['$or', '$and'].includes(key)) {
-                    sqlParts.push(this.addLogicalOperatorToSql(value.map((cond) => this.conditionToSql(cond, alias, model)), key.toUpperCase().replace('$', '')));
-                }
-                for (const operator of operators) {
-                    if (operator in value) {
-                        switch (operator) {
-                            case '$eq':
-                                sqlParts.push(this.addSimpleConditionToSql(key, value['$eq'], alias, '='));
-                                break;
-                            case '$ne':
-                                sqlParts.push(this.addSimpleConditionToSql(key, value['$ne'], alias, '!='));
-                                break;
-                            case '$in':
-                                sqlParts.push(this.addInConditionToSql(key, value['$in'], alias));
-                                break;
-                            case '$nin':
-                                sqlParts.push(`${alias}.${key} NOT IN (${value['$nin'].map((val) => this.t(val)).join(", ")})`);
-                                break;
-                            case '$like':
-                                sqlParts.push(`${alias}.${key} LIKE '${value['$like']}'`);
-                                break;
-                            case '$gt':
-                                sqlParts.push(`${alias}.${key} > ${value['$gt']}`);
-                                break;
-                            case '$gte':
-                                sqlParts.push(`${alias}.${key} >= ${value['$gte']}`);
-                                break;
-                            case '$lt':
-                                sqlParts.push(`${alias}.${key} < ${value['$lt']}`);
-                                break;
-                            case '$lte':
-                                sqlParts.push(`${alias}.${key} <= ${value['$lte']}`);
-                                break;
-                            case '$and':
-                            case '$or':
-                                const parts = value[operator].map((cond) => this.conditionToSql(cond, alias, model));
-                                sqlParts.push(this.addLogicalOperatorToSql(parts, operator.toUpperCase().replace('$', '')));
-                                break;
-                        }
-                    }
-                }
-            }
-        }
-        if (sqlParts.length === 0) {
-            return '';
-        }
-        return this.addLogicalOperatorToSql(sqlParts, 'AND');
-    }
     t(value) {
         return (typeof value === 'string') ? `'${value}'` : value;
     }
-    applyJoin(relationShip, value, alias) {
-        const { tableName, schema } = this.getTableName();
-        const { tableName: joinTableName, schema: joinSchema, hooks: joinHooks, } = this.entityStorage.get(relationShip.entity()) || {
-            tableName: relationShip.entity().name.toLowerCase(),
-            schema: 'public',
-        };
-        let originPrimaryKey = 'id';
-        for (const prop in this.entity.properties) {
-            if (this.entity.properties[prop].options.isPrimary) {
-                originPrimaryKey = prop;
-                break;
-            }
-        }
-        const joinAlias = `${this.getAlias(joinTableName)}`;
-        const joinWhere = this.conditionToSql(value, joinAlias, relationShip.entity());
-        let on = '';
-        switch (relationShip.relation) {
-            case "one-to-many":
-                on = `${joinAlias}."${this.getFkKey(relationShip)}" = ${alias}."${originPrimaryKey}"`;
-                break;
-            case "many-to-one":
-                on = `${alias}."${relationShip.columnName}" = ${joinAlias}."${this.getFkKey(relationShip)}"`;
-                break;
-        }
-        if (this.statements.strategy === 'joined') {
-            this.statements.join = this.statements.join || [];
-            this.statements.join.push({
-                joinAlias: joinAlias,
-                joinTable: joinTableName,
-                joinSchema: joinSchema || 'public',
-                joinWhere: joinWhere,
-                joinProperty: relationShip.propertyKey,
-                originAlias: alias,
-                originSchema: schema,
-                originTable: tableName,
-                propertyKey: relationShip.propertyKey,
-                joinEntity: relationShip.entity(),
-                type: 'LEFT',
-                // @ts-ignore
-                on,
-                originalEntity: relationShip.originalEntity,
-                hooks: joinHooks,
-            });
-        }
-        else {
-            this.statements.selectJoin = this.statements.selectJoin || [];
-            this.statements.selectJoin.push({
-                statement: 'select',
-                columns: this.originalColumns.filter(column => column.startsWith(`${relationShip.propertyKey}`)).map(column => column.split('.')[1]) || [],
-                table: `"${joinSchema || 'public'}"."${joinTableName}"`,
-                alias: joinAlias,
-                where: joinWhere,
-                joinProperty: relationShip.propertyKey,
-                fkKey: this.getFkKey(relationShip),
-                primaryKey: originPrimaryKey,
-                originAlias: alias,
-                originProperty: relationShip.propertyKey,
-                joinEntity: relationShip.entity(),
-                originEntity: relationShip.originalEntity,
-                hooks: joinHooks,
-            });
-        }
-        return joinWhere;
-    }
-    getFkKey(relationShip) {
-        // se for nullable, deverá retornar o primary key da entidade target
-        if (typeof relationShip.fkKey === 'undefined') {
-            return 'id'; // TODO: Pegar dinamicamente o primary key da entidade target
-        }
-        // se o fkKey é uma função, ele retornará a propriedade da entidade que é a chave estrangeira
-        // precisamos pegar o nome dessa propriedade
-        if (typeof relationShip.fkKey === 'string') {
-            return relationShip.fkKey;
-        }
-        const match = /\.(?<propriedade>[\w]+)/.exec(relationShip.fkKey.toString());
-        const propertyKey = match ? match.groups.propriedade : '';
-        const entity = this.entityStorage.get(relationShip.entity());
-        const property = Object.entries(entity.properties).find(([key, _value]) => key === propertyKey)?.[1];
-        return property.options.columnName;
-    }
     // private conditionLogicalOperatorToSql<T extends typeof BaseEntity>(conditions: Condition<T>[], operator: 'AND' | 'OR'): string {
     //   const sqlParts = conditions.map(cond => this.conditionToSql(cond));
     //   return this.addLogicalOperatorToSql(sqlParts, operator);
@@ -586,57 +234,6 @@ export class SqlBuilder {
         }
         this.entity = entity;
     }
-    transformToModel(model, statement, data) {
-        const instance = new model();
-        instance.$_isPersisted = true;
-        const entitiesByAlias = {
-            [statement.alias]: instance,
-        };
-        const entitiesOptions = new Map();
-        entitiesOptions.set(statement.alias, this.entityStorage.get(instance.constructor));
-        if (this.statements.join) {
-            this.statements.join.forEach(join => {
-                const joinInstance = new join.joinEntity();
-                joinInstance.$_isPersisted = true;
-                entitiesByAlias[join.joinAlias] = joinInstance;
-                entitiesOptions.set(join.joinAlias, this.entityStorage.get(joinInstance.constructor));
-            });
-        }
-        Object.entries(data).forEach(([key, value]) => {
-            const index = key.indexOf('_');
-            const alias = key.substring(0, index);
-            const prop = key.substring(index + 1);
-            const entity = entitiesByAlias[alias];
-            if (!entity) {
-                return;
-            }
-            const ep = Object.entries(entitiesOptions.get(alias).properties).find(([_, value]) => value.options.columnName === prop);
-            const entityProperty = ep?.[1];
-            const keyProperty = ep?.[0];
-            if (entityProperty) {
-                if (extendsFrom(ValueObject, entityProperty.type.prototype)) {
-                    // @ts-ignore
-                    entity[keyProperty] = new entityProperty.type(value);
-                    return;
-                }
-                entity[keyProperty] = value;
-            }
-        });
-        if (this.statements.join) {
-            this.statements.join.forEach(join => {
-                const { joinAlias, originAlias, propertyKey } = join;
-                const originEntity = entitiesByAlias[originAlias];
-                const joinEntity = entitiesByAlias[joinAlias];
-                const property = entitiesOptions.get(originAlias).relations.find(rel => rel.propertyKey === propertyKey);
-                if (!originEntity || !joinEntity) {
-                    return;
-                }
-                // @ts-ignore
-                originEntity[propertyKey] = (property.type === Array) ? (originEntity[propertyKey]) ? [...originEntity[propertyKey], joinEntity] : [joinEntity] : joinEntity;
-            });
-        }
-        return instance;
-    }
     /**
      * Retrieves an alias for a given table name.
      *
@@ -645,170 +242,91 @@ export class SqlBuilder {
      * @returns {string} - The alias for the table name.
      */
     getAlias(tableName) {
-        const alias = tableName.split('').shift() || '';
-        let counter = 1;
-        let uniqueAlias = `${alias}${counter}`;
-        while (this.aliases.has(uniqueAlias)) {
-            counter++;
-            uniqueAlias = `${alias}${counter}`;
-        }
+        const baseAlias = tableName.split('').shift() || '';
+        const uniqueAlias = this.generateUniqueAlias(baseAlias);
         this.aliases.add(uniqueAlias);
         return uniqueAlias;
     }
-    getColumnsEntity(entity, alias) {
-        const e = this.entityStorage.get(entity);
-        if (!e) {
-            throw new Error('Entity not found');
-        }
-        const columns = Object.keys(e.properties).map(key => `${alias}."${e.properties[key].options.columnName}" as "${alias}_${e.properties[key].options.columnName}"`);
-        if (e.relations) {
-            for (const relation of e.relations) {
-                if (relation.relation === 'many-to-one') {
-                    // @ts-ignore
-                    columns.push(`${alias}."${relation.columnName}" as "${alias}_${relation.columnName}"`);
-                }
-            }
+    generateUniqueAlias(baseAlias) {
+        let counter = 1;
+        let candidate = `${baseAlias}${counter}`;
+        while (this.aliases.has(candidate)) {
+            counter++;
+            candidate = `${baseAlias}${counter}`;
         }
-        return columns;
+        return candidate;
     }
     withDefaultValues(values, entityOptions) {
-        const property = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onInsert);
+        this.applyDefaultProperties(values, entityOptions);
+        this.applyOnInsertProperties(values, entityOptions);
+        return values;
+    }
+    applyDefaultProperties(values, entityOptions) {
         const defaultProperties = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.default);
         for (const [key, property] of defaultProperties) {
-            if (typeof values[key] === 'undefined') {
-                if (typeof property.options.default === 'function') {
-                    values[key] = eval(property.options.default());
-                }
-                else {
-                    values[key] = eval(property.options.default);
-                }
-            }
+            this.setDefaultValue(values, key, property);
         }
-        property.forEach(([key, property]) => {
-            values[key] = property.options.onInsert();
-            this.updatedColumns.push(`${this.statements.alias}."${key}" as "${this.statements.alias}_${key}"`);
-        });
-        return values;
+    }
+    setDefaultValue(values, key, property) {
+        if (typeof values[key] !== 'undefined')
+            return;
+        values[key] = typeof property.options.default === 'function'
+            ? property.options.default()
+            : property.options.default;
+    }
+    applyOnInsertProperties(values, entityOptions) {
+        const properties = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onInsert);
+        properties.forEach(([key, property]) => this.applyOnInsert(values, key, property));
+    }
+    applyOnInsert(values, key, property) {
+        values[key] = property.options.onInsert();
+        this.updatedColumns.push(`${this.statements.alias}."${key}" as "${this.statements.alias}_${key}"`);
     }
     withUpdatedValues(values, entityOptions) {
-        const property = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onUpdate);
-        property.forEach(([key, property]) => {
-            values[property.options.columnName] = property.options.onUpdate();
-            this.updatedColumns.push(`${this.statements.alias}."${property.options.columnName}" as "${this.statements.alias}_${property.options.columnName}"`);
-        });
+        const properties = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onUpdate);
+        properties.forEach(([key, property]) => this.applyOnUpdate(values, property));
         return values;
     }
+    applyOnUpdate(values, property) {
+        const columnName = property.options.columnName;
+        values[columnName] = property.options.onUpdate();
+        this.updatedColumns.push(`${this.statements.alias}."${columnName}" as "${this.statements.alias}_${columnName}"`);
+    }
     callHook(type, model) {
         const hooks = this.statements.hooks?.filter(hook => hook.type === type) || [];
         const instance = model || this.statements.instance;
-        for (const hook of hooks) {
-            instance[hook.propertyName]();
-            if (!model) {
-                this.reflectToValues();
-            }
-        }
+        hooks.forEach(hook => this.executeHook(hook, instance, !model));
+    }
+    executeHook(hook, instance, shouldReflect) {
+        instance[hook.propertyName]();
+        if (shouldReflect)
+            this.reflectToValues();
     }
     reflectToValues() {
         for (const key in this.statements.instance) {
-            if (key.startsWith('$')) {
-                continue;
-            }
-            if (key.startsWith('_')) {
-                continue;
-            }
-            if (this.entity.properties[key]) {
-                this.statements.values[this.entity.properties[key].options.columnName] = this.statements.instance[key];
+            if (this.shouldSkipKey(key))
                 continue;
-            }
-            const rel = this.entity.relations.find(rel => rel.propertyKey === key);
-            if (rel) {
-                this.statements.values[rel.columnName] = this.statements.instance[key];
-            }
+            this.reflectKey(key);
         }
     }
-}
-function processValuesForInsert(values, options) {
-    const newValue = {};
-    for (const value in values) {
-        const columnName = getColumnName(value, options);
-        if (extendsFrom(ValueObject, values[value].constructor.prototype)) {
-            newValue[columnName] = values[value].getValue();
-            continue;
-        }
-        if (values[value] instanceof BaseEntity) {
-            // @ts-ignore
-            newValue[columnName] = values[value].id; // TODO: get primary key
-            continue;
-        }
-        newValue[columnName] = values[value];
+    shouldSkipKey(key) {
+        return key.startsWith('$') || key.startsWith('_');
     }
-    return newValue;
-}
-function processValuesForUpdate(values, options) {
-    const newValue = {};
-    for (const value in values) {
-        if (extendsFrom(ValueObject, values[value].constructor.prototype)) {
-            newValue[getColumnName(value, options)] = values[value].getValue();
-            continue;
+    reflectKey(key) {
+        if (this.entity.properties[key]) {
+            this.reflectProperty(key);
+            return;
         }
-        newValue[getColumnName(value, options)] = values[value];
+        this.reflectRelation(key);
     }
-    return newValue;
-}
-function getColumnName(propertyKey, entity) {
-    const property = entity.properties[propertyKey];
-    const relation = entity.relations?.find(rel => rel.propertyKey === propertyKey);
-    if (propertyKey.startsWith('$')) {
-        return propertyKey;
-    }
-    if (!property) {
-        if (relation) {
-            return relation.columnName || propertyKey;
-        }
-        throw new Error('Property not found');
+    reflectProperty(key) {
+        const columnName = this.entity.properties[key].options.columnName;
+        this.statements.values[columnName] = this.statements.instance[key];
     }
-    return property.options.columnName || propertyKey;
-}
-function upEntity(values, entity, moment = undefined) {
-    const entityStorage = EntityStorage.getInstance();
-    const entityOptions = entityStorage.get(entity);
-    // @ts-ignore
-    const instance = new entity();
-    if (!entityOptions) {
-        throw new Error('Entity not found');
-    }
-    const property = Object.entries(entityOptions.properties);
-    const relations = entityOptions.relations;
-    property.forEach(([key, property]) => {
-        if (property.options.onInsert && moment === 'insert') {
-            instance[key] = property.options.onInsert();
-        }
-        if (property.options.onInsert && moment === 'update') {
-            instance[key] = property.options.onUpdate();
-        }
-        if (key in values) {
-            instance[key] = values[property.options.columnName];
-        }
-    });
-    if (relations) {
-        for (const relation of relations) {
-            if (relation.relation === 'many-to-one') {
-                // @ts-ignore
-                instance[relation.propertyKey] = values[relation.columnName];
-            }
-        }
-    }
-    return instance;
-}
-function convertWhereObj(where, entity) {
-    let newWhere = {};
-    for (const key in where) {
-        if (where[key] instanceof Object) { // Se o valor atual é um objeto, chame a mesma função recursivamente
-            newWhere[getColumnName(key, entity)] = convertWhereObj(where[key], entity);
-        }
-        else {
-            newWhere[getColumnName(key, entity)] = where[key];
+    reflectRelation(key) {
+        const rel = this.entity.relations.find(rel => rel.propertyKey === key);
+        if (rel) {
+            this.statements.values[rel.columnName] = this.statements.instance[key];
         }
     }
-    return newWhere;
 }