- Added support projection case;

- configured tslint in project;

Author: fernandocode

docs-commands.ignorenpm

@@ -0,0 +1,7 @@
+##Compile TS:
+> tsc
+
+##TSLint:
+> tslint -c tslint.json --project "./src" [--fix]
+> tslint -c tslint.json "src/**/*.ts" [--fix]
+- // tslint:disable-next-line

docs-compile.ignorenpm

@@ -6,4 +6,4 @@
 
 // export { DatetimeUtils } from './src/datetime-utils';
 // export { DatabaseHelper } from "./src/database-helper";
-// export { MetadataTable } from './src/metadata-table';
+// export { MetadataTable } from './src/metadata-table';

main.ts

@@ -1,6 +1,6 @@
 {
   "name": "database-builder",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Framework to assist in database manipulation (DDL and CRUD)",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
@@ -12,6 +12,11 @@
     "lambda-expression": "0.1.0"
   },
   "devDependencies": {
+    "@types/chai": "^4.1.1",
+    "@types/mocha": "^2.2.46",
+    "chai": "^4.1.2",
+    "mocha": "^5.0.0",
+    "ts-node": "^4.1.0",
     "typescript": "2.6.2"
   },
   "keywords": [

package.json

@@ -0,0 +1,9 @@
+import { ValueType } from "./utils";
+
+export class BuilderCompiled {
+
+    constructor(
+        public builder: string = "",
+        public params: ValueType[] = []) {
+    }
+}

src/core/builder-compiled.ts

@@ -0,0 +1,8 @@
+import { ValueType} from "./utils";
+import { FieldType } from "./enums/field-type";
+
+export interface Column {
+    value: ValueType;
+    name: string;
+    type: FieldType;
+}

src/core/column.ts

@@ -1,21 +1,24 @@
-import { MetadataTable } from './../metadata-table';
-import { DatabaseHelper } from './../database-helper';
+import { MetadataTable } from "./../metadata-table";
+import { DatabaseHelper } from "./../database-helper";
 import { Expression, ExpressionUtils } from "lambda-expression";
-import { FieldType, ColumnsCompiled, ValueTypeToParse, Column } from './utils';
-import { MapperTable } from '../mapper-table';
+import { ExpressionOrColumn, Utils, ValueTypeToParse } from "./utils";
+import { MapperTable } from "../mapper-table";
+import { Column } from "./column";
+import { FieldType } from "./enums/field-type";
+import { ColumnsCompiled } from "./columns-compiled";
 
-export abstract class ColumnsBaseBuilder<TThis extends ColumnsBaseBuilder<TThis, T, TColumn>, T, TColumn extends Column>{
+export abstract class ColumnsBaseBuilder<
+    TThis extends ColumnsBaseBuilder<TThis, T, TColumn>,
+    T,
+    TColumn extends Column
+    > {
 
     protected columns: TColumn[] = [];
-    protected readonly expressionUtils: ExpressionUtils;
-    protected readonly databaseHelper: DatabaseHelper;
 
     constructor(
         protected readonly metadata: MetadataTable<T>,
-        protected readonly modelToSave: T = metadata.instance
+        protected readonly modelToSave: T = metadata.instance,
     ) {
-        this.expressionUtils = new ExpressionUtils();
-        this.databaseHelper = new DatabaseHelper();
     }
 
     public allColumns() {
@@ -25,49 +28,48 @@ export abstract class ColumnsBaseBuilder<TThis extends ColumnsBaseBuilder<TThis,
     }
 
     public setColumn(column: string, type: FieldType): TThis {
-        this.columns.push(<TColumn>{
+        this.columns.push({
             name: column,
-            type: type
-        });
+            type,
+        } as TColumn);
         return this.getInstance();
     }
 
-    public set(expression: Expression<T>): TThis {
+    public set(expression: ExpressionOrColumn<T>): TThis {
         return this.setColumn(
-            this.expressionUtils.getColumnByExpression(expression),
-            this.getTypeByExpression(expression)
+            Utils.getColumn(expression),
+            Utils.getType(this.metadata.instance, expression),
         );
     }
 
     public compile(): ColumnsCompiled {
-        let result: ColumnsCompiled = {
+        const result: ColumnsCompiled = {
             columns: [],
-            params: []
+            params: [],
         };
-        this.columns.forEach(column => {
-            result.columns.push(this.columnFormat(column));
-        });
-        return result;
-    }
-
-    private setAllColumns(mapper: MapperTable, modelWithValue: T): void {
-        for (let key in mapper.columns) {
-            let column = mapper.columns[key];
-            this.setColumnValue(column.column, this.databaseHelper.getValue(modelWithValue, column.fieldReference), column.fieldType);
+        for (const key in this.columns) {
+            if (this.columns.hasOwnProperty(key)) {
+                const column = this.columns[key];
+                result.columns.push(this.columnFormat(column));
+            }
         }
-    }
-
-    protected getTypeByValue(value: ValueTypeToParse): FieldType {
-        return this.databaseHelper.getType(value);
-    }
-
-    protected getTypeByExpression(expression: Expression<T>): FieldType {
-        return this.getTypeByValue(this.expressionUtils.getValueByExpression(this.metadata.instance, expression));
+        return result;
     }
 
     protected abstract columnFormat(column: TColumn): string;
 
     protected abstract getInstance(): TThis;
 
     protected abstract setColumnValue(column: string, value: ValueTypeToParse, fieldType: FieldType): TThis;
-}
+
+    private setAllColumns(mapper: MapperTable, modelWithValue: T): void {
+        for (const key in mapper.columns) {
+            if (mapper.columns.hasOwnProperty(key)) {
+                const column = mapper.columns[key];
+                this.setColumnValue(column.column,
+                    Utils.getValue(modelWithValue, column.fieldReference),
+                    column.fieldType);
+            }
+        }
+    }
+}

src/core/columns-base-builder.ts

@@ -0,0 +1,3 @@
+export interface ColumnsBaseCompiled {
+    columns: string[];
+}

src/core/columns-base-compiled.ts

@@ -0,0 +1,6 @@
+import { ValueType } from "./utils";
+import { ColumnsBaseCompiled } from "./columns-base-compiled";
+
+export interface ColumnsCompiled extends ColumnsBaseCompiled {
+    params: ValueType[];
+}

src/core/columns-compiled.ts

@@ -1,47 +1,52 @@
-import { MetadataTable } from './../metadata-table';
-import { ColumnsCompiled, ValueTypeToParse, Column, FieldType } from "./utils";
+import { MetadataTable } from "./../metadata-table";
+import { ExpressionOrColumn, Utils, ValueTypeToParse } from "./utils";
 import { Expression } from "lambda-expression";
 import { ColumnsBaseBuilder } from "./columns-base-builder";
+import { Column } from "./column";
+import { FieldType } from "./enums/field-type";
+import { ColumnsCompiled } from "./columns-compiled";
 
-export abstract class ColumnsValuesBuilder<T, TThis extends ColumnsValuesBuilder<T, TThis>> extends ColumnsBaseBuilder<TThis, T, Column>{
+export abstract class ColumnsValuesBuilder<
+    T, TThis extends ColumnsValuesBuilder<T, TThis>>
+    extends ColumnsBaseBuilder<TThis, T, Column> {
 
     constructor(
         metadata: MetadataTable<T>,
-        modelToSave: T = void 0
+        modelToSave: T = void 0,
     ) {
         super(metadata, modelToSave);
-    } 
+    }
 
     public setColumnValue(column: string, value: ValueTypeToParse, fieldType: FieldType): TThis {
         this.columns.push({
             name: column,
-            value: this.databaseHelper.parseToValueType(value, fieldType),
-            type: fieldType
+            type: fieldType,
+            value: Utils.getValueType(value, fieldType),
         });
         return this.getInstance();
     }
 
-    public setValue(expression: Expression<T>, value: ValueTypeToParse): TThis {
+    public setValue(expression: ExpressionOrColumn<T>, value: ValueTypeToParse): TThis {
         return this.setColumnValue(
-            this.expressionUtils.getColumnByExpression(expression),
+            Utils.getColumn(expression),
             value,
-            this.databaseHelper.getType(value)
+            Utils.getType(value),
         );
     }
 
-    public set(expression: Expression<T>): TThis {
+    public set(expression: ExpressionOrColumn<T>): TThis {
         return this.setValue(
             expression,
-            this.getValueByExpression(expression)
+            this.getValueByExpression(expression),
         );
     }
 
     public compile(): ColumnsCompiled {
-        let result: ColumnsCompiled = {
+        const result: ColumnsCompiled = {
             columns: [],
-            params: []
+            params: [],
         };
-        this.columns.forEach(column => {
+        this.columns.forEach((column) => {
             result.columns.push(this.columnFormat(column));
             result.params.push(column.value);
         });
@@ -50,7 +55,7 @@ export abstract class ColumnsValuesBuilder<T, TThis extends ColumnsValuesBuilder
 
     protected abstract columnFormat(column: Column): string;
 
-    private getValueByExpression(expression: Expression<T>) {
-        return this.expressionUtils.getValueByExpression(this.modelToSave, expression);
+    private getValueByExpression(expression: ExpressionOrColumn<T>) {
+        return Utils.getValue(this.modelToSave, expression);
     }
-}
+}

src/core/columns-values-builder.ts

@@ -0,0 +1,6 @@
+import { ValueType } from "./utils";
+
+export interface CrudCompiled {
+    sql: string;
+    params: ValueType[];
+}

src/core/crud-compiled.ts

@@ -0,0 +1,4 @@
+export interface CrudInsertCompiled {
+    columns: string;
+    values: string;
+}

src/core/crud-insert-compiled.ts

@@ -0,0 +1,5 @@
+export enum ColumnType {
+    TEXT = "TEXT",
+    INTEGER = "INTEGER",
+    BOOLEAN = "BOOLEAN",
+}

src/core/enums/column-type.ts

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

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

@@ -0,0 +1,8 @@
+export enum FieldType {
+    STRING,
+    NUMBER,
+    BOOLEAN,
+    DATE,
+    OBJECT,
+    FUNCTION,
+}

src/core/enums/field-type.ts

@@ -0,0 +1,4 @@
+export enum OrderBy {
+    ASC = "ASC",
+    DESC = "DESC",
+}

src/core/enums/order-by.ts

@@ -1,46 +1,48 @@
-import { Database, DatabaseObject, DatabaseTransaction } from './../definitions/database-definition';
-import { ResultExecuteSql, QueryCompiled } from "./utils";
+import { Database, DatabaseObject, DatabaseTransaction } from "./../definitions/database-definition";
+import { QueryCompiled } from "./query-compiled";
+import { ResultExecuteSql } from "./result-execute-sql";
 
 export class ExecutableBuilder {
 
-    constructor(public enableLog: boolean = true){
+    constructor(public enableLog: boolean = true) {
 
     }
 
     public execute(
         compiled: QueryCompiled,
-        database: Database
+        database: Database,
     ): Promise<ResultExecuteSql> {
         this.log(compiled);
         return this.executeSql(database, compiled);
     }
 
     private executeSql(
-        database: Database, compiled: QueryCompiled
+        database: Database, compiled: QueryCompiled,
     ): Promise<ResultExecuteSql> {
-        if ((<DatabaseObject>database).addTransaction) {
-        // if (database instanceof SQLiteObject) {
-            return (<DatabaseObject>database).executeSql(
+        if ((database as DatabaseObject).addTransaction) {
+            return (database as DatabaseObject).executeSql(
                 compiled.query,
-                compiled.params
+                compiled.params,
             );
         }
         return new Promise<any>((resolve, reject) => {
-            (<DatabaseTransaction>database).executeSql(
+            (database as DatabaseTransaction).executeSql(
                 compiled.query,
                 compiled.params,
                 (tx: DatabaseTransaction, result: ResultExecuteSql) => {
                     resolve(result);
                 },
                 (tx: DatabaseTransaction, error: any) => {
                     reject(error);
-                }
+                },
             );
         });
     }
 
     private log(log: any) {
-        if (this.enableLog)
+        if (this.enableLog) {
+            // tslint:disable-next-line
             console.log(log);
+        }
     }
-}
+}

src/core/executable-builder.ts

@@ -1,3 +1,3 @@
-
-export { ResultExecuteSql, QueryCompiled } from "./utils";
-export { ExecutableBuilder } from './executable-builder';
+export { ResultExecuteSql } from "./result-execute-sql";
+export { QueryCompiled } from "./query-compiled";
+export { ExecutableBuilder } from "./executable-builder";

src/core/index.ts

@@ -0,0 +1,5 @@
+import { ValueType } from "./utils";
+
+export interface QueryCompilable {
+    compile(): { query: string, params: ValueType[] };
+}

src/core/query-compilable.ts

@@ -0,0 +1,6 @@
+import { ValueType } from "./utils";
+
+export interface QueryCompiled {
+    query: string;
+    params: ValueType[];
+}

src/core/query-compiled.ts

@@ -0,0 +1,7 @@
+import { RowsResultExecuteSql } from "./rows-result-execute-sql";
+
+export interface ResultExecuteSql {
+    rows: RowsResultExecuteSql;
+    rowsAffected: number;
+    insertId: number;
+}

src/core/result-execute-sql.ts

@@ -0,0 +1,4 @@
+export interface RowsResultExecuteSql {
+    length: number;
+    item(key: number): any;
+}