- Add new features;

- Update Docs;
- Add tests;

Author: fernandocode

README.md

@@ -12,26 +12,87 @@ npm install --save database-builder
 ```
 This will install the current stable version of `database-builder` in your `node_modules` directory and save the entry in `package.json`.
 
-### Step 2: Usage Typescript (Angular 2+ example)
+### Step 2: Usage Typescript
 
-#### Step 2.1: Usage Query<T>
+[In StackBlitz](https://stackblitz.com/edit/typescript-cfzt6q)
 
 ```ts
-import { Component } from '@angular/core';
 import { Query } from 'database-builder';
+import { TestClazz, TestClazzRef } from './models';
 
-@Component({
-    selector: 'app-component',
-    templateUrl: 'app.html'
-})
-export class AppComponent {
-    
-    ngOnInit(){
-        let query = new Query(TestClazz);
-        query.
-    }
-}
+let querySimple = new Query(TestClazz);
+print(querySimple.compile());
+/**
+ * {
+ *  params: [],
+ *  query: "SELECT tes.* FROM TestClazz AS tes"
+ * }
+ */
+
+const queryWhere = new Query(TestClazz);
+queryWhere.where(where => {
+  where.contains(x => x.description, "abc");
+  where.greatValue(x => x.id, 1);
+});
+print(queryWhere.compile());
+/**
+ * {
+ *  params: ["%abc%", 1],
+ *  query: "SELECT tes.* FROM TestClazz AS tes WHERE tes.description LIKE ? AND tes.id > ?"
+ * }
+ */
+
+const queryProjections = new Query(TestClazz);
+queryProjections.projection(projection => {
+  projection.add(x => x.description);
+  projection.sum(x => x.id);
+  projection.max(x => x.referenceTest.id);
+  projection.count(x => x.id, "countId");
+});
+print(queryProjections.compile());
+/**
+ * {
+ *  params: [],
+ *  query: "SELECT tes.description AS description, SUM(tes.id) AS id, MAX(tes.referenceTest_id) AS referenceTest_id, COUNT(tes.id) AS countId FROM TestClazz AS tes"
+ * }
+ */
+
+const queryOrderBy = new Query(TestClazz);
+queryOrderBy.orderBy(x => x.id);
+print(queryOrderBy.compile());
+/**
+ * {
+ *  params: [],
+ *  query: "SELECT tes.* FROM TestClazz AS tes ORDER BY tes.id ASC"
+ * }
+ */
+
+const queryGroupBy = new Query(TestClazz);
+queryGroupBy.groupBy(x => x.id, (having, projection) => {
+    having.greatValue(projection.count(x => x.id), 10);
+  });
+print(queryGroupBy.compile());
+/**
+ * {
+ *  params: [10],
+ *  query: "SELECT tes.* FROM TestClazz AS tes GROUP BY tes.id HAVING COUNT(tes.id) > ?"
+ * }
+ */
+
+const queryLimitOffset = new Query(TestClazz);
+queryLimitOffset.limit(10/*, 5*/);
+print(queryLimitOffset.compile());
+/**
+ * {
+ *  params: [10, 5],
+ *  query: "SELECT tes.* FROM TestClazz AS tes LIMIT ? OFFSET ?"
+ * }
+ */
+```
+
+models.ts
 
+```ts
 export class TestClazz {
 
     public description: string = "";
@@ -46,6 +107,30 @@ export class TestClazzRef{
 }
 ```
 
+### Usage Angular 2+
 
+```ts
+import { Component } from '@angular/core';
+import { Query } from 'database-builder';
+import { TestClazz } from './models';
 
-# TODO: Getting Started Ionic 2+
+@Component({
+    selector: 'app-component',
+    templateUrl: 'app.html'
+})
+export class AppComponent {
+    
+    ngOnInit(){
+        let query = new Query(TestClazz);
+        const result = query.compile();
+        console.log(result);
+        /**
+         * result:
+         * {
+         *  params: [],
+         *  query: "SELECT tes.* FROM TestClazz AS tes"
+         * }
+         */
+    }
+}
+```

src/core/column-ref.ts

@@ -8,6 +8,9 @@ export class ColumnRef {
     }
 
     public result(): string {
-        return `${this.alias}.${this.column}`;
+        if (this.alias) {
+            return `${this.alias}.${this.column}`;
+        }
+        return this.column;
     }
 }

src/core/utils.ts

@@ -24,7 +24,7 @@ export type ValueTypeToParse = ValueType | moment.Moment | Date | object;
 
 export type ExpressionOrColumn<T> = Expression<T> | string;
 
-export type ExpressionOrValue<T> = Expression<T> | ValueTypeToParse | ColumnRef | ProjectionsHelper<T>;
+export type TypeWhere<T> = Expression<T> | ValueTypeToParse | ColumnRef | ProjectionsHelper<T>;
 
 export type TypeProjection<T> = ProjectionsHelper<T> | ColumnRef | PlanRef;
 
@@ -39,6 +39,10 @@ export class Utils {
         return typeof value === type;
     }
 
+    public static isArray(value: any): boolean {
+        return Array.isArray(value);
+    }
+
     public static isString(value: any): boolean {
         return this.is(value, "string");
     }
@@ -128,7 +132,7 @@ export class Utils {
     }
 
     public static expressionOrValue<T>(
-        value: ExpressionOrValue<T>
+        value: TypeWhere<T>
     ): ExpressionOrValueEnum {
         return this.isProjectionsHelper(value)
             ? ExpressionOrValueEnum.Projection
@@ -149,7 +153,7 @@ export class Utils {
         }
     }
 
-    public static getColumnValue<T>(expression: ExpressionOrValue<T>): ColumnParams {
+    public static getColumnWhere<T>(expression: TypeWhere<T>): ColumnParams {
         const type = this.expressionOrValue(expression);
         switch (type) {
             case (ExpressionOrValueEnum.Expression):
@@ -222,12 +226,11 @@ export class Utils {
     }
 
     public static isValue(value: any): boolean {
-        return !this.isNameColumn(value) &&
-            (
-                this.isValueNumber(value) || this.isString(value) || this.isValueBoolean(value)
-                || this.isDate(value)
-                || this.isMoment(value)
-            );
+        return this.isValueNumber(value)
+            || this.isString(value)
+            || this.isValueBoolean(value)
+            || this.isDate(value)
+            || this.isMoment(value);
     }
 
     public static normalizeSqlString(inputSql: string): string {

src/crud/projection-builder.ts

@@ -42,7 +42,7 @@ export class ProjectionBuilder<T> {
         return new ProjectionsHelper(this._typeT, this._aliasTable, false);
     }
 
-    public col(column: string): ColumnRef {
+    public ref(column: string): ColumnRef {
         return new ColumnRef(column, this._aliasTable);
     }
 

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

@@ -13,8 +13,7 @@ export interface QueryBuilderBaseContract<T, TQuery extends QueryBuilderBaseCont
 
     clone(): TQuery;
 
-    // ref(expression: ExpressionOrColumn<T>): string;
-    ref2(expression: ExpressionOrColumn<T>): ColumnRef;
+    ref(expression: ExpressionOrColumn<T>): ColumnRef;
 
     hasAlias(alias: string): boolean;
 
@@ -26,13 +25,9 @@ export interface QueryBuilderBaseContract<T, TQuery extends QueryBuilderBaseCont
 
     whereExp(expression: LambdaExpression<T>): TQuery;
 
-    /**
-     * @deprecated Use `select`
-     * @param projectionCallback
-     */
     projection(projectionCallback: (projection: ProjectionBuilder<T>) => void): TQuery;
 
-    select(selectCallback: (select: ProjectionBuilder<T>) => void): TQuery;
+    select(...expressions: Array<ExpressionOrColumn<T>>): TQuery;
 
     orderBy(expression: ExpressionOrColumn<T>, order?: OrderBy): TQuery;
 

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

@@ -17,6 +17,7 @@ import { HavingBuilder } from "../having-builder";
 import { ProjectionsHelper } from "../../core/projections-helper";
 import { BuilderCompiled } from "../../core/builder-compiled";
 import { ColumnRef } from "../../core/column-ref";
+import { QueryCompilable } from "../../core/query-compilable";
 
 let NEXT_VALUE_ALIAS: number = 0;
 
@@ -85,7 +86,7 @@ export abstract class QueryBuilderBase<T, TQuery extends QueryBuilderBase<T, TQu
     //     return this.addAlias(Utils.getColumn(expression));
     // }
 
-    public ref2(expression: ExpressionOrColumn<T>): ColumnRef {
+    public ref(expression: ExpressionOrColumn<T>): ColumnRef {
         return new ColumnRef(
             Utils.getColumn(expression),
             this.alias
@@ -108,9 +109,20 @@ export abstract class QueryBuilderBase<T, TQuery extends QueryBuilderBase<T, TQu
         return false;
     }
 
-    public from(query: QueryCompiled): TQuery {
-        this._tablename = `(${query.query})`;
-        this._fromParams = query.params;
+    public from(query: QueryCompiled | QueryCompilable): TQuery {
+        if ((query as QueryCompilable).compile) {
+            return this.from((query as QueryCompilable).compile());
+        }
+        this._tablename = `(${(query as QueryCompiled).query})`;
+        this._fromParams = (query as QueryCompiled).params;
+        return this._getInstance();
+    }
+
+    public union(query: QueryCompiled | QueryCompilable): TQuery {
+        if ((query as QueryCompilable).compile) {
+            return this.union((query as QueryCompilable).compile());
+        }
+        this._unionsQuery.push(query as QueryCompiled);
         return this._getInstance();
     }
 
@@ -139,19 +151,20 @@ export abstract class QueryBuilderBase<T, TQuery extends QueryBuilderBase<T, TQu
         return this._getInstance();
     }
 
-    /**
-     * @deprecated Use `select`
-     * @param projectionCallback
-     */
     public projection(projectionCallback: (projection: ProjectionBuilder<T>) => void): TQuery {
-        return this.select(projectionCallback);
-    }
-
-    public select(selectCallback: (select: ProjectionBuilder<T>) => void): TQuery {
         const instanceProjection: ProjectionBuilder<T> = this.createProjectionBuilder();
-        selectCallback(instanceProjection);
+        projectionCallback(instanceProjection);
         this.compileProjection(instanceProjection.compile());
         return this._getInstance();
+        // return this.select(projectionCallback);
+    }
+
+    public select(...expressions: Array<ExpressionOrColumn<T>>): TQuery {
+        return this.projection(projection => projection.columns(...expressions));
+        // const instanceProjection: ProjectionBuilder<T> = this.createProjectionBuilder();
+        // instanceProjection.columns(...expressions);
+        // this.compileProjection(instanceProjection.compile());
+        // return this._getInstance();
     }
 
     public orderBy(expression: ExpressionOrColumn<T>, order: OrderBy = OrderBy.ASC): TQuery {
@@ -180,11 +193,6 @@ export abstract class QueryBuilderBase<T, TQuery extends QueryBuilderBase<T, TQu
         return this._getInstance();
     }
 
-    public union(query: QueryCompiled): TQuery {
-        this._unionsQuery.push(query);
-        return this._getInstance();
-    }
-
     public execute(database: Database): Promise<ResultExecuteSql> {
         return this._executableBuilder.execute(this.compile(), database);
     }

src/crud/query/query.ts

@@ -11,7 +11,6 @@ import { QueryBuilder } from "./query-builder";
 import { ExpressionOrColumn, ValueType } from "./../../core/utils";
 import { QueryCompilable } from "./../../core/query-compilable";
 import { OrderBy } from "../../core/enums/order-by";
-// import { JoinQueryBuilder } from "./join-query-builder";
 import { JoinType } from "../enums/join-type";
 import { LambdaExpression } from "lambda-expression";
 import { JoinQueryBuilder } from "./join-query-builder";
@@ -43,19 +42,20 @@ export class Query<T> implements QueryCompilable {
         return this._queryBuilder.alias;
     }
 
-    // public ref(expression: ExpressionOrColumn<T>): string {
-    //     return this._queryBuilder.ref(expression);
-    // }
-
-    public ref2(expression: ExpressionOrColumn<T>): ColumnRef {
-        return this._queryBuilder.ref2(expression);
+    public ref(expression: ExpressionOrColumn<T>): ColumnRef {
+        return this._queryBuilder.ref(expression);
     }
 
-    public from(query: QueryCompiled): Query<T> {
+    public from(query: QueryCompiled | QueryCompilable): Query<T> {
         this._queryBuilder.from(query);
         return this;
     }
 
+    public union(query: QueryCompiled | QueryCompilable): Query<T> {
+        this._queryBuilder.union(query);
+        return this;
+    }
+
     public join<TJoin>(
         typeTJoin: new () => TJoin,
         onWhere: (where: WhereBuilder<TJoin>) => void,
@@ -90,8 +90,8 @@ export class Query<T> implements QueryCompilable {
         return this;
     }
 
-    public select(selectCallback: (select: ProjectionBuilder<T>) => void): Query<T> {
-        this._queryBuilder.select(selectCallback);
+    public select(...expressions: Array<ExpressionOrColumn<T>>): Query<T> {
+        this._queryBuilder.select(...expressions);
         return this;
     }