@dascompany/product 1.1.7 → 2.1.0

package/dist/repo/FileConnectionsRepo.d.ts

@@ -1,7 +1,8 @@
+import { QueryOptions } from "@dascompany/database";
 import FileConnection from "../stockObjects/FileConnection";
 export default class FileConnectionsRepo {
-    static getAllForFileId(fileId: number): Promise<FileConnection[]>;
-    static deleteAllForConnection(connectionType: string, connectionId: number): Promise<boolean>;
+    static getAll(queryOptions: QueryOptions): Promise<FileConnection[]>;
+    static delete(id: number): Promise<boolean>;
     private static correctFileConnections;
     private static correctFileConnection;
 }

package/dist/repo/FileConnectionsRepo.js

@@ -1,12 +1,12 @@
 import DatabaseConnection from "../DatabaseConnection";
 import FileConnection from "../stockObjects/FileConnection";
 export default class FileConnectionsRepo {
-    static async getAllForFileId(fileId) {
-        const fileConnections = await DatabaseConnection.getInstance().fileConnections.selectForFileId(fileId);
+    static async getAll(queryOptions) {
+        const fileConnections = await DatabaseConnection.getInstance().fileConnections.selectAll(queryOptions);
         return this.correctFileConnections(fileConnections);
     }
-    static async deleteAllForConnection(connectionType, connectionId) {
-        return await DatabaseConnection.getInstance().fileConnections.deleteForConnection(connectionType, connectionId);
+    static async delete(id) {
+        return await DatabaseConnection.getInstance().fileConnections.delete(id);
     }
     static correctFileConnections(dataRows) {
         const fileConnections = [];

package/dist/repo/FilesRepo.d.ts

@@ -1,7 +1,7 @@
-import FileConnectionTypeE from "../types/FileConnectionTypeE";
+import { QueryOptions } from "@dascompany/database";
 export default class FilesRepo {
-    static get(fileId: number): Promise<any>;
-    static getAllForConnection(connectionType: FileConnectionTypeE, connectionId: number): Promise<any>;
+    static get(queryOptions: QueryOptions): Promise<any>;
+    static getAll(queryOptions: QueryOptions): Promise<any>;
     private static createFilesFromRows;
     private static createFileFromRow;
 }

package/dist/repo/FilesRepo.js

@@ -1,12 +1,12 @@
 import DatabaseConnection from "../DatabaseConnection";
 import File from "../stockObjects/File";
 export default class FilesRepo {
-    static async get(fileId) {
-        const file = await DatabaseConnection.getInstance().files.select(fileId);
+    static async get(queryOptions) {
+        const file = await DatabaseConnection.getInstance().files.select(queryOptions);
         return this.createFileFromRow(file);
     }
-    static async getAllForConnection(connectionType, connectionId) {
-        const files = await DatabaseConnection.getInstance().files.selectForConnection(connectionType, connectionId);
+    static async getAll(queryOptions) {
+        const files = await DatabaseConnection.getInstance().files.selectForConnection(queryOptions);
         return this.createFilesFromRows(files);
     }
     static async createFilesFromRows(dataRows) {

package/dist/repo/InvoiceDetailsRepo.d.ts

@@ -1,5 +1,6 @@
+import { QueryOptions } from "@dascompany/database";
 import InvoiceDetails from "../stockObjects/InvoiceDetails";
 export default class InvoiceDetailsRepo {
-    static get(invoiceDetailsId: number): Promise<InvoiceDetails>;
+    static get(queryOptions: QueryOptions): Promise<InvoiceDetails>;
     private static createInvoiceDetailsFromRow;
 }

package/dist/repo/InvoiceDetailsRepo.js

@@ -1,8 +1,8 @@
 import DatabaseConnection from "../DatabaseConnection";
 import InvoiceDetails from "../stockObjects/InvoiceDetails";
 export default class InvoiceDetailsRepo {
-    static async get(invoiceDetailsId) {
-        const invoiceDetailsRow = await DatabaseConnection.getInstance().invoiceDetails.select(invoiceDetailsId);
+    static async get(queryOptions) {
+        const invoiceDetailsRow = await DatabaseConnection.getInstance().invoiceDetails.select(queryOptions);
         return this.createInvoiceDetailsFromRow(invoiceDetailsRow);
     }
     static createInvoiceDetailsFromRow(invoiceDetailsRow) {

package/dist/repo/OrderProductsRepo.d.ts

@@ -1,7 +1,7 @@
+import { QueryOptions } from "@dascompany/database";
 import OrderProduct from "../stockObjects/OrderProduct";
 export default class OrderProductsRepo {
-    static getAllActive(orderId: number): Promise<OrderProduct[]>;
-    static getAllForIds(orderProductsIds: number[]): Promise<OrderProduct[]>;
+    static getAll(queryOptions: QueryOptions): Promise<OrderProduct[]>;
     private static createOrdersProductsFromRows;
     private static createOrdersProductFromRow;
 }

package/dist/repo/OrderProductsRepo.js

@@ -1,21 +1,8 @@
-import { ConnectorE, ParameterType } from "@dascompany/database";
 import DatabaseConnection from "../DatabaseConnection";
 import OrderProduct from "../stockObjects/OrderProduct";
 export default class OrderProductsRepo {
-    static async getAllActive(orderId) {
-        const orderProducts = await DatabaseConnection.getInstance().ordersProducts.selectAllActive(orderId);
-        return this.createOrdersProductsFromRows(orderProducts);
-    }
-    static async getAllForIds(orderProductsIds) {
-        const queryOptions = {
-            where: {
-                connector: ConnectorE.and,
-                parameters: [
-                    { name: 'id', type: ParameterType.arrayBigint, value: orderProductsIds },
-                ]
-            }
-        };
-        const orderProducts = await DatabaseConnection.getInstance().ordersProducts.selectAllForIds(queryOptions);
+    static async getAll(queryOptions) {
+        const orderProducts = await DatabaseConnection.getInstance().ordersProducts.selectAll(queryOptions);
         return this.createOrdersProductsFromRows(orderProducts);
     }
     static async createOrdersProductsFromRows(dataRows) {

package/dist/repo/OrderRepo.d.ts

@@ -1,5 +1,6 @@
+import { QueryOptions } from "@dascompany/database";
 import Order from "../stockObjects/Order";
 export default class OrderRepo {
-    static get(orderId: number): Promise<Order>;
+    static get(queryOptions: QueryOptions): Promise<Order>;
     private static createOrderFromRow;
 }

package/dist/repo/OrderRepo.js

@@ -1,8 +1,8 @@
 import DatabaseConnection from "../DatabaseConnection";
 import Order from "../stockObjects/Order";
 export default class OrderRepo {
-    static async get(orderId) {
-        const orderData = await DatabaseConnection.getInstance().orders.select(orderId);
+    static async get(queryOptions) {
+        const orderData = await DatabaseConnection.getInstance().orders.select(queryOptions);
         return this.createOrderFromRow(orderData);
     }
     static createOrderFromRow(orderData) {

package/dist/repo/OrderStatusRepo.d.ts

@@ -1,7 +1,8 @@
+import { QueryOptions } from "@dascompany/database";
 import Status from "../stockObjects/Status";
 export default class OrderStatusRepo {
-    static get(orderId: number): Promise<Status>;
-    static getAll(orderId: number): Promise<Status[]>;
+    static get(queryOptions: QueryOptions): Promise<Status>;
+    static getAll(queryOptions: QueryOptions): Promise<Status[]>;
     private static createStatusesFromRows;
     private static createStatusFromRow;
 }

package/dist/repo/OrderStatusRepo.js

@@ -1,12 +1,12 @@
 import DatabaseConnection from "../DatabaseConnection";
 import Status from "../stockObjects/Status";
 export default class OrderStatusRepo {
-    static async get(orderId) {
-        const status = await DatabaseConnection.getInstance().statuses.select(orderId);
+    static async get(queryOptions) {
+        const status = await DatabaseConnection.getInstance().statuses.select(queryOptions);
         return this.createStatusFromRow(status);
     }
-    static async getAll(orderId) {
-        const statuses = await DatabaseConnection.getInstance().statuses.selectAll(orderId);
+    static async getAll(queryOptions) {
+        const statuses = await DatabaseConnection.getInstance().statuses.selectAll(queryOptions);
         return this.createStatusesFromRows(statuses);
     }
     static async createStatusesFromRows(dataRows) {

package/dist/repo/PaymentDetailsRepo.d.ts

@@ -1,5 +1,6 @@
+import { QueryOptions } from "@dascompany/database";
 import PaymentDetails from "../stockObjects/PaymentDetails";
 export default class PaymentDetailsRepo {
-    static get(paymentDetailsId: number): Promise<PaymentDetails>;
+    static get(queryOptions: QueryOptions): Promise<PaymentDetails>;
     private static createPaymentDetailsFromRow;
 }

package/dist/repo/PaymentDetailsRepo.js

@@ -1,8 +1,8 @@
 import DatabaseConnection from "../DatabaseConnection";
 import PaymentDetails from "../stockObjects/PaymentDetails";
 export default class PaymentDetailsRepo {
-    static async get(paymentDetailsId) {
-        const paymentDetailsRow = await DatabaseConnection.getInstance().paymentDetails.select(paymentDetailsId);
+    static async get(queryOptions) {
+        const paymentDetailsRow = await DatabaseConnection.getInstance().paymentDetails.select(queryOptions);
         return this.createPaymentDetailsFromRow(paymentDetailsRow);
     }
     static createPaymentDetailsFromRow(paymentDetailsRow) {

package/dist/repo/PaymentMethodRepo.d.ts

@@ -1,4 +1,5 @@
+import { QueryOptions } from "@dascompany/database";
 import PaymentMethods from "../stockObjects/PaymentMethods";
 export default class PaymentMethodRepo {
-    static get(id: number): Promise<PaymentMethods>;
+    static get(queryOptions: QueryOptions): Promise<PaymentMethods>;
 }

package/dist/repo/PaymentMethodRepo.js

@@ -1,8 +1,8 @@
 import DatabaseConnection from "../DatabaseConnection";
 import PaymentMethods from "../stockObjects/PaymentMethods";
 export default class PaymentMethodRepo {
-    static async get(id) {
-        const paymentMethodsRow = await DatabaseConnection.getInstance().paymentMethods.select(id);
+    static async get(queryOptions) {
+        const paymentMethodsRow = await DatabaseConnection.getInstance().paymentMethods.select(queryOptions);
         const paymentMethods = new PaymentMethods(paymentMethodsRow.key, paymentMethodsRow.active);
         paymentMethods.setId(paymentMethodsRow.id);
         return paymentMethods;

package/dist/repo/PersonalDataRepo.d.ts

@@ -1,5 +1,6 @@
+import { QueryOptions } from "@dascompany/database";
 import PersonalData from "../stockObjects/PersonalData";
 export default class PersonalDataRepo {
-    static get(personalDataId: number): Promise<PersonalData>;
+    static get(queryOptions: QueryOptions): Promise<PersonalData>;
     private static createPersonalDataFromRow;
 }

package/dist/repo/PersonalDataRepo.js

@@ -2,8 +2,8 @@ import DatabaseConnection from "../DatabaseConnection";
 import PersonalData from "../stockObjects/PersonalData";
 import correctPhoneNumber from "../utils/correctPhoneNumber";
 export default class PersonalDataRepo {
-    static async get(personalDataId) {
-        const personalData = await DatabaseConnection.getInstance().personalData.select(personalDataId);
+    static async get(queryOptions) {
+        const personalData = await DatabaseConnection.getInstance().personalData.select(queryOptions);
         return this.createPersonalDataFromRow(personalData);
     }
     static createPersonalDataFromRow(dataRow) {

package/dist/repo/ProductRepo.d.ts

@@ -1,6 +1,6 @@
 import Product from "../stockObjects/Product";
+import { QueryOptions } from "@dascompany/database";
 export default class ProductRepo {
-    static get(productId: number): Promise<Product>;
-    static getForSku(productSku: string): Promise<Product>;
+    static get(queryOptions: QueryOptions): Promise<Product>;
     private static createProductFromRow;
 }

package/dist/repo/ProductRepo.js

@@ -1,12 +1,8 @@
 import Product from "../stockObjects/Product";
 import DatabaseConnection from "../DatabaseConnection";
 export default class ProductRepo {
-    static async get(productId) {
-        const product = await DatabaseConnection.getInstance().products.select(productId);
-        return this.createProductFromRow(product);
-    }
-    static async getForSku(productSku) {
-        const product = await DatabaseConnection.getInstance().products.selectForSku(productSku);
+    static async get(queryOptions) {
+        const product = await DatabaseConnection.getInstance().products.select(queryOptions);
         return this.createProductFromRow(product);
     }
     static createProductFromRow(productRow) {

package/dist/stockObjects/Order.js

@@ -1,4 +1,4 @@
-import { StockObject } from "@dascompany/database";
+import { ParameterType, QueryOptions, StockObject } from "@dascompany/database";
 import OrderMapper from "../mappers/OrderMapper";
 import OrderProductsRepo from "../repo/OrderProductsRepo";
 import calculateNetToGrossPrice from "../utils/calculateNetToGrossPrice";
@@ -87,7 +87,9 @@ export default class Order extends StockObject {
         const id = this.getId();
         if (id) {
             let totalPrice = 0;
-            const orderProducts = await OrderProductsRepo.getAllActive(id);
+            const queryOptions = new QueryOptions();
+            queryOptions.setWhere([{ name: 'id', type: ParameterType.bigint, value: id }]);
+            const orderProducts = await OrderProductsRepo.getAll(queryOptions);
             for (const product of orderProducts) {
                 totalPrice += product.getNetPrice();
             }

package/dist/stockObjects/PersonalData.js

@@ -1,4 +1,4 @@
-import { StockObject } from "@dascompany/database";
+import { ParameterType, QueryOptions, StockObject } from "@dascompany/database";
 import PersonalDataMapper from "../mappers/PersonalDataMapper";
 import CompanyDetailsRepo from "../repo/CompanyDetailsRepo";
 export default class PersonalData extends StockObject {
@@ -35,8 +35,11 @@ export default class PersonalData extends StockObject {
         return companyDetailsData;
     }
     async getCompanyDetails() {
-        if (this.companyDetailsId && !this.companyDetails)
-            this.companyDetails = await CompanyDetailsRepo.get(this.companyDetailsId);
+        if (this.companyDetailsId && !this.companyDetails) {
+            const queryOptions = new QueryOptions();
+            queryOptions.setWhere([{ name: 'id', type: ParameterType.bigint, value: this.companyDetailsId }]);
+            this.companyDetails = await CompanyDetailsRepo.get(queryOptions);
+        }
         return this.companyDetails;
     }
     isCompany() {

package/dist/stockObjects/Product.js

@@ -1,4 +1,4 @@
-import { StockObject } from "@dascompany/database";
+import { ParameterType, QueryOptions, StockObject } from "@dascompany/database";
 import ProductMapper from "../mappers/ProductMapper";
 import FilesReader from "../reader/FilesReader";
 import FileConnectionTypeE from "../types/FileConnectionTypeE";
@@ -87,15 +87,20 @@ export default class Product extends StockObject {
         return this.deleted;
     }
     async getFile() {
-        if (!this.file && this.fileId)
-            this.file = await FilesReader.get(this.fileId);
+        if (!this.file && this.fileId) {
+            const queryOptions = new QueryOptions();
+            queryOptions.setWhere([{ name: 'id', type: ParameterType.bigint, value: this.fileId }]);
+            this.file = await FilesReader.get(queryOptions);
+        }
         return this.file;
     }
     async getFiles() {
         if (!this.files) {
             const id = this.getId();
             if (id) {
-                const files = await FilesReader.getForConnection(FileConnectionTypeE.product, id);
+                const queryOptions = new QueryOptions();
+                queryOptions.setWhere([{ name: 'connection_id', type: ParameterType.bigint, value: id }, { name: 'connection_type', type: ParameterType.string, value: FileConnectionTypeE.product }]);
+                const files = await FilesReader.getForConnection(queryOptions);
                 this.files = files;
             }
         }

package/dist/tables/clients/ClientAccountsTable.d.ts

@@ -1,16 +1,14 @@
-import { QueryOptionsI, Table } from '@dascompany/database';
+import { QueryOptions, Table } from '@dascompany/database';
 import ClientAccountRow from '../../types/rows/ClientAccountRow';
 import Client from '../../stockObjects/Client';
 export default class ClientAccountsTable extends Table {
-    select(accountId: number): Promise<ClientAccountRow>;
-    selectEmail(id: number): Promise<string>;
-    count(queryOptions: QueryOptionsI): Promise<number>;
-    selectAll(queryOptions: QueryOptionsI): Promise<ClientAccountRow[]>;
-    selectForEmail(email: string): Promise<ClientAccountRow>;
+    select(queryOptions: QueryOptions): Promise<ClientAccountRow>;
+    selectAll(queryOptions: QueryOptions): Promise<ClientAccountRow[]>;
+    selectId(queryOptions: QueryOptions): Promise<number | null>;
+    count(queryOptions: QueryOptions): Promise<number>;
     update(clientData: Client): Promise<void>;
     delete(accountId: number): Promise<number>;
     private bindParameters;
     insert(clientAccount: Client): Promise<void>;
-    getIdForEmail(email: string): Promise<number>;
     private selectNextId;
 }

package/dist/tables/clients/ClientAccountsTable.js

@@ -1,15 +1,18 @@
-import { Table } from '@dascompany/database';
+import { ParameterType, QueryOptions, Table } from '@dascompany/database';
 import * as SQL from '../../SQL.json';
 export default class ClientAccountsTable extends Table {
-    async select(accountId) {
-        const query = this.createQuery(SQL.accounts.select);
-        query.bindParameter('account_id', accountId);
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.accounts.select, queryOptions);
         const result = await query.execute();
         return result.getRow();
     }
-    async selectEmail(id) {
-        const query = this.createQuery(SQL.accounts.selectEmail);
-        query.bindParameter('id', id);
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.accounts.select, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async selectId(queryOptions) {
+        const query = this.createQuery(SQL.accounts.selectId, queryOptions);
         const result = await query.execute();
         return result.getValue();
     }
@@ -18,15 +21,6 @@ export default class ClientAccountsTable extends Table {
         const result = await query.execute();
         return result.getValue();
     }
-    async selectAll(queryOptions) {
-        const query = this.createQuery(SQL.accounts.selectAll, queryOptions);
-        const result = await query.execute();
-        return result.getRows();
-    }
-    async selectForEmail(email) {
-        const id = await this.getIdForEmail(email);
-        return await this.select(id);
-    }
     async update(clientData) {
         const query = this.createQuery(SQL.accounts.update);
         query.bindParameter('id', clientData.getId());
@@ -48,7 +42,9 @@ export default class ClientAccountsTable extends Table {
     }
     async insert(clientAccount) {
         const clientEmail = clientAccount.getEmail();
-        let accountId = await this.getIdForEmail(clientEmail);
+        const queryOptions = new QueryOptions();
+        queryOptions.setWhere([{ name: 'email', type: ParameterType.string, value: clientEmail }]);
+        let accountId = await this.selectId(queryOptions);
         if (accountId)
             throw new Error(`Client account with email: ${clientEmail} already exist!`);
         else
@@ -60,12 +56,6 @@ export default class ClientAccountsTable extends Table {
         await query.execute();
         clientAccount.setId(accountId);
     }
-    async getIdForEmail(email) {
-        const query = this.createQuery(SQL.accounts.getIdForEmail);
-        query.bindParameter('email', String(email).toUpperCase());
-        const result = await query.execute();
-        return result.getValue();
-    }
     async selectNextId() {
         const query = this.createQuery(SQL.accounts.selectNextId);
         const result = await query.execute();

package/dist/tables/files/FileConnectionsTable.d.ts

@@ -1,12 +1,9 @@
-import { Table } from '@dascompany/database';
-import FileConnectionTypeE from '../../types/FileConnectionTypeE';
+import { QueryOptions, Table } from '@dascompany/database';
 import FileConnection from '../../stockObjects/FileConnection';
 import FileConnectionRow from '../../types/rows/FileConnectionRow';
 export default class FileConnectionsTable extends Table {
-    select(connectionType: FileConnectionTypeE, connection_id: number): Promise<any[]>;
-    selectForFileId(fileId: number): Promise<FileConnectionRow[]>;
+    selectAll(queryOptions: QueryOptions): Promise<FileConnectionRow[]>;
     insert(fileConnection: FileConnection): Promise<void>;
-    delete(fileId: number): Promise<boolean>;
-    deleteForConnection(connectionType: string, connectionId: number): Promise<boolean>;
+    delete(id: number): Promise<boolean>;
     private bindParameters;
 }

package/dist/tables/files/FileConnectionsTable.js

@@ -1,16 +1,8 @@
 import { Table } from '@dascompany/database';
 import * as SQL from '../../SQL.json';
 export default class FileConnectionsTable extends Table {
-    async select(connectionType, connection_id) {
-        const query = this.createQuery(SQL.fileConnections.select);
-        query.bindParameter('connectionType', connectionType);
-        query.bindParameter('connection_id', connection_id);
-        const result = await query.execute();
-        return result.getRows();
-    }
-    async selectForFileId(fileId) {
-        const query = this.createQuery(SQL.fileConnections.selectForFileId);
-        query.bindParameter('file_id', fileId);
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.fileConnections.select, queryOptions);
         const result = await query.execute();
         return result.getRows();
     }
@@ -19,16 +11,9 @@ export default class FileConnectionsTable extends Table {
         this.bindParameters(query, fileConnection);
         await query.execute();
     }
-    async delete(fileId) {
+    async delete(id) {
         const query = this.createQuery(SQL.fileConnections.delete);
-        query.bindParameter('file_id', fileId);
-        await query.execute();
-        return true;
-    }
-    async deleteForConnection(connectionType, connectionId) {
-        const query = this.createQuery(SQL.fileConnections.deleteForConnection);
-        query.bindParameter('connection_type', connectionType);
-        query.bindParameter('connection_id', connectionId);
+        query.bindParameter('id', id);
         await query.execute();
         return true;
     }

package/dist/tables/files/FilesTable.d.ts

@@ -1,15 +1,14 @@
-import { QueryOptionsI, Table } from '@dascompany/database';
+import { QueryOptions, Table } from '@dascompany/database';
 import FileRow from '../../types/rows/FileRow';
-import FileConnectionTypeE from '../../types/FileConnectionTypeE';
 import File from '../../stockObjects/File';
 export default class FilesTable extends Table {
-    selectId(queryOptions: QueryOptionsI): Promise<number>;
-    selectAll(queryOptions: QueryOptionsI): Promise<FileRow[]>;
-    select(fileId: number): Promise<FileRow>;
-    selectForConnection(connectionType: FileConnectionTypeE, connectionId: number): Promise<FileRow[]>;
+    select(queryOptions: QueryOptions): Promise<FileRow>;
+    selectAll(queryOptions: QueryOptions): Promise<FileRow[]>;
+    selectId(queryOptions: QueryOptions): Promise<number>;
+    selectForConnection(queryOptions: QueryOptions): Promise<FileRow[]>;
     insert(file: File): Promise<boolean>;
     update(fileData: File): Promise<boolean>;
-    count(queryOptions: QueryOptionsI): Promise<number>;
+    count(queryOptions: QueryOptions): Promise<number>;
     private bindParameters;
     delete(fileId: number): Promise<number>;
     private selectNextId;

package/dist/tables/files/FilesTable.js

@@ -1,26 +1,23 @@
 import { Table } from '@dascompany/database';
 import * as SQL from '../../SQL.json';
 export default class FilesTable extends Table {
-    async selectId(queryOptions) {
-        const query = this.createQuery(SQL.files.selectId, queryOptions);
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.files.select, queryOptions);
         const result = await query.execute();
-        return result.getValue();
+        return result.getRow();
     }
     async selectAll(queryOptions) {
-        const query = this.createQuery(SQL.files.selectAll, queryOptions);
+        const query = this.createQuery(SQL.files.select, queryOptions);
         const result = await query.execute();
         return result.getRows();
     }
-    async select(fileId) {
-        const query = this.createQuery(SQL.files.select);
-        query.bindParameter('id', fileId);
+    async selectId(queryOptions) {
+        const query = this.createQuery(SQL.files.selectId, queryOptions);
         const result = await query.execute();
-        return result.getRow();
+        return result.getValue();
     }
-    async selectForConnection(connectionType, connectionId) {
-        const query = this.createQuery(SQL.files.selectForConnection);
-        query.bindParameter('connection_type', connectionType);
-        query.bindParameter('connection_id', connectionId);
+    async selectForConnection(queryOptions) {
+        const query = this.createQuery(SQL.files.selectForConnection, queryOptions);
         const result = await query.execute();
         return result.getRows();
     }

package/dist/tables/orders/OrdersProductsTable.d.ts

@@ -1,11 +1,10 @@
-import { QueryOptionsI, Table } from '@dascompany/database';
+import { QueryOptions, Table } from '@dascompany/database';
 import OrderProductRow from '../../types/rows/OrderProductRow';
 import OrderProduct from '../../stockObjects/OrderProduct';
 export default class OrdersProductsTable extends Table {
-    selectAllActive(orderId: number): Promise<OrderProductRow[]>;
-    selectAllForIds(queryOprions: QueryOptionsI): Promise<OrderProductRow[]>;
-    delete(orderProduct: OrderProduct): Promise<boolean>;
-    private bindParams;
+    selectAll(queryOprions: QueryOptions): Promise<OrderProductRow[]>;
     insert(orderProduct: OrderProduct): Promise<boolean>;
+    delete(orderProduct: OrderProduct): Promise<boolean>;
     private selectNextId;
+    private bindParams;
 }

package/dist/tables/orders/OrdersProductsTable.js

@@ -1,30 +1,11 @@
 import { Table } from '@dascompany/database';
 import * as SQL from '../../SQL.json';
 export default class OrdersProductsTable extends Table {
-    async selectAllActive(orderId) {
-        const query = this.createQuery(SQL.ordersProducts.selectAllActive);
-        query.bindParameter('order_id', orderId);
-        const result = await query.execute();
-        return result.getRows();
-    }
-    async selectAllForIds(queryOprions) {
+    async selectAll(queryOprions) {
         const query = this.createQuery(SQL.ordersProducts.selectAll, queryOprions);
         const result = await query.execute();
         return result.getRows();
     }
-    async delete(orderProduct) {
-        const query = this.createQuery(SQL.ordersProducts.delete);
-        const id = orderProduct.getId();
-        query.bindParameter('id', id);
-        await query.execute();
-        return true;
-    }
-    bindParams(query, orderProduct) {
-        query.bindParameter('order_id', orderProduct.getOrderId());
-        query.bindParameter('product_id', orderProduct.getProductId());
-        query.bindParameter('net_price', orderProduct.getNetPrice());
-        query.bindParameter('in_order', orderProduct.getInOrder());
-    }
     async insert(orderProduct) {
         const query = this.createQuery(SQL.ordersProducts.insert);
         const id = await this.selectNextId();
@@ -34,9 +15,22 @@ export default class OrdersProductsTable extends Table {
         orderProduct.setId(id);
         return true;
     }
+    async delete(orderProduct) {
+        const query = this.createQuery(SQL.ordersProducts.delete);
+        const id = orderProduct.getId();
+        query.bindParameter('id', id);
+        await query.execute();
+        return true;
+    }
     async selectNextId() {
         const query = this.createQuery(SQL.ordersProducts.selectNextId);
         const result = await query.execute();
         return result.getValue();
     }
+    bindParams(query, orderProduct) {
+        query.bindParameter('order_id', orderProduct.getOrderId());
+        query.bindParameter('product_id', orderProduct.getProductId());
+        query.bindParameter('net_price', orderProduct.getNetPrice());
+        query.bindParameter('in_order', orderProduct.getInOrder());
+    }
 }

package/dist/tables/orders/OrdersTable.d.ts

@@ -1,11 +1,10 @@
-import { QueryOptionsI, Table } from '@dascompany/database';
+import { QueryOptions, Table } from '@dascompany/database';
 import OrderRow from '../../types/rows/OrderRow';
 import Order from '../../stockObjects/Order';
 export default class OrdersTable extends Table {
-    select(orderId: number): Promise<OrderRow>;
-    selectForClient(clientId: number): Promise<OrderRow[]>;
-    selectAll(queryOption: QueryOptionsI): Promise<OrderRow[]>;
-    count(queryOptions?: QueryOptionsI): Promise<number>;
+    select(queryOptions: QueryOptions): Promise<OrderRow>;
+    selectAll(queryOption: QueryOptions): Promise<OrderRow[]>;
+    count(queryOptions?: QueryOptions): Promise<number>;
     insert(order: Order): Promise<void>;
     update(order: Order): Promise<void>;
     private bindParameters;