v.0.1.0-beta.9

Author: fernandocode

BREAKING-CHANGES.md

@@ -0,0 +1,4 @@
+#Breaking Changes
+
+##Find by 'BREAKING-CHANGE:' in code:
+

package.json

@@ -1,30 +1,34 @@
 {
   "name": "database-builder",
-  "version": "0.1.0-beta.6",
+  "version": "0.1.0-beta.9",
   "description": "Library to assist in creating and maintaining SQL commands.",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
   "scripts": {
-    "test": "tsc & mocha src/**/*.spec.js",
-    "test-grep": "tsc & mocha src/**/*.spec.js --grep",
-    "test-single": "tsc & mocha src/**/*.spec.js --grep Mapper --debug-brk",
-    "test-debug": "mocha -r ts-node/register src/**/*.spec.ts --debug-brk",
+    "test": "tsc & mocha src/test/**/*.spec.js",
+    "test-grep": "tsc & mocha src/test/**/*.spec.js --grep",
+    "test-single": "tsc & mocha src/test/**/*.spec.js --grep Mapper --debug-brk",
+    "test-debug": "mocha -r ts-node/register src/test/**/*.spec.ts --debug-brk",
     "publish-npm": "tsc & npm publish"
   },
   "dependencies": {
     "lambda-expression": ">=0.1.3",
+    "lodash": "^4.17.11",
     "moment": ">=2.22.0",
     "uuid": ">=3.3.2"
   },
   "devDependencies": {
     "@types/chai": "^4.1.1",
+    "@types/lodash": "^4.14.116",
     "@types/mocha": "^2.2.46",
+    "@types/sqlite3": "^3.1.3",
     "@types/uuid": "^3.4.4",
     "chai": "^4.1.2",
     "mocha": "^5.0.0",
+    "sqlite3": "^4.0.2",
     "ts-node": "^4.1.0",
     "tslint": "^5.9.1",
-    "typescript": "2.8.1"
+    "typescript": "3.0.3"
   },
   "keywords": [
     "orm",

src/core/columns-base-builder.ts

@@ -30,31 +30,23 @@ export abstract class ColumnsBaseBuilder<
         column: string,
         type: FieldType,
         primaryKeyType: PrimaryKeyType
-        // isKeyColumn: boolean,
-        // isAutoIncrement: boolean
     ): TThis {
         this.columns.push({
             name: column,
             type,
             primaryKeyType
-            // isKeyColumn,
-            // isAutoIncrement
         } as TColumn);
         return this.getInstance();
     }
 
     public set<TReturn extends ValueTypeToParse>(
         expression: ExpressionOrColumn<TReturn, T>,
         primaryKeyType: PrimaryKeyType
-        // isKeyColumn: boolean,
-        // isAutoIncrement: boolean
     ): TThis {
         return this.setColumn(
             Utils.getColumn(expression),
             Utils.getType(this.metadata.instance, expression),
             primaryKeyType
-            // isKeyColumn,
-            // isAutoIncrement
         );
     }
 
@@ -68,7 +60,6 @@ export abstract class ColumnsBaseBuilder<
             if (this.columns.hasOwnProperty(key)) {
                 const column = this.columns[key];
                 if (column.primaryKeyType) {
-                // if (column.isKeyColumn) {
                     result.keyColumns.push(column.name);
                 }
                 result.columns.push(this.columnFormat(column));
@@ -79,7 +70,6 @@ export abstract class ColumnsBaseBuilder<
 
     protected isCompositeKey(): boolean {
         return this.metadata.mapperTable.columns.filter(x => !!x.primaryKeyType).length > 1;
-        // return this.metadata.mapperTable.columns.filter(x => x.isKeyColumn === true).length > 1;
     }
 
     protected abstract columnFormat(column: TColumn): string;
@@ -91,8 +81,6 @@ export abstract class ColumnsBaseBuilder<
         value: ValueTypeToParse,
         fieldType: FieldType,
         primaryKeyType: PrimaryKeyType
-        // isKeyColumn: boolean,
-        // isAutoIncrement: boolean
     ): TThis;
 
     private setAllColumns(mapper: MapperTable, modelWithValue: T): void {
@@ -104,8 +92,6 @@ export abstract class ColumnsBaseBuilder<
                     Utils.getValue(modelWithValue, column.fieldReference),
                     column.fieldType,
                     column.primaryKeyType
-                    // column.isKeyColumn,
-                    // column.isAutoIncrement
                 );
             }
         }

