@dascompany/database 2.1.5 → 3.0.1

package/dist/Table.d.ts

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

package/dist/query/BindParams.d.ts

@@ -1,7 +1,7 @@
-import QueryOptionsI from "../types/QueryOptionsI";
 import Query from "./Query";
+import QueryOptions from "./QueryOptions";
 export default class BindParams {
-    static bindParams(query: Query, options: QueryOptionsI): void;
+    static bindParams(query: Query, options: QueryOptions): void;
     private static bindWhereParams;
     private static bindWhereParam;
     private static bindLimitParams;

package/dist/query/BindParams.js

@@ -2,10 +2,12 @@ import ParameterType from "../types/parameters/ParameterType";
 import QueryParamCreator from "./QueryParamCreator";
 export default class BindParams {
     static bindParams(query, options) {
-        if (options?.where)
-            BindParams.bindWhereParams(query, options.where.parameters);
-        if (options?.limit)
-            BindParams.bindLimitParams(query, options.limit);
+        const where = options.getWhere();
+        const limit = options.getLimit();
+        if (where)
+            BindParams.bindWhereParams(query, where.parameters);
+        if (limit)
+            BindParams.bindLimitParams(query, limit);
     }
     static bindWhereParams(query, parameters) {
         parameters.forEach((parameter) => {

package/dist/query/QueryOptions.d.ts

@@ -1,6 +1,17 @@
 import ResultLimitationI from "../types/ResultLimitationI";
 import OrderByI from "../types/OrderByI";
+import WhereOptionI from "../types/WhereOptionI";
+import ParameterI from "../types/ParameterI";
+import ConnectorE from "../types/ConnectorE";
 export default class QueryOptions {
-    static correctingSorting(querySortBy: any): OrderByI[];
-    static correctingLimitation(queryLimit: any, queryOffset: any): ResultLimitationI;
+    private where;
+    private orderBy;
+    private limit;
+    constructor();
+    getWhere(): WhereOptionI | null;
+    getOrderBy(): OrderByI[] | null;
+    getLimit(): ResultLimitationI | null;
+    setWhere(parameters: ParameterI[], connector?: ConnectorE): void;
+    setOrderBy(orderBy: OrderByI[]): void;
+    setLimit(limit: number, offset: number): void;
 }

package/dist/query/QueryOptions.js

@@ -1,23 +1,33 @@
-import ParameterType from "../types/parameters/ParameterType";
-import Filters from "../utils/Filters";
-import Parameters from "../utils/Parameters";
+import ConnectorE from "../types/ConnectorE";
 export default class QueryOptions {
-    static correctingSorting(querySortBy) {
-        const orderBy = Parameters.correct(querySortBy, { type: ParameterType.arrayObject });
-        const table = [];
-        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 });
-            });
-        }
-        return table;
+    where;
+    orderBy;
+    limit;
+    constructor() {
+        this.where = null;
+        this.orderBy = null;
+        this.limit = null;
     }
-    static correctingLimitation(queryLimit, queryOffset) {
-        const limit = Parameters.correct(queryLimit, { type: ParameterType.bigint });
-        const offset = Parameters.correct(queryOffset, { type: ParameterType.bigint });
-        return {
+    getWhere() {
+        return this.where;
+    }
+    getOrderBy() {
+        return this.orderBy;
+    }
+    getLimit() {
+        return this.limit;
+    }
+    setWhere(parameters, connector = ConnectorE.and) {
+        this.where = {
+            connector,
+            parameters
+        };
+    }
+    setOrderBy(orderBy) {
+        this.orderBy = orderBy;
+    }
+    setLimit(limit, offset) {
+        this.limit = {
             limit,
             offset
         };

package/dist/query/QueryParams.d.ts

@@ -1,6 +1,6 @@
-import QueryOptionsI from '../types/QueryOptionsI';
+import QueryOptions from './QueryOptions';
 export default class QueryParams {
-    static createParams(queryString: string, options: QueryOptionsI): string;
+    static createParams(queryString: string, options: QueryOptions): string;
     private static createWhereParams;
     private static createParamsSql;
     private static createOrderParams;

package/dist/query/QueryParams.js

@@ -1,19 +1,24 @@
 import QueryParamsCreator from './QueryParamCreator';
 export default class QueryParams {
     static createParams(queryString, options) {
-        if (options.where)
-            queryString = QueryParams.createWhereParams(queryString, options.where);
-        if (options.orderBy)
-            queryString = QueryParams.createOrderParams(queryString, options.orderBy);
-        if (options.limit)
-            queryString += `LIMIT $limit::BIGINT OFFSET $offset::BIGINT`;
+        const where = options.getWhere();
+        const orderBy = options.getOrderBy();
+        const limit = options.getLimit();
+        if (where)
+            queryString = QueryParams.createWhereParams(queryString, where);
+        if (orderBy)
+            queryString = QueryParams.createOrderParams(queryString, orderBy);
+        if (limit)
+            queryString += ` LIMIT $limit::BIGINT OFFSET $offset::BIGINT`;
         return queryString;
     }
     static createWhereParams(sql, where) {
         const params = this.createParamsSql(where.parameters);
         const connector = 'WHERE';
-        const sqlWithParams = `${sql} ${connector} ${params.join(` ${where.connector} `)}`;
-        return sqlWithParams;
+        if (params.length > 0)
+            return `${sql} ${connector} ${params.join(` ${where.connector} `)}`;
+        else
+            return sql;
     }
     static createParamsSql(parameters) {
         let sqlParams = [];

package/package.json

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