@dascompany/database 2.1.1 → 2.1.3

package/dist/query/BindParams.js

@@ -23,6 +23,10 @@ export default class BindParams {
                 query.bindParameter(`${parameter.name}_param${index}`, value);
             });
         }
+        else if (QueryParamCreator.isBetweenType(parameter.type)) {
+            query.bindParameter(`${parameter.name}_min`, parameter.value.min);
+            query.bindParameter(`${parameter.name}_max`, parameter.value.max);
+        }
         else {
             if (parameter.type == ParameterType.string)
                 parameter.value = `%${parameter.value}%`;

package/dist/query/QueryOptions.js

@@ -3,10 +3,10 @@ import Filters from "../utils/Filters";
 import Parameters from "../utils/Parameters";
 export default class QueryOptions {
     static correctingSorting(querySortBy) {
-        const sortBy = Parameters.correct(querySortBy, { type: ParameterType.arrayObject });
+        const orderBy = Parameters.correct(querySortBy, { type: ParameterType.arrayObject });
         const table = [];
-        if (sortBy[0]) {
-            sortBy.forEach((element) => {
+        if (orderBy[0]) {
+            orderBy.forEach((element) => {
                 const key = Parameters.correct(element.key, { type: ParameterType.string, filter: Filters.databaseColumn });
                 const order = Parameters.correct(element.order, { type: ParameterType.string });
                 table.push({ key, order });

package/dist/query/QueryParamCreator.d.ts

@@ -3,8 +3,9 @@ import ParameterType from "../types/parameters/ParameterType";
 export default class QueryParamCreator {
     static createParam(parameter: ParameterI): string;
     static isArrayType(type: ParameterType): boolean;
+    static isBetweenType(type: ParameterType): boolean;
     private static createArrayParam;
     static createParamValue(paramName: string, paramType: ParameterType): string;
-    static getBaseTypeForArrayType(paramType: ParameterType): ParameterType;
+    static getBaseTypeForComplexType(paramType: ParameterType): ParameterType;
     private static getOperatorForType;
 }

package/dist/query/QueryParamCreator.js

@@ -3,6 +3,13 @@ export default class QueryParamCreator {
     static createParam(parameter) {
         if (this.isArrayType(parameter.type))
             return this.createArrayParam(parameter);
+        else if (this.isBetweenType(parameter.type)) {
+            const name = parameter.name;
+            const paramValueType = this.getBaseTypeForComplexType(parameter.type);
+            const min = this.createParamValue(`${name}_min`, paramValueType);
+            const max = this.createParamValue(`${name}_max`, paramValueType);
+            return `${name} BETWEEN ${min} AND ${max}`;
+        }
         else {
             const paramName = parameter.name;
             const operator = this.getOperatorForType(parameter.type);
@@ -16,12 +23,18 @@ export default class QueryParamCreator {
         else
             return false;
     }
+    static isBetweenType(type) {
+        if (type == ParameterType.betweenNumber)
+            return true;
+        else
+            return false;
+    }
     static createArrayParam(parameter) {
         const paramName = parameter.name;
         let sqlArrayParam = '(';
         let arrayParam = [];
         parameter.value.forEach((paramValue, index) => {
-            const paramType = this.getBaseTypeForArrayType(parameter.type);
+            const paramType = this.getBaseTypeForComplexType(parameter.type);
             const operator = this.getOperatorForType(paramType);
             const value = this.createParamValue(`${paramName}_param${index}`, paramType);
             arrayParam.push(`${paramName} ${operator} ${value}`);
@@ -46,9 +59,9 @@ export default class QueryParamCreator {
             default: throw new Error(`Nieznany typ parametru: ${paramName} typu: ${paramType} `);
         }
     }
-    static getBaseTypeForArrayType(paramType) {
+    static getBaseTypeForComplexType(paramType) {
         switch (paramType) {
-            case ParameterType.arrayNumber:
+            case ParameterType.arrayNumber || ParameterType.betweenNumber:
                 return ParameterType.number;
             case ParameterType.arrayString:
                 return ParameterType.string;

package/dist/query/QueryParams.d.ts

@@ -3,7 +3,7 @@ import QueryOptionsI from '../types/QueryOptionsI';
 export default class QueryParams {
     private static where;
     private static params;
-    private static order;
+    private static orderBy;
     private static limit;
     private static values;
     private static paramConnector;

package/dist/query/QueryParams.js

@@ -3,15 +3,15 @@ import QueryParamsCreator from './QueryParamCreator';
 export default class QueryParams {
     static where = '$WHERE';
     static params = '$PARAMS';
-    static order = '$ORDERBY';
+    static orderBy = '$ORDERBY';
     static limit = '$LIMIT';
     static values = '$VALUES';
     static paramConnector = 'AND';
     static createParams(queryString, options) {
         if (options.where && (queryString.includes(this.where) || queryString.includes(this.params)))
             queryString = QueryParams.createWhereParams(queryString, options.where);
-        if (options && queryString.includes(this.order))
-            queryString = QueryParams.createOrderParams(queryString, options.order);
+        if (options && queryString.includes(this.orderBy))
+            queryString = QueryParams.createOrderParams(queryString, options.orderBy);
         if (options && queryString.includes(this.limit))
             queryString = QueryParams.createLimitParams(queryString, options.limit);
         if (options.values && queryString.includes(this.values))
@@ -37,7 +37,7 @@ export default class QueryParams {
         values.forEach((value) => {
             let valueall;
             if (index) {
-                const paramType = QueryParamCreator.getBaseTypeForArrayType(value.type);
+                const paramType = QueryParamCreator.getBaseTypeForComplexType(value.type);
                 valueall = QueryParamCreator.createParamValue(`${value.name}_${index}`, paramType);
             }
             else {
@@ -63,12 +63,16 @@ export default class QueryParams {
             throw new Error(`Brak zmiennej: ${this.where} lub ${this.params} w zapytaniu sql`);
         return sqlWithParams;
     }
-    static createOrderParams(sql, order) {
-        if (order) {
-            sql = sql.replaceAll(this.order, `ORDER BY ${order}`);
+    static createOrderParams(sql, orderBy) {
+        if (orderBy) {
+            let strToReplace = `ORDER BY `;
+            orderBy.forEach(item => {
+                strToReplace += `${item.key} ${item.order} `;
+            });
+            sql = sql.replaceAll(this.orderBy, strToReplace);
         }
         else
-            sql = sql.replaceAll(this.order, '');
+            sql = sql.replaceAll(this.orderBy, '');
         return sql;
     }
     static createLimitParams(sql, resultLimitation) {

package/dist/types/QueryOptionsI.d.ts

@@ -4,7 +4,7 @@ import ResultLimitationI from "./ResultLimitationI";
 import WhereOptionI from "./WhereOptionI";
 export default interface QueryOptionsI {
     where?: WhereOptionI;
-    order?: OrderByI[];
+    orderBy?: OrderByI[];
     limit?: ResultLimitationI;
     values?: ParameterI[];
 }

package/dist/types/parameters/ParameterType.d.ts

@@ -5,12 +5,13 @@ declare enum ParameterType {
     arrayBoolean = 3,
     arrayValue = 4,
     arrayObject = 5,
-    bigint = 6,
-    smallint = 7,
-    number = 8,
-    string = 9,
-    boolean = 10,
-    object = 11,
-    column = 12
+    betweenNumber = 6,
+    bigint = 7,
+    smallint = 8,
+    number = 9,
+    string = 10,
+    boolean = 11,
+    object = 12,
+    column = 13
 }
 export default ParameterType;

package/dist/types/parameters/ParameterType.js

@@ -6,12 +6,13 @@ var ParameterType;
     ParameterType[ParameterType["arrayBoolean"] = 3] = "arrayBoolean";
     ParameterType[ParameterType["arrayValue"] = 4] = "arrayValue";
     ParameterType[ParameterType["arrayObject"] = 5] = "arrayObject";
-    ParameterType[ParameterType["bigint"] = 6] = "bigint";
-    ParameterType[ParameterType["smallint"] = 7] = "smallint";
-    ParameterType[ParameterType["number"] = 8] = "number";
-    ParameterType[ParameterType["string"] = 9] = "string";
-    ParameterType[ParameterType["boolean"] = 10] = "boolean";
-    ParameterType[ParameterType["object"] = 11] = "object";
-    ParameterType[ParameterType["column"] = 12] = "column";
+    ParameterType[ParameterType["betweenNumber"] = 6] = "betweenNumber";
+    ParameterType[ParameterType["bigint"] = 7] = "bigint";
+    ParameterType[ParameterType["smallint"] = 8] = "smallint";
+    ParameterType[ParameterType["number"] = 9] = "number";
+    ParameterType[ParameterType["string"] = 10] = "string";
+    ParameterType[ParameterType["boolean"] = 11] = "boolean";
+    ParameterType[ParameterType["object"] = 12] = "object";
+    ParameterType[ParameterType["column"] = 13] = "column";
 })(ParameterType || (ParameterType = {}));
 export default ParameterType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dascompany/database",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "main": "dist/index.js",
   "scripts": {
     "test": "vitest",