@cheetah.js/orm 0.1.14 → 0.1.15

package/dist/SqlBuilder.d.ts

@@ -1,4 +1,4 @@
-import { AutoPath, FilterQuery, QueryOrderMap, ValueOrInstance } from './driver/driver.interface';
+import { AutoPath, FilterQuery, QueryOrderMap, Statement, ValueOrInstance } from './driver/driver.interface';
 export declare class SqlBuilder<T> {
     private readonly driver;
     private entityStorage;
@@ -9,8 +9,10 @@ export declare class SqlBuilder<T> {
     private lastKeyNotOperator;
     private logger;
     private updatedColumns;
+    private originalColumns;
     constructor(model: new () => T);
     select(columns?: AutoPath<T, never, '*'>[]): SqlBuilder<T>;
+    setStrategy(strategy?: 'joined' | 'select'): SqlBuilder<T>;
     insert(values: Partial<{
         [K in keyof T]: ValueOrInstance<T[K]>;
     }>): SqlBuilder<T>;
@@ -23,14 +25,27 @@ export declare class SqlBuilder<T> {
     }) | QueryOrderMap<T>[]): SqlBuilder<T>;
     limit(limit: number | undefined): SqlBuilder<T>;
     offset(offset: number | undefined): SqlBuilder<T>;
-    executeAndReturnFirst(): Promise<T | undefined>;
-    executeAndReturnFirstOrFail(): Promise<T>;
-    executeAndReturnAll(): Promise<T[]>;
+    load(load: string[]): SqlBuilder<T>;
+    private addJoinForRelationshipPath;
+    private getPrimaryKeyColumnName;
     execute(): Promise<{
         query: any;
         startTime: number;
         sql: string;
     }>;
+    executeAndReturnFirst(): Promise<T | undefined>;
+    executeAndReturnFirstOrFail(): Promise<T>;
+    executeAndReturnAll(): Promise<T[]>;
+    private handleSelectJoin;
+    getPathForSelectJoin(selectJoin: Statement<any>): string[] | null;
+    private setValueByPath;
+    private getPathForSelectJoinRecursive;
+    private findIdRecursively;
+    private generateColumns;
+    private extractAliasForColumns;
+    private filterInvalidColumns;
+    private includeUpdatedColumns;
+    private logExecution;
     startTransaction(): Promise<void>;
     commit(): Promise<void>;
     rollback(): Promise<void>;

package/dist/SqlBuilder.js

@@ -1,6 +1,7 @@
 import { EntityStorage } from './domain/entities';
 import { Orm } from './orm';
 import { ValueObject } from './common/value-object';
