v.0.4.4

Corrigido formas não suportadas de fazer um order by (por alias, por index, com subquery, com count, etc)

Author: fernandocode

package.json

@@ -1,6 +1,6 @@
 {
   "name": "database-builder",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Library to assist in creating and maintaining SQL commands.",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

src/core/enums/expression-or-column-enum.ts

@@ -1,4 +1,4 @@
 export enum ExpressionOrColumnEnum {
     Expression,
-    Column,
+    Column
 }

src/core/query-helper.ts

@@ -0,0 +1,18 @@
+import { QueryCompiled } from "./query-compiled";
+import { Replaceable } from "./replaceable";
+import { ParamType, Utils } from "./utils";
+
+export class QueryHelper {
+
+    public static compileWithoutParams(queryCompiled: QueryCompiled): string {
+        return Replaceable.replaceArrayPattern(queryCompiled.query, "?", this.formatParamsToInline(queryCompiled.params));
+    }
+
+    private static formatParamsToInline(params: ParamType[]): any[] {
+        return params.map(param => {
+            return Utils.isString(param) || Utils.isBoolean(param)
+                ? `'${param}'`
+                : param as any;
+        });
+    }
+}

src/core/replaceable.ts

@@ -0,0 +1,16 @@
+
+export class Replaceable {
+
+    public static replaceAt(base: string, index: number, replace: string) {
+        return index > -1
+            ? base.substring(0, index) + replace + base.substring(index + 1)
+            : base;
+    }
+
+    public static replaceArrayPattern(base: string, searchValue: string, replaceArray: string[]) {
+        replaceArray.forEach(replace => {
+            base = this.replaceAt(base, base.indexOf(searchValue), replace);
+        });
+        return base;
+    }
+}

src/core/utils.ts

@@ -23,6 +23,7 @@ import { MetadataTable } from "../metadata-table";
 import { MetadataTableBase } from "../metadata-table-base";
 import { ProjectionCompile } from "../crud/projection-compile";
 import * as lodash from "lodash";
+import { QueryCompiled } from ".";
 
 export type ParamType = ValueType | ReplacementParam;
 
@@ -33,6 +34,8 @@ export type TypeOrString<T> = (new () => T) | string;
 
 export type ExpressionOrColumn<TReturn, T> = ReturnExpression<TReturn, T> | string;
 
+export type TypeOrderBy<TReturn, T> = ExpressionOrColumn<TReturn, T> | PlanRef | number | QueryCompiled | QueryCompiled[];
+
 export type TypeWhere<T> = Expression<T> | ValueTypeToParse | ColumnRef | ProjectionsHelper<T> | PlanRef;
 
 export type TypeProjection<T> = ProjectionsHelper<T> | ColumnRef | PlanRef;
@@ -111,7 +114,7 @@ export class Utils {
     }
 
     public static isReservedBoolean(value: any): boolean {
-        return value === "true" || value === "false" || value === 0 || value === 1 ;
+        return value === "true" || value === "false" || value === 0 || value === 1;
     }
 
     public static isFunction(value: any): boolean {
@@ -166,13 +169,22 @@ export class Utils {
         return instance instanceof PlanRef;
     }
 
-    public static isEmpty(value: any) {
+    public static isEmpty(value: any): boolean {
         if (this.isBoolean(value) || this.isDate(value)) {
             return this.isNull(value);
         }
         return lodash.isEmpty(value);
     }
 
+    public static isQueryCompiled(value: any): boolean {
+        return value && this.isString(value.query) && this.isArray(value.params);
+    }
+
+    public static isQueryCompiledArray(value: any): boolean {
+        return (this.isArray(value)
+            && (value as any[]).filter(v => this.isQueryCompiled(v) === false).length === 0);
+    }
+
     public static databaseName<T>(tablename: TypeOrString<T>): string {
         return this.getValueByTypeOrString(tablename);
     }

src/crud/projection-builder.ts

@@ -108,11 +108,14 @@ export class ProjectionBuilder<T> {
     }
 
     public add<TReturn>(
-        expression: ExpressionOrColumn<TReturn, T>,
+        expression: ExpressionOrColumn<TReturn, T> | QueryCompiled[] | SqlCompilable,
         alias?: string,
     ): ProjectionBuilder<T> {
+        if ((expression as SqlCompilable).compile || Utils.isQueryCompiledArray(expression)) {
+            return this.subQuery((expression as (QueryCompiled[] | SqlCompilable)), alias);
+        }
         this.buildProjectionWithExpression(void 0,
-            expression,
+            expression as ExpressionOrColumn<TReturn, T>,
             alias,
         );
         return this;
@@ -284,7 +287,8 @@ export class ProjectionBuilder<T> {
     ): ProjectionBuilder<T> {
         const instanceProjection: ProjectionBuilder<T> = new ProjectionBuilder(this._typeT, this._aliasTable, void 0, false, this._getMapper);
         projectionCallback(instanceProjection);
-        const projectionInner = instanceProjection.compile();
+        const projectionInner = ProjectionCompile.compile(instanceProjection.result());
+        // const projectionInner = instanceProjection.compile();
         this.buildProjectionWithExpression(Projection.Coalesce,
             `${projectionInner.projection}, ${defaultValue}`,
             alias,
@@ -337,9 +341,12 @@ export class ProjectionBuilder<T> {
         return this;
     }
 
-    public compile(): ProjectionCompiled {
-        return ProjectionCompile.compile(this._projections);
+    public result(): ProjectionModel[] {
+        return this._projections;
     }
+    // public compile(): ProjectionCompiled {
+    //     return ProjectionCompile.compile(this._projections);
+    // }
 
     private selectAllColumns(mapper: MapperTable): void {
         const columns = mapper.columns.filter(x => Utils.isNull(x.tableReference));

src/crud/projection-case-when.ts

@@ -45,7 +45,8 @@ export class ProjectionCaseWhen<T> {
             this._whenBuilder.builder += ` ${type} ${projectionCompiled.projection}`;
             this._whenBuilder.params = this._whenBuilder.params.concat(projectionCompiled.params);
         } else if (Utils.isProjectionBuilder(projection)) {
-            const projectionCompiled = (projection as ProjectionBuilder<T>).compile();
+            const projectionCompiled = ProjectionCompile.compile((projection as ProjectionBuilder<T>).result());
+            // const projectionCompiled = (projection as ProjectionBuilder<T>).compile();
             this._whenBuilder.builder += ` ${type} ${projectionCompiled.projection}`;
             this._whenBuilder.params = this._whenBuilder.params.concat(projectionCompiled.params);
         } else {

src/crud/query/join-query-builder-contract.ts

@@ -1,15 +1,16 @@
-import { ProjectionCompiled } from "../projection-compiled";
 import { QueryBuilderBaseContract } from "./query-builder-base-contract";
 import { WhereCompiled } from "../where-compiled";
 import { ParamType } from "../../core/utils";
+import { ProjectionModel } from "../projection-model";
 
 export interface JoinQueryBuilderContract<T, TQuery extends JoinQueryBuilderContract<T, TQuery>>
     extends QueryBuilderBaseContract<T, TQuery> {
 
     _getOn(): WhereCompiled;
     _getTypeJoin(): string;
     _getWhere(): WhereCompiled;
-    _getSelect(): ProjectionCompiled;
+    _getProjections(): ProjectionModel[];
+    // _getSelect(): ProjectionCompiled;
     _getGroupBy(): string;
     _getHaving(): WhereCompiled;
     _getOrderBy(): string;

src/crud/query/join-query-builder.ts

@@ -9,6 +9,7 @@ import { ParamType, ValueType } from "../../core/utils";
 import { MapperTable } from "../../mapper-table";
 import { MetadataTable } from "../../metadata-table";
 import { QueryBuilder } from "./query-builder";
+import { ProjectionModel } from "../projection-model";
 
 export class JoinQueryBuilder<T>
     extends QueryBuilderBase<T, JoinQueryBuilder<T>>
@@ -37,10 +38,7 @@ export class JoinQueryBuilder<T>
     }
 
     public _getOn(): WhereCompiled {
-        const t = this.whereCompile(this._on.compile());
-        // console.log(this.tablename, t);
-        return t;
-        // return this._on.compile();
+        return this.whereCompile(this._on.compile());
     }
 
     public _getTypeJoin(): string {
@@ -52,9 +50,12 @@ export class JoinQueryBuilder<T>
         return this.whereCompiled;
     }
 
-    public _getSelect(): ProjectionCompiled {
-        return this._projectionCompiled;
+    public _getProjections(): ProjectionModel[] {
+        return this._projections;
     }
+    // public _getSelect(): ProjectionCompiled {
+    //     return this._projectionCompiled;
+    // }
 
     public _getGroupBy(): string {
         return this._groupBy;
@@ -70,12 +71,6 @@ export class JoinQueryBuilder<T>
 
     public _getParams(): ParamType[] {
         return this._joinParams;
-        // const compiled: QueryCompiled = this.buildBase();
-        // return compiled.params
-        //     .concat(this._joinParams)
-        //     .concat(this.whereCompiled.params)
-        //     .concat(this._having.params)
-        //     .concat(this._limit.params);
     }
 
     public addParamsOn(params: ValueType[]): JoinQueryBuilder<T> {
@@ -85,7 +80,6 @@ export class JoinQueryBuilder<T>
 
     // Para adicionar alias da tabela no apelido da projeção padrão
     protected createProjectionBuilder(): ProjectionBuilder<T> {
-        // return new ProjectionBuilder(this._typeT, this.alias, true);
         return super.createProjectionBuilder(true, void 0);
     }
 

src/crud/query/query-builder-base.ts

@@ -1,7 +1,7 @@
 import { ProjectionCompiled } from "../projection-compiled";
 import { UnionType } from "../../core/union-type";
 import { ProjectionBuilder } from "../projection-builder";
-import { ExpressionOrColumn, ParamType, Utils } from "../../core/utils";
+import { ExpressionOrColumn, ParamType, Utils, TypeOrderBy } from "../../core/utils";
 import { WhereBuilder } from "../where-builder";
 import { OrderBy } from "../../core/enums/order-by";
 import { WhereCompiled } from "../where-compiled";
@@ -22,6 +22,11 @@ import { DatabaseBuilderError } from "../../core";
 import { QueryBuilder } from "./query-builder";
 import { ModelUtils } from "../../core/model-utils";
 import { ParamFilter } from "../../core/param-filter";
+import { PlanRef } from "../../core/plan-ref";
+import { ProjectionModel } from "../projection-model";
+import { ProjectionCompile } from "../projection-compile";
+import { Replaceable } from "../../core/replaceable";
+import { QueryHelper } from "../../core/query-helper";
 
 export abstract class QueryBuilderBase<T,
     TQuery extends QueryBuilderBase<T, TQuery>>
@@ -44,10 +49,11 @@ export abstract class QueryBuilderBase<T,
         params: []
     } as WhereCompiled;
 
-    protected _projectionCompiled: ProjectionCompiled = {
-        projection: "",
-        params: []
-    } as ProjectionCompiled;
+    protected _projections: ProjectionModel[] = [];
+    // protected _projectionCompiled: ProjectionCompiled = {
+    //     projection: "",
+    //     params: []
+    // } as ProjectionCompiled;
     // TODO: remove "_joinParams" e utilizar SqlAndParams como é realizado nos projections
     protected _joinParams: ParamType[] = [];
     protected _ignoreQueryFilter: boolean = false;
@@ -193,7 +199,8 @@ export abstract class QueryBuilderBase<T,
     ): TQuery {
         const instanceProjection: ProjectionBuilder<T> = this.createProjectionBuilder();
         projectionCallback(instanceProjection);
-        this.compileProjection(instanceProjection.compile());
+        this.buildProjections(instanceProjection.result());
+        // this.compileProjection(instanceProjection.compile());
         return this._getInstance();
     }
 
@@ -204,21 +211,33 @@ export abstract class QueryBuilderBase<T,
     }
 
     public orderBy<TReturn>(
-        expression: ExpressionOrColumn<TReturn, T>,
+        expression: TypeOrderBy<TReturn, T>,
         order: OrderBy = OrderBy.ASC
     ): TQuery {
-        this.compileOrderBy(`${Utils.addAlias(Utils.getColumn(expression), this._alias)} ${order}`);
+        let columnName;
+        if (Utils.isQueryCompiled(expression)) {
+            return this.orderBy(`(${QueryHelper.compileWithoutParams(expression as QueryCompiled)})`, order);
+        } else if (Utils.isQueryCompiledArray(expression)) {
+            return this.orderBy((expression as QueryCompiled[])[0], order);
+        } else if (Utils.isPlanRef(expression)) {
+            columnName = (expression as PlanRef).result();
+        } else if (Utils.isNumber(expression)) {
+            columnName = `${(expression as number)}`;
+        } else {
+            columnName = Utils.addAlias(Utils.getColumn(expression as ExpressionOrColumn<TReturn, T>), this._alias);
+        }
+        this.compileOrderBy(`${columnName} ${order}`);
         return this._getInstance();
     }
 
     public asc<TReturn>(
-        expression: ExpressionOrColumn<TReturn, T>
+        expression: TypeOrderBy<TReturn, T>
     ): TQuery {
         return this.orderBy(expression, OrderBy.ASC);
     }
 
     public desc<TReturn>(
-        expression: ExpressionOrColumn<TReturn, T>
+        expression: TypeOrderBy<TReturn, T>
     ): TQuery {
         return this.orderBy(expression, OrderBy.DESC);
     }
@@ -246,6 +265,20 @@ export abstract class QueryBuilderBase<T,
         return this._getInstance();
     }
 
+    /**
+     * Find projection by alias and result index (base 1...N+1)
+     * @param projectionAlias alias to find the projection
+     * @returns index (base 1...N+1)
+     */
+    public getIndexProjection<TReturn>(projectionAlias: ExpressionOrColumn<TReturn, T>): number {
+        const projectionColumnAlias = Utils.getColumn(projectionAlias);
+        const index = this._projections.findIndex(x => x.projection.endsWith(` AS ${projectionColumnAlias}`));
+        if (index > -1) {
+            return index + 1;
+        }
+        throw new DatabaseBuilderError(`Not found projection alias ("${projectionColumnAlias}" in projections (current value: "${ProjectionCompile.compile(this._projections).projection}"))`);
+    }
+
     public ignoreQueryFilters(): TQuery {
         if (this._joinsQuery.length) {
             throw new DatabaseBuilderError(`Can't apply 'ignoreQueryFilters' after joining 'join()'`);
@@ -336,7 +369,8 @@ export abstract class QueryBuilderBase<T,
         this._joinsQuery.push(joinQuery);
         this._joinParams = this._joinParams.concat(joinQuery._getParams());
         this.compileWhere(this.whereCompiled, joinQuery._getWhere());
-        this.compileProjection(joinQuery._getSelect());
+        this.buildProjections(joinQuery._getProjections());
+        // this.compileProjection(joinQuery._getSelect());
         this.compileGroupBy(joinQuery._getGroupBy());
         this.compileHaving(joinQuery._getHaving());
         this.compileOrderBy(joinQuery._getOrderBy());
@@ -347,10 +381,14 @@ export abstract class QueryBuilderBase<T,
     }
 
     protected getColumnsCompiled(): ProjectionCompiled {
-        if (!this._projectionCompiled.projection.length) {
+        if (this._projections.length === 0) {
             this.setDefaultColumns();
         }
-        return this._projectionCompiled;
+        return ProjectionCompile.compile(this._projections);
+        // if (!this._projectionCompiled.projection.length) {
+        //     this.setDefaultColumns();
+        // }
+        // return this._projectionCompiled;
     }
 
     protected buildBase(): QueryCompiled {
@@ -404,15 +442,20 @@ export abstract class QueryBuilderBase<T,
         return queryBase;
     }
 
-    private compileProjection(compiled: ProjectionCompiled) {
-        if (compiled.projection.length) {
-            this._projectionCompiled.projection +=
-                `${(this._projectionCompiled.projection.length ? ", " : "")}${compiled.projection}`;
-            compiled.params.forEach((value: any) => {
-                this._projectionCompiled.params.push(value);
-            });
+    private buildProjections(projections: ProjectionModel[]) {
+        if (projections.length > 0) {
+            this._projections = [...this._projections, ...projections];
         }
     }
+    // private compileProjection(compiled: ProjectionCompiled) {
+    //     if (compiled.projection.length) {
+    //         this._projectionCompiled.projection +=
+    //             `${(this._projectionCompiled.projection.length ? ", " : "")}${compiled.projection}`;
+    //         compiled.params.forEach((value: any) => {
+    //             this._projectionCompiled.params.push(value);
+    //         });
+    //     }
+    // }
 
     private compileTableJoins<TJoin, TQueryJoin extends JoinQueryBuilderContract<TJoin, TQueryJoin>>(
         tablesBase: QueryCompiled,