@dascompany/database 2.1.4 → 2.1.5

package/dist/Table.d.ts

@@ -4,5 +4,5 @@ import QueryOptionsI from './types/QueryOptionsI';
 export default abstract class Table {
     private connection;
     constructor(connection: Connection);
-    protected createQuery(queryString: string, options?: QueryOptionsI): Query;
+    createQuery(queryString: string, options?: QueryOptionsI): Query;
 }

package/dist/query/BindParams.d.ts

@@ -5,5 +5,4 @@ export default class BindParams {
     private static bindWhereParams;
     private static bindWhereParam;
     private static bindLimitParams;
-    private static bindValuesParams;
 }

package/dist/query/BindParams.js

@@ -6,9 +6,6 @@ export default class BindParams {
             BindParams.bindWhereParams(query, options.where.parameters);
         if (options?.limit)
             BindParams.bindLimitParams(query, options.limit);
-        if (options?.values) {
-            BindParams.bindValuesParams(query, options.values);
-        }
     }
     static bindWhereParams(query, parameters) {
         parameters.forEach((parameter) => {
@@ -37,24 +34,4 @@ export default class BindParams {
         query.bindParameter("limit", resultLimitation.limit);
         query.bindParameter("offset", resultLimitation.offset);
     }
-    static bindValuesParams(query, values) {
-        if (Array.isArray(values[0].value)) {
-            const quantity = values[0].value.length;
-            for (let i = 0; i < quantity; i++) {
-                values.forEach((value) => {
-                    if (Array.isArray(value.value)) {
-                        query.bindParameter(`${value.name}_${i}`, value.value[i]);
-                    }
-                    else {
-                        query.bindParameter(`${value.name}_${i}`, value.value);
-                    }
-                });
-            }
-        }
-        else {
-            values.forEach((value) => {
-                query.bindParameter(`${value.name}_0`, value.value);
-            });
-        }
-    }
 }

package/dist/query/QueryParams.d.ts

@@ -1,20 +1,7 @@
-import ParameterI from '../types/ParameterI';
 import QueryOptionsI from '../types/QueryOptionsI';
 export default class QueryParams {
-    private static where;
-    private static params;
-    private static orderBy;
-    private static limit;
-    private static values;
-    private static paramConnector;
     static createParams(queryString: string, options: QueryOptionsI): string;
-    static createValuesParams(sql: string, values: ParameterI[]): string;
-    private static createValueParams;
     private static createWhereParams;
-    private static createOrderParams;
-    private static createLimitParams;
     private static createParamsSql;
-    private static removeWhereVariable;
-    private static splitSql;
-    private static getWhereConnector;
+    private static createOrderParams;
 }

package/dist/query/QueryParams.js

@@ -1,88 +1,20 @@
-import QueryParamCreator from './QueryParamCreator';
 import QueryParamsCreator from './QueryParamCreator';
 export default class QueryParams {
-    static where = '$WHERE';
-    static params = '$PARAMS';
-    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)))
+        if (options.where)
             queryString = QueryParams.createWhereParams(queryString, options.where);
-        if (options && queryString.includes(this.orderBy))
+        if (options.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))
-            queryString = QueryParams.createValuesParams(queryString, options.values);
+        if (options.limit)
+            queryString += `LIMIT $limit::BIGINT OFFSET $offset::BIGINT`;
         return queryString;
     }
-    static createValuesParams(sql, values) {
-        const vals = [];
-        if (Array.isArray(values[0].value)) {
-            const quantity = values[0].value.length;
-            for (let i = 0; i < quantity; i++) {
-                vals.push(this.createValueParams(values, i));
-            }
-        }
-        else {
-            vals.push(this.createValueParams(values));
-        }
-        sql = sql.replaceAll(this.values, `VALUES ${vals.join(', ')}`);
-        return sql;
-    }
-    static createValueParams(values, index) {
-        const creatingValues = [];
-        values.forEach((value) => {
-            let valueall;
-            if (index) {
-                const paramType = QueryParamCreator.getBaseTypeForComplexType(value.type);
-                valueall = QueryParamCreator.createParamValue(`${value.name}_${index}`, paramType);
-            }
-            else {
-                valueall = QueryParamCreator.createParamValue(`${value.name}_0`, value.type);
-            }
-            creatingValues.push(valueall);
-        });
-        return `( ${creatingValues.join(', ')} )`;
-    }
     static createWhereParams(sql, where) {
-        let sqlWithParams = '';
         const params = this.createParamsSql(where.parameters);
-        if (sql.includes(this.where) || sql.includes(this.params)) {
-            if (params.length > 0) {
-                const { leftSql, rightSql } = this.splitSql(sql);
-                const connector = this.getWhereConnector(sql);
-                sqlWithParams = `${leftSql} ${connector} ${params.join(` ${where.connector}`)} ${rightSql}`;
-            }
-            else
-                sqlWithParams = this.removeWhereVariable(sql);
-        }
-        else
-            throw new Error(`Brak zmiennej: ${this.where} lub ${this.params} w zapytaniu sql`);
+        const connector = 'WHERE';
+        const sqlWithParams = `${sql} ${connector} ${params.join(` ${where.connector} `)}`;
         return sqlWithParams;
     }
-    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.orderBy, '');
-        return sql;
-    }
-    static createLimitParams(sql, resultLimitation) {
-        if (resultLimitation) {
-            sql = sql.replaceAll(this.limit, `LIMIT $limit::BIGINT OFFSET $offset::BIGINT`);
-        }
-        else
-            sql = sql.replaceAll(this.limit, '');
-        return sql;
-    }
     static createParamsSql(parameters) {
         let sqlParams = [];
         parameters.forEach((parameter) => {
@@ -92,26 +24,12 @@ export default class QueryParams {
         });
         return sqlParams;
     }
-    static removeWhereVariable(sql) {
-        sql = sql.replaceAll(this.where, '');
-        sql = sql.replaceAll(this.params, '');
+    static createOrderParams(sql, orderBy) {
+        let sqlString = `ORDER BY `;
+        orderBy.forEach(item => {
+            sqlString += `${item.key} ${item.order} `;
+        });
+        sql = `${sql} ${sqlString}`;
         return sql;
     }
-    static splitSql(sql) {
-        let sqlArray = [];
-        if (sql.includes(this.where))
-            sqlArray = sql.split(this.where);
-        else if (sql.includes(this.params))
-            sqlArray = sql.split(this.params);
-        return {
-            leftSql: sqlArray[0],
-            rightSql: sqlArray[1]
-        };
-    }
-    static getWhereConnector(sql) {
-        if (sql.includes(this.where))
-            return 'WHERE';
-        else if (sql.includes(this.params))
-            return 'AND';
-    }
 }

package/package.json

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