+import { BaseEntity } from '@cheetah.js/orm/domain/base-entity';
 export class SqlBuilder {
     driver;
     entityStorage;
@@ -11,6 +12,7 @@ export class SqlBuilder {
     lastKeyNotOperator = '';
     logger;
     updatedColumns = [];
+    originalColumns = [];
     constructor(model) {
         const orm = Orm.getInstance();
         this.driver = orm.driverInstance;
@@ -23,17 +25,18 @@ export class SqlBuilder {
         const schema = this.entity.schema || 'public';
         this.statements.statement = 'select';
         this.statements.columns = columns;
+        this.originalColumns = columns || [];
         this.statements.alias = this.getAlias(tableName);
         this.statements.table = `"${schema}"."${tableName}"`;
         return this;
     }
+    setStrategy(strategy = 'joined') {
+        this.statements.strategy = strategy;
+        return this;
+    }
     insert(values) {
         const { tableName, schema } = this.getTableName();
-        for (let value in values) {
-            if (this.extendsFrom(ValueObject, values[value].constructor.prototype)) {
-                values[value] = values[value].getValue();
-            }
-        }
+        processValuesForInsert(values);
         this.statements.statement = 'insert';
         this.statements.alias = this.getAlias(tableName);
         this.statements.table = `"${schema}"."${tableName}"`;
@@ -42,11 +45,7 @@ export class SqlBuilder {
     }
     update(values) {
         const { tableName, schema } = this.getTableName();
-        for (let value in values) {
-            if (this.extendsFrom(ValueObject, values[value].constructor.prototype)) {
-                values[value] = values[value].getValue();
-            }
-        }
+        processValuesForUpdate(values);
         this.statements.statement = 'update';
         this.statements.alias = this.getAlias(tableName);
         this.statements.table = `${schema}.${tableName}`;
@@ -54,14 +53,14 @@ export class SqlBuilder {
         return this;
     }
     where(where) {
-        if (typeof where === 'undefined' || Object.entries(where).length === 0) {
+        if (!where || Object.keys(where).length === 0) {
             return this;
         }
-        this.statements.where = this.conditionToSql(where, this.statements.alias);
+        this.statements.where = this.conditionToSql(where, this.statements.alias, this.model);
         return this;
     }
     orderBy(orderBy) {
-        if (typeof orderBy === 'undefined') {
+        if (!orderBy) {
             return this;
         }
         this.statements.orderBy = this.objectToStringMap(orderBy);
@@ -75,13 +74,77 @@ export class SqlBuilder {
         this.statements.offset = offset;
         return this;
     }
+    load(load) {
+        load?.forEach(relationshipPath => {
+            this.addJoinForRelationshipPath(this.entity, relationshipPath);
+        });
+        if (this.statements.join) {
+            this.statements.join = this.statements.join?.reverse();
+        }
+        if (this.statements.selectJoin) {
+            this.statements.selectJoin = this.statements.selectJoin?.reverse();
+        }
+        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
+        // Por exemplo, se a chave primária for sempre 'id', você pode retornar 'id'.
+        // Se a lógica for mais complexa, você pode adicionar um método na classe Options para obter a chave primária.
+        return 'id';
+    }
+    async execute() {
+        if (!this.statements.columns) {
+            this.statements.columns = this.generateColumns();
+        }
+        else {
+            this.extractAliasForColumns();
+            this.filterInvalidColumns();
+        }
+        this.statements.join = this.statements.join?.reverse();
+        this.includeUpdatedColumns();
+        const result = await this.driver.executeStatement(this.statements);
+        this.logExecution(result);
+        return result;
+    }
     async executeAndReturnFirst() {
         this.statements.limit = 1;
         const result = await this.execute();
         if (result.query.rows.length === 0) {
             return undefined;
         }
-        return this.transformToModel(result.query.rows[0]);
+        const entities = result.query.rows[0];
+        const model = await this.transformToModel(this.model, this.statements, entities);
+        await this.handleSelectJoin(entities, model);
+        return model;
     }
     async executeAndReturnFirstOrFail() {
         this.statements.limit = 1;
@@ -89,40 +152,126 @@ export class SqlBuilder {
         if (result.query.rows.length === 0) {
             throw new Error('Result not found');
         }
-        return this.transformToModel(result.query.rows[0]);
+        const entities = result.query.rows[0];
+        const model = await this.transformToModel(this.model, this.statements, entities);
+        await this.handleSelectJoin(entities, model);
+        return model;
     }
-    // TODO: Corrigir tipagem do retorno de acordo com o driver
     async executeAndReturnAll() {
         const result = await this.execute();
         if (result.query.rows.length === 0) {
             return [];
         }
-        return result.query.rows.map((row) => this.transformToModel(row));
+        const rows = result.query.rows;
+        const results = [];
+        for (const row of rows) {
+            const models = this.transformToModel(this.model, this.statements, row);
+            await this.handleSelectJoin(row, models);
+            results.push(models);
+        }
+        return results;
     }
-    async execute() {
-        if (!this.statements.columns) {
-            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)),
-                ];
+    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})`;
             }
-            this.statements.columns = columns;
+            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]);
         }
-        else {
-            // @ts-ignore
-            this.statements.columns = this.statements.columns.map((column) => {
-                return this.discoverColumnAlias(column);
-            }).flat();
+        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);
-        const result = await this.driver.executeStatement(this.statements);
-        // console.log(result.query.rows);
+    }
+    logExecution(result) {
         this.logger.debug(`SQL: ${result.sql} [${Date.now() - result.startTime}ms]`);
-        return result;
     }
     startTransaction() {
         return this.driver.startTransaction();
@@ -169,20 +318,29 @@ export class SqlBuilder {
             }
             return `${this.statements.alias}."${column}" as ${this.statements.alias}_${column}`;
         }
-        if (typeof this.statements.join === 'undefined') {
+        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(this.statements.join.map(join => [join.joinProperty, join]));
+        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
-                lastAlias = joinMap.get(entities[i])?.joinAlias;
+                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) {
@@ -216,7 +374,7 @@ export class SqlBuilder {
     addLogicalOperatorToSql(conditions, operator) {
         return `(${conditions.join(` ${operator} `)})`;
     }
-    conditionToSql(condition, alias) {
+    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)) {
@@ -226,9 +384,13 @@ export class SqlBuilder {
             if (!operators.includes(key)) {
                 this.lastKeyNotOperator = key;
             }
-            const relationShip = this.entity.relations?.find(rel => rel.propertyKey === key);
+            const entity = this.entityStorage.get(model);
+            const relationShip = entity.relations?.find(rel => rel.propertyKey === key);
             if (relationShip) {
-                sqlParts.push(this.applyJoin(relationShip, value, alias));
+                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') {
@@ -242,7 +404,7 @@ export class SqlBuilder {
             }
             else {
                 if (['$or', '$and'].includes(key)) {
-                    sqlParts.push(this.addLogicalOperatorToSql(value.map((cond) => this.conditionToSql(cond, alias)), key.toUpperCase().replace('$', '')));
+                    sqlParts.push(this.addLogicalOperatorToSql(value.map((cond) => this.conditionToSql(cond, alias, model)), key.toUpperCase().replace('$', '')));
                 }
                 for (const operator of operators) {
                     if (operator in value) {
@@ -276,7 +438,7 @@ export class SqlBuilder {
                                 break;
                             case '$and':
                             case '$or':
-                                const parts = value[operator].map((cond) => this.conditionToSql(cond, alias));
+                                const parts = value[operator].map((cond) => this.conditionToSql(cond, alias, model));
                                 sqlParts.push(this.addLogicalOperatorToSql(parts, operator.toUpperCase().replace('$', '')));
                                 break;
                         }
@@ -284,6 +446,9 @@ export class SqlBuilder {
                 }
             }
         }
+        if (sqlParts.length === 0) {
+            return '';
+        }
         return this.addLogicalOperatorToSql(sqlParts, 'AND');
     }
     t(value) {
@@ -303,33 +468,52 @@ export class SqlBuilder {
             }
         }
         const joinAlias = `${this.getAlias(joinTableName)}`;
-        const joinWhere = this.conditionToSql(value, joinAlias);
-        this.statements.join = this.statements.join || [];
+        const joinWhere = this.conditionToSql(value, joinAlias, relationShip.entity());
         let on = '';
         switch (relationShip.relation) {
             case "one-to-many":
-                on = `${joinAlias}.${this.getFkKey(relationShip)} = ${alias}.${originPrimaryKey}`;
+                on = `${joinAlias}."${this.getFkKey(relationShip)}" = ${alias}."${originPrimaryKey}"`;
                 break;
             case "many-to-one":
-                on = `${alias}.${relationShip.propertyKey} = ${joinAlias}.${this.getFkKey(relationShip)}`;
+                on = `${alias}."${relationShip.propertyKey}" = ${joinAlias}."${this.getFkKey(relationShip)}"`;
                 break;
         }
-        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,
-        });
+        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,
+            });
+        }
+        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,
+            });
+        }
         return joinWhere;
     }
     getFkKey(relationShip) {
@@ -357,14 +541,14 @@ export class SqlBuilder {
         }
         this.entity = entity;
     }
-    transformToModel(data) {
-        const instance = new this.model();
+    transformToModel(model, statement, data) {
+        const instance = new model();
         instance.$_isPersisted = true;
         const entitiesByAlias = {
-            [this.statements.alias]: instance,
+            [statement.alias]: instance,
         };
         const entitiesOptions = new Map();
-        entitiesOptions.set(this.statements.alias, this.entityStorage.get(instance.constructor));
+        entitiesOptions.set(statement.alias, this.entityStorage.get(instance.constructor));
         if (this.statements.join) {
             this.statements.join.forEach(join => {
                 const joinInstance = new join.joinEntity();
@@ -428,7 +612,16 @@ export class SqlBuilder {
         if (!e) {
             throw new Error('Entity not found');
         }
-        return Object.keys(e.showProperties).map(key => `${alias}."${key}" as "${alias}_${key}"`);
+        const columns = Object.keys(e.showProperties).map(key => `${alias}."${key}" as "${alias}_${key}"`);
+        if (e.relations) {
+            for (const relation of e.relations) {
+                if (relation.relation === 'many-to-one') {
+                    // @ts-ignore
+                    columns.push(`${alias}."${relation.propertyKey}" as "${alias}_${relation.propertyKey}"`);
+                }
+            }
+        }
+        return columns;
     }
     withDefaultValues(values, entityOptions) {
         const property = Object.entries(entityOptions.showProperties).filter(([_, value]) => value.options.onInsert);
@@ -468,4 +661,33 @@ export class SqlBuilder {
         return false;
     }
 }
+function processValuesForInsert(values) {
+    for (const value in values) {
+        if (extendsFrom(ValueObject, values[value].constructor.prototype)) {
+            values[value] = values[value].getValue();
+            continue;
+        }
+        if (values[value] instanceof BaseEntity) {
+            // @ts-ignore
+            values[value] = values[value].id; // TODO: get primary key
+        }
+    }
+}
+function processValuesForUpdate(values) {
+    for (const value in values) {
+        if (extendsFrom(ValueObject, values[value].constructor.prototype)) {
+            values[value] = values[value].getValue();
+        }
+    }
+}
+function extendsFrom(baseClass, instance) {
+    let proto = Object.getPrototypeOf(instance);
+    while (proto) {
+        if (proto === baseClass.prototype) {
+            return true;
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+}
 //# sourceMappingURL=SqlBuilder.js.map