src/core/columns-values-builder.ts

@@ -1,3 +1,4 @@
+import { KeyUtils } from "./key-utils";
 import { PrimaryKeyType } from "./enums/primary-key-type";
 import { MetadataTable } from "../metadata-table";
 import { ExpressionOrColumn, Utils, ValueTypeToParse } from "./utils";
@@ -22,21 +23,19 @@ export abstract class ColumnsValuesBuilder<
         value: ValueTypeToParse,
         fieldType: FieldType,
         primaryKeyType?: PrimaryKeyType
-        // isKeyColumn?: boolean,
-        // isAutoIncrement?: boolean
     ): TThis {
         // verificar se é GUID, se for gerar um valor para o mesmo
-        if (primaryKeyType === PrimaryKeyType.Guid) {
+        if (primaryKeyType === PrimaryKeyType.Guid && !value) {
             // gerar GUID
             value = Utils.GUID();
+            // set value GUID in model
+            KeyUtils.setKey(this.metadata, this.modelToSave, value);
         }
         this.columns.push({
             name: column,
             type: fieldType,
             value: Utils.getValueType(value, fieldType),
             primaryKeyType
-            // isKeyColumn,
-            // isAutoIncrement
         });
         return this.getInstance();
     }
@@ -45,31 +44,23 @@ export abstract class ColumnsValuesBuilder<
         expression: ExpressionOrColumn<TReturn, T>,
         value: TReturn,
         primaryKeyType?: PrimaryKeyType
-        // isKeyColumn?: boolean,
-        // isAutoIncrement?: boolean
     ): TThis {
         return this.setColumnValue(
             Utils.getColumn(expression),
             value,
             Utils.getType(value),
             primaryKeyType
-            // isKeyColumn,
-            // isAutoIncrement
         );
     }
 
     public set<TReturn extends ValueTypeToParse>(
         expression: ExpressionOrColumn<TReturn, T>,
         primaryKeyType?: PrimaryKeyType
-        // isKeyColumn?: boolean,
-        // isAutoIncrement?: boolean
     ): TThis {
         return this.setValue(
             expression,
             this.getValueByExpression(expression),
             primaryKeyType
-            // isKeyColumn,
-            // isAutoIncrement
         );
     }
 

src/core/key-utils.ts

@@ -0,0 +1,33 @@
+import { MapperColumn } from "../mapper-column";
+import { PrimaryKeyType } from "./enums/primary-key-type";
+import { Utils } from "./utils";
+import * as lodash from "lodash";
+import { MetadataTable } from "../metadata-table";
+
+export class KeyUtils {
+
+    public static setKey<T>(metadata: MetadataTable<T>, model: any, keyValue: any): void {
+        // model[this.primaryKeyMapper(metadata).fieldReference] = keyValue;
+        lodash.set(model, this.primaryKeyMapper(metadata).fieldReference, keyValue);
+    }
+
+    public static getKey<T>(metadata: MetadataTable<T>, model: any): any {
+        return Utils.getValue(model, this.primaryKeyMapper(metadata).fieldReference);
+    }
+
+    public static primaryKeyType<T>(metadata: MetadataTable<T>): PrimaryKeyType {
+        return this.primaryKeyMapper(metadata).primaryKeyType;
+    }
+
+    public static isCompositeKey<T>(metadata: MetadataTable<T>): boolean {
+        return this.primaryKeysMapper(metadata).length > 1;
+    }
+
+    public static primaryKeyMapper<T>(metadata: MetadataTable<T>): MapperColumn {
+        return this.primaryKeysMapper(metadata).find(_ => true);
+    }
+
+    public static primaryKeysMapper<T>(metadata: MetadataTable<T>): MapperColumn[] {
+        return metadata.mapperTable.columns.filter(x => !!x.primaryKeyType);
+    }
+}

