initial v.1.0

Author: fernandocode

package.json

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

src/core/column.ts

@@ -5,4 +5,6 @@ export interface Column {
     value: ValueType;
     name: string;
     type: FieldType;
+    isKeyColumn?: boolean;
+    isAutoIncrement?: boolean;
 }

src/core/columns-base-builder.ts

@@ -1,4 +1,4 @@
-import { MetadataTable } from "./../metadata-table";
+import { MetadataTable } from "../metadata-table";
 import { ExpressionOrColumn, Utils, ValueTypeToParse } from "./utils";
 import { MapperTable } from "../mapper-table";
 import { Column } from "./column";
@@ -25,48 +25,79 @@ export abstract class ColumnsBaseBuilder<
         this.setAllColumns(this.metadata.mapperTable, this.modelToSave);
     }
 
-    public setColumn(column: string, type: FieldType): TThis {
+    public setColumn(
+        column: string,
+        type: FieldType,
+        isKeyColumn: boolean,
+        isAutoIncrement: boolean
+    ): TThis {
         this.columns.push({
             name: column,
             type,
+            isKeyColumn,
+            isAutoIncrement
         } as TColumn);
         return this.getInstance();
     }
 
-    public set<TReturn extends ValueTypeToParse>(expression: ExpressionOrColumn<TReturn, T>): TThis {
+    public set<TReturn extends ValueTypeToParse>(
+        expression: ExpressionOrColumn<TReturn, T>,
+        isKeyColumn: boolean,
+        isAutoIncrement: boolean
+    ): TThis {
         return this.setColumn(
             Utils.getColumn(expression),
             Utils.getType(this.metadata.instance, expression),
+            isKeyColumn,
+            isAutoIncrement
         );
     }
 
     public compile(): ColumnsCompiled {
         const result: ColumnsCompiled = {
             columns: [],
+            keyColumns: [],
             params: [],
         };
         for (const key in this.columns) {
             if (this.columns.hasOwnProperty(key)) {
                 const column = this.columns[key];
+                if (column.isKeyColumn) {
+                    result.keyColumns.push(column.name);
+                }
                 result.columns.push(this.columnFormat(column));
             }
         }
         return result;
     }
 
+    protected isCompositeKey(): boolean {
+        return this.metadata.mapperTable.columns.filter(x => x.isKeyColumn === true).length > 1;
+    }
+
     protected abstract columnFormat(column: TColumn): string;
 
     protected abstract getInstance(): TThis;
 
-    protected abstract setColumnValue(column: string, value: ValueTypeToParse, fieldType: FieldType): TThis;
+    protected abstract setColumnValue(
+        column: string,
+        value: ValueTypeToParse,
+        fieldType: FieldType,
+        isKeyColumn: boolean,
+        isAutoIncrement: boolean
+    ): 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,
+                this.setColumnValue(
+                    column.column,
                     Utils.getValue(modelWithValue, column.fieldReference),
-                    column.fieldType);
+                    column.fieldType,
+                    column.isKeyColumn,
+                    column.isAutoIncrement
+                );
             }
         }
     }

src/core/columns-base-compiled.ts

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

src/core/columns-values-builder.ts

@@ -1,4 +1,4 @@
-import { MetadataTable } from "./../metadata-table";
+import { MetadataTable } from "../metadata-table";
 import { ExpressionOrColumn, Utils, ValueTypeToParse } from "./utils";
 import { ColumnsBaseBuilder } from "./columns-base-builder";
 import { Column } from "./column";
@@ -16,38 +16,62 @@ export abstract class ColumnsValuesBuilder<
         super(metadata, modelToSave);
     }
 
-    public setColumnValue(column: string, value: ValueTypeToParse, fieldType: FieldType): TThis {
+    public setColumnValue(
+        column: string,
+        value: ValueTypeToParse,
+        fieldType: FieldType,
+        isKeyColumn: boolean,
+        isAutoIncrement: boolean): TThis {
         this.columns.push({
             name: column,
             type: fieldType,
             value: Utils.getValueType(value, fieldType),
+            isKeyColumn,
+            isAutoIncrement
         });
         return this.getInstance();
     }
 
-    public setValue<TReturn extends ValueTypeToParse>(expression: ExpressionOrColumn<TReturn, T>, value: TReturn): TThis {
+    public setValue<TReturn extends ValueTypeToParse>(
+        expression: ExpressionOrColumn<TReturn, T>,
+        value: TReturn,
+        isKeyColumn: boolean,
+        isAutoIncrement: boolean
+    ): TThis {
         return this.setColumnValue(
             Utils.getColumn(expression),
             value,
             Utils.getType(value),
+            isKeyColumn,
+            isAutoIncrement
         );
     }
 
-    public set<TReturn extends ValueTypeToParse>(expression: ExpressionOrColumn<TReturn, T>): TThis {
+    public set<TReturn extends ValueTypeToParse>(
+        expression: ExpressionOrColumn<TReturn, T>,
+        isKeyColumn: boolean,
+        isAutoIncrement: boolean
+    ): TThis {
         return this.setValue(
             expression,
             this.getValueByExpression(expression),
+            isKeyColumn,
+            isAutoIncrement
         );
     }
 
     public compile(): ColumnsCompiled {
         const result: ColumnsCompiled = {
             columns: [],
+            keyColumns: [],
             params: [],
         };
         this.columns.forEach((column) => {
-            result.columns.push(this.columnFormat(column));
-            result.params.push(column.value);
+            const columnName = this.columnFormat(column);
+            if (columnName !== void 0) {
+                result.columns.push(columnName);
+                result.params.push(column.value);
+            }
         });
         return result;
     }

src/core/executable-builder.ts

@@ -1,4 +1,4 @@
-import { DatabaseBase, DatabaseObject, DatabaseResult, DatabaseTransaction } from "./../definitions/database-definition";
+import { DatabaseBase, DatabaseObject, DatabaseResult, DatabaseTransaction } from "../definitions/database-definition";
 import { QueryCompiled } from "./query-compiled";
 
 export class ExecutableBuilder {

src/core/lambda-metadata.ts

@@ -1,4 +1,4 @@
-import { Condition } from "./../crud/enums/condition";
+import { Condition } from "../crud/enums/condition";
 
 export interface LambdaMetadata {
     left: string;

src/core/projections-helper.ts

@@ -1,4 +1,4 @@
-import { Projection } from "./../crud/enums/projection";
+import { Projection } from "../crud/enums/projection";
 import { ExpressionOrColumn, TypeProjection, Utils } from "./utils";
 import { ProjectionCompiled } from "..";
 import { ProjectionsUtils } from "./projections-utils";

src/core/projections-utils.ts

@@ -1,4 +1,4 @@
-import { Projection } from "./../crud/enums/projection";
+import { Projection } from "../crud/enums/projection";
 import { ExpressionOrColumn, Utils } from "./utils";
 import { ProjectionCompiled } from "..";
 

src/core/row-result.ts

@@ -1,4 +1,4 @@
-import { MapperTable } from "./../mapper-table";
+import { MapperTable } from "../mapper-table";
 import { ExpressionOrColumn, Utils } from "./utils";
 import { DatabaseHelper } from "..";
 import { FieldType } from "./enums/field-type";