@dascompany/product 1.1.7 → 2.1.0

package/dist/reader/InvoiceDetailsReader.js

@@ -1,16 +1,31 @@
+import { ParameterType, QueryOptions } from "@dascompany/database";
 import DatabaseConnection from "../DatabaseConnection";
 import AddressesReader from "./AddressesReader";
 import PersonalDataReader from "./PersonalDataReader";
 export default class InvoiceDetailsReader {
-    static async get(invoiceDetailsId) {
-        const invoiceDetails = await DatabaseConnection.getInstance().invoiceDetails.select(invoiceDetailsId);
+    static async get(queryOptions) {
+        const invoiceDetails = await DatabaseConnection.getInstance().invoiceDetails.select(queryOptions);
         const id = invoiceDetails.id;
         let personalData = null;
         let address = null;
-        if (invoiceDetails.personal_data_id)
-            personalData = await PersonalDataReader.get(invoiceDetails.personal_data_id);
-        if (invoiceDetails.address_id)
-            address = await AddressesReader.get(invoiceDetails.address_id);
+        if (invoiceDetails.personal_data_id) {
+            const queryOptionsPersonalData = new QueryOptions();
+            queryOptionsPersonalData.setWhere([{
+                    name: 'id',
+                    type: ParameterType.bigint,
+                    value: invoiceDetails.personal_data_id
+                }]);
+            personalData = await PersonalDataReader.get(queryOptionsPersonalData);
+        }
+        if (invoiceDetails.address_id) {
+            const queryOptionsAddress = new QueryOptions();
+            queryOptionsAddress.setWhere([{
+                    name: 'id',
+                    type: ParameterType.bigint,
+                    value: invoiceDetails.address_id
+                }]);
+            address = await AddressesReader.get(queryOptionsAddress);
+        }
         return {
             id,
             personalData,

package/dist/reader/OrderProductsReader.d.ts

@@ -1,7 +1,7 @@
+import { QueryOptions } from "@dascompany/database";
 import OrderProductI from "../types/OrderProductI";
 export default class OrderProductsReader {
-    static getAll(orderId: number): Promise<OrderProductI[]>;
-    static getForOrder(orderId: number): Promise<any[]>;
+    static getAll(queryOptions: QueryOptions): Promise<OrderProductI[]>;
     private static correctOrderProducts;
     private static correctProduct;
 }

package/dist/reader/OrderProductsReader.js

@@ -1,26 +1,13 @@
+import { ParameterType, QueryOptions } from "@dascompany/database";
 import DatabaseConnection from "../DatabaseConnection";
 import calculateNetToGrossPrice from "../utils/calculateNetToGrossPrice";
 import FilesReader from "./FilesReader";
 export default class OrderProductsReader {
-    static async getAll(orderId) {
-        const orderProducts = await DatabaseConnection.getInstance().ordersProducts.selectAllActive(orderId);
+    static async getAll(queryOptions) {
+        const orderProducts = await DatabaseConnection.getInstance().ordersProducts.selectAll(queryOptions);
         const correctProducts = await this.correctOrderProducts(orderProducts);
         return correctProducts;
     }
-    static async getForOrder(orderId) {
-        const products = await DatabaseConnection.getInstance().ordersProducts.selectAllActive(orderId);
-        const correctProducts = [];
-        for (let i = 0; i < products.length; i++) {
-            const correctProduct = {
-                id: products[i].id,
-                orderId: products[i].order_id,
-                productId: products[i].product_id,
-                netPrice: products[i].net_price,
-            };
-            correctProducts.push(correctProduct);
-        }
-        return correctProducts;
-    }
     static async correctOrderProducts(products) {
         const correctProducts = [];
         for (let i = 0; i < products.length; i++) {
@@ -30,7 +17,9 @@ export default class OrderProductsReader {
         return correctProducts;
     }
     static async correctProduct(orderProduct) {
-        const file = await FilesReader.get(orderProduct.file_id);
+        const queryOptions = new QueryOptions();
+        queryOptions.setWhere([{ name: 'id', type: ParameterType.bigint, value: orderProduct.file_id }]);
+        const file = await FilesReader.get(queryOptions);
         const correctProduct = {
             id: orderProduct.id,
             orderId: orderProduct.order_id,

package/dist/reader/OrderReader.d.ts

@@ -1,12 +1,10 @@
-import { QueryOptionsI } from "@dascompany/database";
+import { QueryOptions } from "@dascompany/database";
 import OrderI from "../types/OrderI";
 export default class OrderReader {
-    static get(orderId: number): Promise<OrderI>;
-    static getForClient(clientAccountId: number): Promise<OrderI[]>;
-    static getAll(queryOptions: QueryOptionsI): Promise<{
-        orders: OrderI[];
-        quantity: number;
-    }>;
+    static get(queryOptions: QueryOptions): Promise<OrderI>;
+    static getAll(queryOptions: QueryOptions): Promise<OrderI[]>;
+    static getAllForClient(queryOptions: QueryOptions): Promise<OrderI[]>;
+    static getQuantity(queryOptions: QueryOptions): Promise<number>;
     private static correctOrders;
     private static correctOrder;
 }

package/dist/reader/OrderReader.js

@@ -1,26 +1,29 @@
+import { ParameterType, QueryOptions } from "@dascompany/database";
 import DatabaseConnection from "../DatabaseConnection";
 import OrderProductsReader from "./OrderProductsReader";
 import OrderStatusReader from "./OrderStatusReader";
 export default class OrderReader {
-    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.correctOrder(orderData);
     }
-    static async getForClient(clientAccountId) {
-        const orders = await DatabaseConnection.getInstance().orders.selectForClient(clientAccountId);
+    static async getAll(queryOptions) {
+        const orders = await DatabaseConnection.getInstance().orders.selectAll(queryOptions);
         const correctOrders = [];
         for (let i = 0; i < orders.length; i++) {
             const correctOrder = await this.correctOrder(orders[i]);
-            const products = await OrderProductsReader.getAll(orders[i].id);
-            correctOrders.push({ ...correctOrder, products });
+            correctOrders.push(correctOrder);
         }
         return correctOrders;
     }
-    static async getAll(queryOptions) {
+    static async getAllForClient(queryOptions) {
         const orderRows = await DatabaseConnection.getInstance().orders.selectAll(queryOptions);
-        const quantity = await DatabaseConnection.getInstance().orders.count(queryOptions);
         const orders = await this.correctOrders(orderRows);
-        return { orders, quantity };
+        return orders;
+    }
+    static async getQuantity(queryOptions) {
+        const quantity = await DatabaseConnection.getInstance().orders.count(queryOptions);
+        return quantity;
     }
     static async correctOrders(orderRows) {
         const orders = [];
@@ -31,7 +34,10 @@ export default class OrderReader {
         return orders;
     }
     static async correctOrder(order) {
-        const status = await OrderStatusReader.get(order.id);
+        const queryOptions = new QueryOptions();
+        queryOptions.setWhere([{ name: 'order_id', type: ParameterType.bigint, value: order.id }]);
+        const products = await OrderProductsReader.getAll(queryOptions);
+        const status = await OrderStatusReader.get(queryOptions);
         const correctOrder = {
             id: order.id,
             email: order.email,
@@ -43,7 +49,8 @@ export default class OrderReader {
             invoiceDetailsId: order.invoice_details_id,
             paymentDetailsId: order.payment_details_id,
             zsiId: order.zsi_id,
-            status
+            status,
+            products
         };
         return correctOrder;
     }

package/dist/reader/OrderStatusReader.d.ts

@@ -1,6 +1,7 @@
+import { QueryOptions } from "@dascompany/database";
 import OrderStatusI from "../types/StatusI";
 export default class OrderStatusReader {
-    static get(orderId: number): Promise<OrderStatusI>;
-    static getAll(orderId: number): Promise<OrderStatusI[]>;
+    static get(queryOptions: QueryOptions): Promise<OrderStatusI>;
+    static getAll(queryOptions: QueryOptions): Promise<OrderStatusI[]>;
     private static correctStatus;
 }

package/dist/reader/OrderStatusReader.js

@@ -1,11 +1,11 @@
 import DatabaseConnection from "../DatabaseConnection";
 export default class OrderStatusReader {
-    static async get(orderId) {
-        const statusRow = await DatabaseConnection.getInstance().statuses.select(orderId);
+    static async get(queryOptions) {
+        const statusRow = await DatabaseConnection.getInstance().statuses.select(queryOptions);
         return this.correctStatus(statusRow);
     }
-    static async getAll(orderId) {
-        const statuses = await DatabaseConnection.getInstance().statuses.selectAll(orderId);
+    static async getAll(queryOptions) {
+        const statuses = await DatabaseConnection.getInstance().statuses.selectAll(queryOptions);
         const correctStatuss = [];
         for (let i = 0; i < statuses.length; i++) {
             const correctStatus = this.correctStatus(statuses[i]);

package/dist/reader/PersonalDataReader.d.ts

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

package/dist/reader/PersonalDataReader.js

@@ -1,12 +1,19 @@
+import { ParameterType, QueryOptions } from "@dascompany/database";
 import DatabaseConnection from "../DatabaseConnection";
 import correctPhoneNumber from "../utils/correctPhoneNumber";
 import CompanyDetailsReader from "./CompanyDetailsReader";
 export default class PersonalDataReader {
-    static async get(personalDataId) {
-        const personalDataRow = await DatabaseConnection.getInstance().personalData.select(personalDataId);
+    static async get(queryOptions) {
+        const personalDataRow = await DatabaseConnection.getInstance().personalData.select(queryOptions);
         const personalData = this.correctPersonalData(personalDataRow);
         if (personalDataRow.company_details_id) {
-            personalData.companyDetails = await CompanyDetailsReader.get(personalDataRow.company_details_id);
+            const queryOptions = new QueryOptions();
+            queryOptions.setWhere([{
+                    name: 'id',
+                    type: ParameterType.bigint,
+                    value: personalDataRow.company_details_id
+                }]);
+            personalData.companyDetails = await CompanyDetailsReader.get(queryOptions);
             personalData.isCompany = true;
         }
         return personalData;

package/dist/reader/ProductReader.d.ts

@@ -1,12 +1,11 @@
-import { QueryOptionsI } from "@dascompany/database";
+import { QueryOptions } from "@dascompany/database";
 import ProductI from "../types/ProductI";
 export default class ProductReader {
-    static get(productId: number): Promise<ProductI>;
-    static getForUrl(productUrl: string): Promise<ProductI>;
-    static getAllActive(queryOptions: QueryOptionsI): Promise<ProductI[]>;
-    static getIdForSku(productSku: string): Promise<number>;
-    static getQuantity(queryOptions: QueryOptionsI): Promise<number>;
-    static getMaxPrice(queryOptions: QueryOptionsI): Promise<number>;
+    static get(queryOption: QueryOptions): Promise<ProductI>;
+    static getAll(queryOption: QueryOptions): Promise<ProductI[]>;
+    static getId(queryOptions: QueryOptions): Promise<number>;
+    static getQuantity(queryOptions: QueryOptions): Promise<number>;
+    static getMaxPrice(queryOptions: QueryOptions): Promise<number>;
     private static correctProducts;
     private static correctProduct;
 }

package/dist/reader/ProductReader.js

@@ -1,24 +1,23 @@
-import FileConnectionTypeE from "../types/FileConnectionTypeE";
+import { ParameterType, QueryOptions } from "@dascompany/database";
 import calculateNetToGrossPrice from "../utils/calculateNetToGrossPrice";
 import FilesReader from "./FilesReader";
 import DatabaseConnection from "../DatabaseConnection";
+import FileConnectionTypeE from "../types/FileConnectionTypeE";
 export default class ProductReader {
-    static async get(productId) {
-        const product = await DatabaseConnection.getInstance().products.select(productId);
-        const files = await FilesReader.getForConnection(FileConnectionTypeE.product, product.id);
-        return this.correctProduct(product, files);
-    }
-    static async getForUrl(productUrl) {
-        const product = await DatabaseConnection.getInstance().products.selectForUrl(productUrl);
-        const files = await FilesReader.getForConnection(FileConnectionTypeE.product, product.id);
-        return this.correctProduct(product, files);
-    }
-    static async getAllActive(queryOptions) {
-        const products = await DatabaseConnection.getInstance().products.selectAllActive(queryOptions);
+    static async get(queryOption) {
+        const product = await DatabaseConnection.getInstance().products.select(queryOption);
+        const queryOptionsFiles = new QueryOptions();
+        queryOptionsFiles.setWhere([{ name: 'connection_id', type: ParameterType.bigint, value: product.id }, { name: 'connection_type', type: ParameterType.string, value: FileConnectionTypeE.product }]);
+        queryOptionsFiles.setOrderBy([{ key: 'sequence', order: 'asc' }]);
+        const files = await FilesReader.getForConnection(queryOptionsFiles);
+        return { ...this.correctProduct(product), files };
+    }
+    static async getAll(queryOption) {
+        const products = await DatabaseConnection.getInstance().products.selectAll(queryOption);
         return this.correctProducts(products);
     }
-    static async getIdForSku(productSku) {
-        return await DatabaseConnection.getInstance().products.selectIdForSku(productSku);
+    static async getId(queryOptions) {
+        return await DatabaseConnection.getInstance().products.selectId(queryOptions);
     }
     static async getQuantity(queryOptions) {
         const quantity = await DatabaseConnection.getInstance().products.count(queryOptions);
@@ -36,8 +35,10 @@ export default class ProductReader {
         }
         return correctProducts;
     }
-    static async correctProduct(product, files) {
-        const thumbnail = await FilesReader.get(product.file_id);
+    static async correctProduct(product) {
+        const queryOptions = new QueryOptions();
+        queryOptions.setWhere([{ name: 'id', type: ParameterType.bigint, value: product.file_id }]);
+        const thumbnail = await FilesReader.get(queryOptions);
         return {
             id: product.id,
             sku: product.sku,
@@ -54,7 +55,6 @@ export default class ProductReader {
             createdAt: product.created_at,
             deleted: product.deleted,
             thumbnail: thumbnail ? thumbnail : null,
-            files,
             grossPrice: calculateNetToGrossPrice(product.net_price, product.vat),
             jsonData: product.json_data
         };

package/dist/reader/payment/PaymentDetailsReader.d.ts

@@ -1,5 +1,5 @@
+import { QueryOptions } from "@dascompany/database";
 export default class PaymentDetailsReader {
-    static get(paymentDetailsId: number): Promise<any>;
-    static getPaymentOrderId(paymentDetailsId: number): Promise<any>;
+    static get(queryOptions: QueryOptions): Promise<any>;
     private static correctPaymentDetails;
 }

package/dist/reader/payment/PaymentDetailsReader.js

@@ -1,20 +1,29 @@
+import { ParameterType, QueryOptions } from "@dascompany/database";
 import DatabaseConnection from "../../DatabaseConnection";
 import PaymentMethodReader from "./PaymentMethodReader";
 import PaymentStatusesReader from "./PaymentStatusesReader";
 export default class PaymentDetailsReader {
-    static async get(paymentDetailsId) {
-        const paymentDetails = await DatabaseConnection.getInstance().paymentDetails.select(paymentDetailsId);
+    static async get(queryOptions) {
+        const paymentDetails = await DatabaseConnection.getInstance().paymentDetails.select(queryOptions);
         return await this.correctPaymentDetails(paymentDetails);
     }
-    static async getPaymentOrderId(paymentDetailsId) {
-        const paymentDetails = await DatabaseConnection.getInstance().paymentDetails.select(paymentDetailsId);
-        return paymentDetails.payment_order_id;
-    }
     static async correctPaymentDetails(paymentDetails) {
         const id = paymentDetails.id;
+        const queryOptionsForPaymentMethod = new QueryOptions();
+        queryOptionsForPaymentMethod.setWhere([{
+                name: 'id',
+                type: ParameterType.bigint,
+                value: paymentDetails.payment_method_id
+            }]);
+        const queryOptionsForPaymentStatus = new QueryOptions();
+        queryOptionsForPaymentStatus.setWhere([{
+                name: 'peyment_details_id',
+                type: ParameterType.bigint,
+                value: paymentDetails.id
+            }]);
         const [paymentMethod, statuses] = await Promise.all([
-            PaymentMethodReader.get(paymentDetails.payment_method_id),
-            PaymentStatusesReader.getAll(paymentDetails.id)
+            PaymentMethodReader.get(queryOptionsForPaymentMethod),
+            PaymentStatusesReader.getAll(queryOptionsForPaymentStatus)
         ]);
         return {
             id,

package/dist/reader/payment/PaymentMethodReader.d.ts

@@ -1,6 +1,6 @@
+import { QueryOptions } from "@dascompany/database";
 import PaymentMethodI from "../../types/PaymentMethodI";
 export default class PaymentMethodReader {
-    static get(paymentMethodId: number): Promise<PaymentMethodI>;
-    static getAll(): Promise<PaymentMethodI[]>;
-    static getAllActive(): Promise<PaymentMethodI[]>;
+    static get(queryOptions: QueryOptions): Promise<PaymentMethodI>;
+    static getAll(queryOptions: QueryOptions): Promise<PaymentMethodI[]>;
 }

package/dist/reader/payment/PaymentMethodReader.js

@@ -1,15 +1,11 @@
 import DatabaseConnection from "../../DatabaseConnection";
 export default class PaymentMethodReader {
-    static async get(paymentMethodId) {
-        const paymentMethod = await DatabaseConnection.getInstance().paymentMethods.select(paymentMethodId);
+    static async get(queryOptions) {
+        const paymentMethod = await DatabaseConnection.getInstance().paymentMethods.select(queryOptions);
         return paymentMethod;
     }
-    static async getAll() {
-        const paymentMethods = await DatabaseConnection.getInstance().paymentMethods.selectAll();
-        return paymentMethods;
-    }
-    static async getAllActive() {
-        const paymentMethods = await DatabaseConnection.getInstance().paymentMethods.selectAllActive();
+    static async getAll(queryOptions) {
+        const paymentMethods = await DatabaseConnection.getInstance().paymentMethods.selectAll(queryOptions);
         return paymentMethods;
     }
 }

package/dist/reader/payment/PaymentStatusesReader.d.ts

@@ -1,5 +1,6 @@
+import { QueryOptions } from "@dascompany/database";
 export default class PaymentStatusesReader {
-    static get(paymentDetailsId: number): Promise<any>;
-    static getAll(paymentDetailsId: number): Promise<any[]>;
+    static get(queryOptions: QueryOptions): Promise<any>;
+    static getAll(queryOptions: QueryOptions): Promise<any[]>;
     private static correctPaymentStatus;
 }

package/dist/reader/payment/PaymentStatusesReader.js

@@ -1,14 +1,15 @@
+import { ParameterType, QueryOptions } from "@dascompany/database";
 import DatabaseConnection from "../../DatabaseConnection";
 export default class PaymentStatusesReader {
-    static async get(paymentDetailsId) {
-        const paymentStatus = await DatabaseConnection.getInstance().paymentStatuses.select(paymentDetailsId);
+    static async get(queryOptions) {
+        const paymentStatus = await DatabaseConnection.getInstance().paymentStatuses.select(queryOptions);
         if (paymentStatus)
             return await this.correctPaymentStatus(paymentStatus);
         else
             return {};
     }
-    static async getAll(paymentDetailsId) {
-        const paymentStatusesData = await DatabaseConnection.getInstance().paymentStatuses.selectAll(paymentDetailsId);
+    static async getAll(queryOptions) {
+        const paymentStatusesData = await DatabaseConnection.getInstance().paymentStatuses.selectAll(queryOptions);
         const paymentStatuses = [];
         for (let i = 0; i < paymentStatusesData.length; i++) {
             const paymentStatus = await this.correctPaymentStatus(paymentStatusesData[i]);
@@ -17,7 +18,9 @@ export default class PaymentStatusesReader {
         return paymentStatuses;
     }
     static async correctPaymentStatus(paymentStatus) {
-        const paymentStatusType = await DatabaseConnection.getInstance().paymentStatusTypes.select(paymentStatus.payment_status_type_id);
+        const queryOptions = new QueryOptions();
+        queryOptions.setWhere([{ name: 'id', type: ParameterType.bigint, value: paymentStatus.payment_status_type_id }]);
+        const paymentStatusType = await DatabaseConnection.getInstance().paymentStatusTypes.select(queryOptions);
         return {
             id: paymentStatus.id,
             type: paymentStatusType,

package/dist/repo/AddressesRepo.d.ts

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

package/dist/repo/AddressesRepo.js

@@ -1,8 +1,8 @@
 import DatabaseConnection from "../DatabaseConnection";
 import Address from "../stockObjects/Address";
 export default class AddressesRepo {
-    static async get(addressId) {
-        const address = await DatabaseConnection.getInstance().addresses.select(addressId);
+    static async get(queryOptions) {
+        const address = await DatabaseConnection.getInstance().addresses.select(queryOptions);
         return this.createAddressFromRow(address);
     }
     static createAddressFromRow(dataRow) {

package/dist/repo/AdminRepo.d.ts

@@ -1,12 +1,10 @@
-import { QueryOptionsI } from "@dascompany/database";
+import { QueryOptions } from "@dascompany/database";
 import Admin from "../stockObjects/Admin";
 export default class AdminRepo {
-    static get(accountId: number): Promise<Admin>;
-    static getIdForEmail(email: string): Promise<number>;
-    static getAll(queryOptions: QueryOptionsI): Promise<{
-        adminAccounts: Admin[];
-        quantity: number;
-    }>;
+    static get(queryOptions: QueryOptions): Promise<Admin>;
+    static getId(queryOptions: QueryOptions): Promise<number>;
+    static getAll(queryOptions: QueryOptions): Promise<Admin[]>;
+    static getQuantity(queryOptions: QueryOptions): Promise<number>;
     private static createAdminsFromRows;
     private static createAdminFromRow;
 }

package/dist/repo/AdminRepo.js

@@ -1,17 +1,20 @@
 import DatabaseConnection from "../DatabaseConnection";
 import Admin from "../stockObjects/Admin";
 export default class AdminRepo {
-    static async get(accountId) {
-        const account = await DatabaseConnection.getInstance().adminAccounts.select(accountId);
+    static async get(queryOptions) {
+        const account = await DatabaseConnection.getInstance().adminAccounts.select(queryOptions);
         return this.createAdminFromRow(account);
     }
-    static async getIdForEmail(email) {
-        return await DatabaseConnection.getInstance().adminAccounts.selectForEmail(email);
+    static async getId(queryOptions) {
+        return await DatabaseConnection.getInstance().adminAccounts.selectId(queryOptions);
     }
     static async getAll(queryOptions) {
         const adminAccounts = await DatabaseConnection.getInstance().adminAccounts.selectAll(queryOptions);
+        return this.createAdminsFromRows(adminAccounts);
+    }
+    static async getQuantity(queryOptions) {
         const quantity = await DatabaseConnection.getInstance().adminAccounts.count(queryOptions);
-        return { adminAccounts: this.createAdminsFromRows(adminAccounts), quantity };
+        return quantity;
     }
     static createAdminsFromRows(dataRows) {
         const admins = [];

package/dist/repo/ClientAccountRepo.d.ts

@@ -1,7 +1,6 @@
+import { QueryOptions } from "@dascompany/database";
 import Client from "../stockObjects/Client";
 export default class ClientAccountRepo {
-    static get(accountId: number): Promise<Client>;
-    static getById(clientId: number): Promise<Client>;
-    static getEmailForId(clientId: number): Promise<string>;
+    static get(queryOptions: QueryOptions): Promise<Client>;
     private static createCilentAccountFromRow;
 }

package/dist/repo/ClientAccountRepo.js

@@ -1,18 +1,10 @@
 import DatabaseConnection from "../DatabaseConnection";
 import Client from "../stockObjects/Client";
 export default class ClientAccountRepo {
-    static async get(accountId) {
-        const accountData = await DatabaseConnection.getInstance().clientAccounts.select(accountId);
+    static async get(queryOptions) {
+        const accountData = await DatabaseConnection.getInstance().clientAccounts.select(queryOptions);
         return this.createCilentAccountFromRow(accountData);
     }
-    static async getById(clientId) {
-        const client = await DatabaseConnection.getInstance().clientAccounts.select(clientId);
-        return this.createCilentAccountFromRow(client);
-    }
-    static async getEmailForId(clientId) {
-        const email = await DatabaseConnection.getInstance().clientAccounts.selectEmail(clientId);
-        return email;
-    }
     static createCilentAccountFromRow(accountData) {
         const client = new Client(accountData.email, accountData.activated, accountData.deleted, accountData.contact_details_id, accountData.delivery_details_id, accountData.invoice_details_id, accountData.created_at);
         client.setId(accountData.id);

package/dist/repo/CompanyDetailsRepo.d.ts

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

package/dist/repo/CompanyDetailsRepo.js

@@ -1,8 +1,8 @@
 import DatabaseConnection from "../DatabaseConnection";
 import CompanyDetails from "../stockObjects/CompanyDetails";
 export default class CompanyDetailsRepo {
-    static async get(id) {
-        const companyDetailsRow = await DatabaseConnection.getInstance().companyDetails.select(id);
+    static async get(queryOptions) {
+        const companyDetailsRow = await DatabaseConnection.getInstance().companyDetails.select(queryOptions);
         return this.createCompanyDetailsFromRow(companyDetailsRow);
     }
     static createCompanyDetailsFromRow(companyDetailsRow) {

package/dist/repo/ContactDetailsRepo.d.ts

@@ -1,6 +1,7 @@
+import { QueryOptions } from "@dascompany/database";
 import ContactDetails from "../stockObjects/ContactDetails";
 export default class ContactDetailsRepo {
-    static get(contactDetailsId: number): Promise<ContactDetails>;
+    static get(queryOptions: QueryOptions): Promise<ContactDetails>;
     static getNextId(): Promise<number>;
     private static createContactDetailsFromRow;
 }

package/dist/repo/ContactDetailsRepo.js

@@ -1,8 +1,8 @@
 import DatabaseConnection from "../DatabaseConnection";
 import ContactDetails from "../stockObjects/ContactDetails";
 export default class ContactDetailsRepo {
-    static async get(contactDetailsId) {
-        const contactDetailsRow = await DatabaseConnection.getInstance().contactDetails.select(contactDetailsId);
+    static async get(queryOptions) {
+        const contactDetailsRow = await DatabaseConnection.getInstance().contactDetails.select(queryOptions);
         return this.createContactDetailsFromRow(contactDetailsRow);
     }
     static async getNextId() {

package/dist/repo/DeliveryDetailsRepo.d.ts

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

package/dist/repo/DeliveryDetailsRepo.js

@@ -1,8 +1,8 @@
 import DatabaseConnection from "../DatabaseConnection";
 import DeliveryDetails from "../stockObjects/DeliveryDetails";
 export default class DeliveryDetailsRepo {
-    static async get(deliveryDetailsId) {
-        const deliveryDetailsRow = await DatabaseConnection.getInstance().deliveryDetails.select(deliveryDetailsId);
+    static async get(queryOptions) {
+        const deliveryDetailsRow = await DatabaseConnection.getInstance().deliveryDetails.select(queryOptions);
         return this.createDeliveryDetailsFromRow(deliveryDetailsRow);
     }
     static createDeliveryDetailsFromRow(deliveryDetailsRow) {

package/dist/repo/DeliveryMethodRepo.d.ts

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

package/dist/repo/DeliveryMethodRepo.js

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