v.0.1.0-beta.16

Author: fernandocode

package.json

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

src/core/builder-compiled.ts

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

src/core/columns-values-builder.ts

@@ -1,24 +1,26 @@
 import { DatabaseBuilderError } from "./errors";
 import { KeyUtils } from "./key-utils";
 import { PrimaryKeyType } from "./enums/primary-key-type";
-import { MetadataTable } from "../metadata-table";
 import { ExpressionOrColumn, Utils, ValueTypeToParse } from "./utils";
 import { ColumnsBaseBuilder } from "./columns-base-builder";
 import { Column } from "./column";
 import { FieldType } from "./enums/field-type";
 import { ColumnsCompiled } from "./columns-compiled";
+import { MapperTable } from "../mapper-table";
 
 export abstract class ColumnsValuesBuilder<
     T, TThis extends ColumnsValuesBuilder<T, TThis>>
     extends ColumnsBaseBuilder<TThis, T, Column> {
 
     // TODO: fixed list task
     constructor(
-        metadata: MetadataTable<T>,
-        modelToSave: T = metadata.instance,
+        // metadata: MetadataTable<T>,
+        mapperTable: MapperTable,
+        modelToSave: T,
+        // modelToSave: T = metadata.instance,
         // modelToSave: T = void 0,
     ) {
-        super(metadata.mapperTable, modelToSave);
+        super(mapperTable, modelToSave);
         // super(metadata, modelToSave);
     }
 

src/core/crud-compiled.ts

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

src/core/executable-builder.ts

@@ -1,6 +1,7 @@
-import { DatabaseBaseTransaction } from './../definitions/database-definition';
+import { DatabaseBaseTransaction } from "./../definitions/database-definition";
 import { DatabaseBase, DatabaseObject, DatabaseResult, DatabaseTransaction } from "../definitions/database-definition";
 import { QueryCompiled } from "./query-compiled";
+import { ReplacementParam } from "./replacement-param";
 
 export class ExecutableBuilder {
 
@@ -9,11 +10,12 @@ export class ExecutableBuilder {
     }
 
     public execute(
-        compiled: QueryCompiled,
+        compiled: QueryCompiled[],
         database: DatabaseBase,
-    ): Promise<DatabaseResult> {
+    ): Promise<DatabaseResult[]> {
         this.log(compiled);
-        return this.executeSql(database, compiled);
+        return this.executorLinked(compiled, [], database);
+        // return this.executeSql(database, compiled);
     }
 
     private executeSql(
@@ -39,6 +41,49 @@ export class ExecutableBuilder {
         });
     }
 
+    private checkParams(
+        script: QueryCompiled, resultadosAnteriores: DatabaseResult[]
+    ): QueryCompiled {
+        const paramsResult: any[] = [];
+        script.params.forEach(param => {
+            if (param instanceof ReplacementParam) {
+                let value = resultadosAnteriores as any;
+                param.properties.forEach(property => {
+                    value = value[property];
+                });
+                paramsResult.push(value);
+            } else {
+                paramsResult.push(param);
+            }
+        });
+        script.params = paramsResult;
+        return script;
+    }
+
+    private executorLinked(
+        compiled: QueryCompiled[],
+        dataResultsApplied: DatabaseResult[],
+        database: DatabaseBase
+    ): Promise<DatabaseResult[]> {
+        return new Promise((resolve, reject) => {
+            if (compiled && compiled.length > 0) {
+                this.executeSql(database, this.checkParams(compiled[0], dataResultsApplied))
+                    .then(result => {
+                        // remove o item executado
+                        compiled.shift();
+                        this.executorLinked(compiled, dataResultsApplied.concat([result]), database)
+                            .then(res => {
+                                resolve([result].concat(res));
+                            })
+                            .catch((err: any) => reject(err));
+                    })
+                    .catch((err: any) => reject(err));
+            } else {
+                resolve([]);
+            }
+        });
+    }
+
     private log(log: any) {
         if (this.enableLog) {
             // tslint:disable-next-line

src/core/query-compilable.ts

@@ -1,5 +1,5 @@
 import { QueryCompiled } from "./query-compiled";
 
 export interface QueryCompilable {
-    compile(): QueryCompiled;
+    compile(): QueryCompiled[];
 }

src/core/query-compiled.ts

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

src/core/replacement-param.ts

@@ -0,0 +1,10 @@
+export class ReplacementParam {
+
+    public properties: string[];
+
+    constructor(
+        ...properties: string[]
+    ) {
+        this.properties = properties;
+    }
+}

src/core/utils.ts

@@ -17,6 +17,9 @@ import { ColumnParams } from "./column-params";
 import { ColumnRef } from "./column-ref";
 import { PlanRef } from "./plan-ref";
 import * as uuidv4 from "uuid/v4";
+import { ReplacementParam } from "./replacement-param";
+
+export type ParamType = ValueType | ReplacementParam;
 
 export type ValueType = number | string | boolean;
 export type ValueTypeToParse = ValueType | moment.Moment | Date | object;

src/crud/crud-base-builder.ts

@@ -4,7 +4,7 @@ import { ColumnsCompiled } from "../core/columns-compiled";
 import { QueryCompiled } from "../core/query-compiled";
 import { CrudCompiled } from "../core/crud-compiled";
 import { WhereCompiled } from "./where-compiled";
-import { MetadataTable } from "../metadata-table";
+import { MapperTable } from "../mapper-table";
 
 let NEXT_VALUE_ALIAS: number = 0;
 
@@ -17,7 +17,8 @@ export abstract class CrudBaseBuilder<T, TColumnsBuilder extends ColumnsValuesBu
 
     constructor(
         protected readonly _typeT: new () => T,
-        protected metadata: MetadataTable<T>,
+        // protected metadata: MetadataTable<T>,
+        protected mapperTable: MapperTable,
         protected readonly _alias: string = void 0,
     ) {
         this._tablename = _typeT.name;
@@ -26,8 +27,12 @@ export abstract class CrudBaseBuilder<T, TColumnsBuilder extends ColumnsValuesBu
         }
     }
 
-    public getMetadata(): MetadataTable<T> {
-        return this.metadata;
+    // public getMetadata(): MetadataTable<T> {
+    //     return this.metadata;
+    // }
+
+    public getMapper(): MapperTable {
+        return this.mapperTable;
     }
 
     public hasAlias(alias: string): boolean {