src/core/projections-helper.ts

@@ -1,7 +1,7 @@
 import { Projection } from "../crud/enums/projection";
 import { ExpressionOrColumn, TypeProjection, Utils } from "./utils";
-import { ProjectionCompiled } from "..";
 import { ProjectionsUtils } from "./projections-utils";
+import { ProjectionCompiled } from "../crud/projection-compiled";
 
 export class ProjectionsHelper<T> {
 

src/core/projections-utils.ts

@@ -1,7 +1,6 @@
 import { Projection } from "../crud/enums/projection";
 import { ExpressionOrColumn, Utils } from "./utils";
-import { ProjectionCompiled } from "..";
-
+import { ProjectionCompiled } from "../crud/projection-compiled";
 export class ProjectionsUtils<T> {
 
     public static readonly WILDCARD = "*";

src/core/query-compilable.ts

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

src/core/row-result.ts

@@ -1,7 +1,7 @@
 import { MapperTable } from "../mapper-table";
 import { ExpressionOrColumn, Utils } from "./utils";
-import { DatabaseHelper } from "..";
 import { FieldType } from "./enums/field-type";
+import { DatabaseHelper } from "../database-helper";
 
 export class RowResult<T> {
     private _databaseHelper: DatabaseHelper;

src/crud/crud-base-builder.ts

@@ -4,6 +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";
 
 let NEXT_VALUE_ALIAS: number = 0;
 
@@ -16,6 +17,7 @@ export abstract class CrudBaseBuilder<T, TColumnsBuilder extends ColumnsValuesBu
 
     constructor(
         protected readonly _typeT: new () => T,
+        protected metadata: MetadataTable<T>,
         protected readonly _alias: string = void 0,
     ) {
         this._tablename = _typeT.name;
@@ -24,6 +26,10 @@ export abstract class CrudBaseBuilder<T, TColumnsBuilder extends ColumnsValuesBu
         }
     }
 
+    public getMetadata(): MetadataTable<T> {
+        return this.metadata;
+    }
+
     public hasAlias(alias: string): boolean {
         if (this._alias === alias) {
             return true;
@@ -39,6 +45,30 @@ export abstract class CrudBaseBuilder<T, TColumnsBuilder extends ColumnsValuesBu
         };
     }
 
+    // public setKeyByModel(keyValue: any): void {
+    //     (this.getModel() as any)[this.primaryKeyMapper().fieldReference] = keyValue;
+    // }
+
+    // public getKeyByModel(): any {
+    //     return Utils.getValue(this.getModel(), this.primaryKeyMapper().fieldReference);
+    // }
+
+    // public primaryKeyType(): PrimaryKeyType {
+    //     return this.primaryKeyMapper().primaryKeyType;
+    // }
+
+    // public isCompositeKey(): boolean {
+    //     return this.primaryKeysMapper().length > 1;
+    // }
+
+    // public primaryKeyMapper(): MapperColumn {
+    //     return this.primaryKeysMapper().find(_ => true);
+    // }
+
+    // public primaryKeysMapper(): MapperColumn[] {
+    //     return this.metadata.mapperTable.columns.filter(x => !!x.primaryKeyType);
+    // }
+
     protected getColumnsCompiled(): ColumnsCompiled {
         if (!this._columnsCompiled.columns.length) {
             this.setDefaultColumns();
@@ -70,6 +100,8 @@ export abstract class CrudBaseBuilder<T, TColumnsBuilder extends ColumnsValuesBu
 
     protected abstract setDefaultColumns(): void;
 
+    public abstract getModel(): T;
+
     private compileWhere(compiled: WhereCompiled) {
         if (compiled.where.length) {
             this._whereCompiled.where += `${(this._whereCompiled.where.length ? " AND " : " WHERE ")}${compiled.where}`;