Fixed bug, in insert generation with sub-level property, did not retrieve the value of the object correctly.

Author: fernandocode

package.json

@@ -1,16 +1,18 @@
 {
   "name": "database-builder",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Framework to assist in database manipulation (DDL and CRUD)",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
   "scripts": {
-    "test": " tsc & mocha src/**/*.spec.js",
+    "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"
   },
   "dependencies": {
     "moment": "2.20.1",
-    "lambda-expression": "0.1.1"
+    "lambda-expression": "0.1.2"
   },
   "devDependencies": {
     "@types/chai": "^4.1.1",

src/core/utils.ts

@@ -116,6 +116,10 @@ export class Utils {
         return isNameColumn.test(column);
     }
 
+    public static normalizeSqlString(inputSql: string): string{
+        return inputSql.replace(/\s+/g, ' ').trim();
+    }
+
     private static getExpressionUtils(): ExpressionUtils {
         return this._expressionUtils = this._expressionUtils ? this._expressionUtils : new ExpressionUtils();
     }

src/crud/insert/insert-builder.ts

@@ -1,3 +1,4 @@
+import { Utils } from './../../core/utils';
 import { InsertColumnsBuilder } from './insert-columns-builder';
 import { MetadataTable } from "./../../metadata-table";
 import { CrudBaseBuilder } from "../crud-base-builder";
@@ -27,9 +28,11 @@ export class InsertBuilder<T> extends CrudBaseBuilder<T, InsertColumnsBuilder<T>
 
         return {
             params: this.getColumnsCompiled().params,
-            sql: `INSERT INTO ${this._tablename}
-            (${this.getColumnsCompiled().columns.join(", ")})
-            VALUES (${parameterValues.join(", ")})`,
+            sql: Utils.normalizeSqlString(
+                `INSERT INTO ${this._tablename}
+                    (${this.getColumnsCompiled().columns.join(", ")})
+                    VALUES (${parameterValues.join(", ")})`
+            ),
         };
     }
 

src/test/mappers-table.ts

@@ -0,0 +1,89 @@
+import { Regiao } from './models/regiao';
+import { SubRegiao } from './models/sub-regiao';
+import { Uf } from './models/uf';
+import { Cidade } from './models/cidade';
+import { Cliente } from './models/cliente';
+import { MetadataTable } from './../metadata-table';
+import { Classificacao } from './models/classificacao';
+import { DatabaseHelper } from './../database-helper';
+import { GetMapper } from "../index";
+
+
+export class MappersTable implements GetMapper {
+
+    private _databaseHelper: DatabaseHelper = new DatabaseHelper()
+
+    
+    public classificacaoMapper =
+        new MetadataTable(Classificacao, this._databaseHelper)
+            .autoMapper(false, true, false);
+    public clienteMapper =
+        new MetadataTable(Cliente, this._databaseHelper)
+            .autoMapper(false, true, false);
+    public cidadeMapper =
+        new MetadataTable(Cidade, this._databaseHelper)
+            .autoMapper(false, true, false);
+    public ufMapper =
+        new MetadataTable(Uf, this._databaseHelper)
+            .autoMapper(false, true, false);
+    public subRegiaoMapper =
+        new MetadataTable(SubRegiao, this._databaseHelper)
+            .autoMapper(false, true, false);
+    public regiaoMapper =
+        new MetadataTable(Regiao, this._databaseHelper)
+            .autoMapper(false, true, false);
+
+    private _mappersKeyValue: Map<string, MetadataTable<any>> = new Map([
+        this.createEntry(this.classificacaoMapper),
+        this.createEntry(this.clienteMapper),
+        this.createEntry(this.cidadeMapper),
+        this.createEntry(this.ufMapper),
+        this.createEntry(this.subRegiaoMapper),
+        this.createEntry(this.regiaoMapper),
+    ]);
+
+    /**
+     * Find mapper metadata by key
+     * 
+     * @public
+     * @param {string} tKey
+     * @returns {MetadataTable} 
+     * @memberof MappersTable
+     */
+    public getMapper<T>(tKey: new () => T): MetadataTable<T> {
+        return this._mappersKeyValue.get(tKey.name);
+    }
+
+    public forEachMapper(
+        callbackfn: (
+            value: MetadataTable<any>,
+            key: string,
+            map: Map<string, MetadataTable<any>>
+        ) => void,
+        thisArg?: any
+    ) {
+        this._mappersKeyValue.forEach(callbackfn);
+    }
+
+    /**
+     * Find mapper metadata by key and merge with new instance of data
+     * 
+     * @param {string} tKey
+     * @param {*} newInstance 
+     * @returns {MetadataTable}
+     * @memberof MappersTable
+    * */
+    public getMapperMerge<T>(tKey: new () => T, newInstance: any): MetadataTable<T> {
+        let mapper = this.getMapper(tKey);
+        if (!mapper) {
+            throw `Mapper to ${tKey.name} not found!`;
+        }
+        let metadataCopy: MetadataTable<T> = Object.assign({}, mapper);
+        metadataCopy.instance = Object.assign(metadataCopy.instance, newInstance);
+        return metadataCopy;
+    }
+
+    private createEntry(metadataTable: MetadataTable<any>): [string, MetadataTable<any>] {
+        return [metadataTable.instance.constructor.name, metadataTable];
+    }
+}

src/test/test.spec.ts

@@ -1,10 +1,16 @@
+import { Regiao } from './models/regiao';
+import { SubRegiao } from './models/sub-regiao';
+import { Uf } from './models/uf';
+import { Classificacao } from './models/classificacao';
 import { ProjectionCompiled } from './../crud/projection-compiled';
 import { Projection } from './../crud/enums/projection';
 import { Query } from './../crud/query/query';
 import { Cliente } from './models/cliente';
 import { expect, assert } from "chai";
 import { Cidade } from './models/cidade';
 import { Operator } from '../crud/enums/operator';
+import { Crud, Insert } from '../index';
+import { MappersTable } from './mappers-table';
 
 describe("Query method", () => {
 
@@ -137,4 +143,41 @@ describe("Query method", () => {
 
     // TODO: query from query
 
+
+});
+
+describe("Mapper", () => {
+    let clienteToSave = <Cliente>{
+        id: 1,
+        razaoSocial: "Razão",
+        apelido: "Apelido",
+        cidade: <Cidade>{
+            id: 2,
+            nome: "Cidade",
+            uf: <Uf>{
+                id: "SC",
+                nome: "Santa Catarina"
+            },
+            subRegiao: <SubRegiao>{
+                id: 4,
+                nome: "Sub Região",
+                regiao: <Regiao>{
+                    id: 5,
+                    nome: "Região"
+                }
+            },
+        },
+        classificacao: <Classificacao>{
+            id: 3,
+            descricao: "Top"
+        },
+        desativo: false
+    };
+
+    it("Test mapper insert", () => {
+        const result = new Insert(Cliente, clienteToSave, new MappersTable().clienteMapper).compile();
+        expect(result.params.toString()).to.equal([1, 'Razão', 'Apelido', false, 2, 3].toString());
+        expect(result.query).to.equal("INSERT INTO Cliente (id, razaoSocial, apelido, desativo, cidade_id, classificacao_id) VALUES (?, ?, ?, ?, ?, ?)");
+    });
+
 });