@dascompany/product 1.1.7 → 2.0.0

package/dist/SQL.json

@@ -1,153 +1,133 @@
 {
     "adminAccounts": {
-        "select": "SELECT id, first_name, last_name, email, created_at, activated, deleted FROM admin_accounts WHERE id = $id::BIGINT",
-        "selectAll": "SELECT id, first_name, last_name, email, created_at, activated, deleted FROM admin_accounts $WHERE $ORDERBY $LIMIT ",
-        "selectNextId": "SELECT nextval('admin_account_id'::regclass)",
-        "selectForEmail": "SELECT id FROM admin_accounts WHERE LOWER( email ) = LOWER($email::TEXT)",
+        "select": "SELECT * FROM admin_accounts",
+        "selectId": "SELECT id FROM admin_accounts",
         "insert": "INSERT INTO admin_accounts( id, first_name, last_name, email, activated) VALUES ($id::BIGINT, $first_name::TEXT, $last_name::TEXT, LOWER($email::TEXT), $activated::BOOL)",
         "update": "UPDATE admin_accounts SET  first_name = $first_name::TEXT, last_name = $last_name::TEXT , email = LOWER($email::TEXT), activated = $activated::BOOL, deleted = $deleted::BOOL WHERE id = $id::BIGINT",
         "delete": "UPDATE admin_accounts SET deleted = true, activated = false WHERE id = $id::BIGINT",
-        "count": "SELECT COUNT(*) AS total_rows FROM admin_accounts $WHERE "
+        "count": "SELECT COUNT(*) AS total_rows FROM admin_accounts",
+        "selectNextId": "SELECT nextval('admin_account_id'::regclass)"
     },
     "accounts": {
-        "select": "SELECT  id, email, created_at, activated, deleted, contact_details_id, delivery_details_id, invoice_details_id FROM clients.accounts WHERE id = $account_id::BIGINT",
-        "selectAll": "SELECT id, email, created_at, activated, deleted FROM clients.accounts $WHERE $ORDERBY $LIMIT",
-        "selectNextId": "SELECT nextval('clients.accounts_id'::regclass)",
-        "getIdForEmail": "SELECT id FROM clients.accounts WHERE LOWER( email ) = LOWER($email::TEXT)",
+        "select": "SELECT * FROM clients.accounts",
+        "selectId": "SELECT id FROM clients.accounts ",
         "insert": "INSERT INTO clients.accounts( id, email, activated, contact_details_id) VALUES ($id::BIGINT, LOWER($email::TEXT), $activated::BOOL, $contact_details_id::BIGINT)",
         "update": "UPDATE clients.accounts SET activated = $activated::BOOL, deleted = $deleted::BOOL, contact_details_id = $contact_details_id::BIGINT, delivery_details_id = $delivery_details_id::BIGINT, invoice_details_id = $invoice_details_id::BIGINT WHERE id = $id::BIGINT",
         "delete": "DELETE FROM clients.accounts WHERE id = $account_id::BIGINT",
-        "count": "SELECT COUNT(*) AS total_rows FROM clients.accounts $WHERE ",
-        "selectEmail": "SELECT email FROM clients.accounts WHERE id = $id:BIGINT"
+        "count": "SELECT COUNT(*) AS total_rows FROM clients.accounts",
+        "selectNextId": "SELECT nextval('clients.accounts_id'::regclass)"
     },
     "contactDetails": {
-        "select": "SELECT id, personal_data_id, address_id FROM personal_information.contact_details  WHERE id = $id::BIGINT",
+        "select": "SELECT * FROM personal_information.contact_details",
         "insert": "INSERT INTO personal_information.contact_details(id, personal_data_id, address_id) VALUES ($id::BIGINT, $personal_data_id::BIGINT, $address_id::BIGINT)",
         "update": "UPDATE personal_information.contact_details SET personal_data_id = $personal_data_id::BIGINT, address_id = $address_id::BIGINT WHERE id = $id::BIGINT",
         "selectNextId": "SELECT nextval('personal_information.contact_details_id'::regclass)"
     },
     "deliveryDetails": {
-        "select": "SELECT id, personal_data_id, address_id, delivery_method_id FROM personal_information.delivery_details  WHERE id = $id::BIGINT",
+        "select": "SELECT * FROM personal_information.delivery_details",
         "insert": "INSERT INTO personal_information.delivery_details(id, personal_data_id, address_id, delivery_method_id) VALUES ($id::BIGINT, $personal_data_id::BIGINT, $address_id::BIGINT, $delivery_method_id::BIGINT)",
         "update": "UPDATE personal_information.delivery_details SET personal_data_id = $personal_data_id::BIGINT, address_id = $address_id::BIGINT, delivery_method_id = $delivery_method_id::BIGINT WHERE id = $id::BIGINT",
         "selectNextId": "SELECT nextval('personal_information.delivery_details_id'::regclass)"
     },
     "invoiceDetails": {
-        "select": "SELECT id, personal_data_id, address_id FROM personal_information.invoice_details  WHERE id = $id::BIGINT",
+        "select": "SELECT * FROM personal_information.invoice_details",
         "insert": "INSERT INTO personal_information.invoice_details(id, personal_data_id, address_id) VALUES ($id::BIGINT, $personal_data_id::BIGINT, $address_id::BIGINT)",
         "update": "UPDATE personal_information.invoice_details SET personal_data_id = $personal_data_id::BIGINT, address_id = $address_id::BIGINT WHERE id = $id::BIGINT",
         "selectNextId": "SELECT nextval('personal_information.invoice_details_id'::regclass)"
     },
     "addresses": {
-        "select": "SELECT id, country, city, postal_code, street, house_number, apartment_number FROM personal_information.addresses WHERE id = $id::BIGINT",
+        "select": "SELECT * FROM personal_information.addresses",
         "insert": "INSERT INTO personal_information.addresses( id, country, city, postal_code, street, house_number, apartment_number) VALUES( $id::BIGINT, $country::TEXT, $city::TEXT, $postal_code::TEXT, $street::TEXT, $house_number::TEXT, $apartment_number::TEXT) ",
         "update": "UPDATE personal_information.addresses SET  country = $country::TEXT, city = $city::TEXT, postal_code = $postal_code::TEXT , street = $street::TEXT , house_number = $house_number::TEXT , apartment_number = $apartment_number::TEXT  WHERE id = $id::BIGINT",
         "selectNextId": "SELECT nextval('personal_information.addresses_id'::regclass)"
     },
     "personalData": {
-        "select": "SELECT id, first_name, last_name, email, phone_number, company_details_id FROM personal_information.personal_data  WHERE id = $id::BIGINT",
+        "select": "SELECT * FROM personal_information.personal_data",
         "insert": "INSERT INTO personal_information.personal_data (id, first_name, last_name, email, phone_number, company_details_id) VALUES ($id::BIGINT, $first_name::TEXT, $last_name::TEXT, $email::TEXT, $phone_number::TEXT, $company_details_id::BIGINT)",
         "update": "UPDATE personal_information.personal_data SET email = $email::TEXT, first_name = $first_name::TEXT, last_name= $last_name::TEXT, phone_number = $phone_number::TEXT, company_details_id = $company_details_id::BIGINT WHERE id = $id::BIGINT",
         "selectNextId": "SELECT nextval('personal_information.personal_data_id'::regclass)"
     },
     "companyDetails": {
-        "select": "SELECT id, name, tax_number FROM personal_information.company_details WHERE id = $id::BIGINT",
+        "select": "SELECT * FROM personal_information.company_details",
         "insert": "INSERT INTO personal_information.company_details( id, name, tax_number ) VALUES ($id::BIGINT, $name::TEXT, $tax_number::TEXT )",
         "update": "UPDATE personal_information.company_details SET name = $name::TEXT, tax_number = $tax_number::TEXT WHERE id = $id::BIGINT",
         "delete": "DELETE FROM personal_information.company_details WHERE id = $id::BIGINT",
         "selectNextId": "SELECT nextval('personal_information.company_details_id'::regclass)"
     },
     "products": {
-        "select": "SELECT * FROM products WHERE id = $id::BIGINT",
-        "selectForUrl": "SELECT * FROM products WHERE LOWER( url ) = LOWER($url::TEXT)",
-        "selectForSku": "SELECT * FROM products WHERE LOWER( sku ) = LOWER($sku::TEXT)",
-        "selectAll": "SELECT id, sku, url, title, description, net_price, vat, color, quantity, width, height, length, file_id, created_at, deleted FROM products $WHERE $ORDERBY LIMIT $limit::BIGINT OFFSET $offset::BIGINT",
-        "selectAllActive": "SELECT id, sku, url, title, description, net_price, vat, color, quantity, width, height, length, file_id, created_at, deleted FROM products WHERE deleted = false  $PARAMS $ORDERBY LIMIT $limit::BIGINT OFFSET $offset::BIGINT",
-        "selectIdForSku": "SELECT id FROM products WHERE LOWER( sku ) = LOWER($sku::TEXT) AND deleted = false",
+        "select": "SELECT * FROM products",
+        "selectId": "SELECT id FROM products",
         "insert": "INSERT INTO products( id, sku, url, title, description, net_price, vat, color, quantity, width, length, height, file_id, json_data, deleted) VALUES ($id::BIGINT, $sku::TEXT, $url::TEXT, $title::TEXT, $description::TEXT, $net_price::DOUBLE PRECISION, $vat::INT, $color::TEXT, $quantity::INT, $width::INT,  $length::INT, $height::DOUBLE PRECISION,$file_id::BIGINT , $json_data::JSON, false::BOOL)",
         "update": "UPDATE products SET url = $url::TEXT, title = $title::TEXT, description = $description::TEXT , net_price = $net_price::DOUBLE PRECISION, vat = $vat::INT, color = $color::TEXT, quantity = $quantity::INT, width = $width::INT, length = $length::INT, height = $height::DOUBLE PRECISION, file_id = $file_id::BIGINT, json_data = $json_data::JSON  WHERE id = $id::BIGINT",
         "delete": "UPDATE products SET deleted = true WHERE id = $id::BIGINT",
-        "selectNextId": "SELECT nextval('product_id'::regclass)",
-        "maxPrice": "SELECT MAX(net_price) FROM products WHERE deleted = false $PARAMS",
-        "count": "SELECT COUNT(*) AS total_rows FROM products WHERE deleted = false $PARAMS"
+        "maxPrice": "SELECT MAX(net_price) FROM products",
+        "count": "SELECT COUNT(*) AS total_rows FROM products",
+        "selectNextId": "SELECT nextval('product_id'::regclass)"
     },
     "orders": {
-        "selectAll": "SELECT id, email, price, client_id, contact_details_id, delivery_details_id, invoice_details_id, payment_details_id, zsi_id, created_at FROM orders.orders",
-        "select": "SELECT id, email, price, client_id, contact_details_id, delivery_details_id, invoice_details_id, payment_details_id, zsi_id FROM orders.orders WHERE id = $id::BIGINT",
-        "selectForClient": "SELECT id, email, price, client_id, contact_details_id, delivery_details_id, invoice_details_id, payment_details_id FROM orders.orders WHERE client_id = $client_id::BIGINT ORDER BY id DESC",
+        "select": "SELECT * FROM orders.orders",
         "insert": "INSERT INTO orders.orders( id, email, price, client_id, contact_details_id, delivery_details_id, invoice_details_id, payment_details_id ) VALUES ($order_id::BIGINT, $email::TEXT, $price::DOUBLE PRECISION, $client_id::BIGINT,  $contact_details_id::BIGINT, $delivery_details_id::BIGINT , $invoice_details_id::BIGINT, $payment_details_id::BIGINT )",
         "update": "UPDATE orders.orders SET price = $price::DOUBLE PRECISION, contact_details_id = $contact_details_id::BIGINT, delivery_details_id = $delivery_details_id::BIGINT, invoice_details_id = $invoice_details_id::BIGINT, payment_details_id = $payment_details_id::BIGINT, zsi_id = $zsi_id::BIGINT WHERE id = $id::BIGINT",
-        "selectNextId": "SELECT nextval('orders.orders_id'::regclass)",
-        "count": "SELECT COUNT (*) AS TOTAL_ROWS FROM orders.orders as o JOIN orders.statuses as os ON o.id = os.order_id JOIN (SELECT order_id, MAX(id) as max_id FROM orders.statuses GROUP BY order_id) as latest ON os.order_id = latest.order_id AND os.id = latest.max_id $WHERE"
+        "count": "SELECT COUNT (*) AS TOTAL_ROWS FROM orders.orders",
+        "selectNextId": "SELECT nextval('orders.orders_id'::regclass)"
     },
     "ordersProducts": {
-        "selectAll": "SELECT  op.id, order_id, product_id, title, sku, vat, p.file_id, op.net_price  FROM orders.orders_products  WHERE order_id = $order_id::BIGINT",
-        "selectAllActive": "SELECT  op.id, order_id, product_id, title, sku, vat, p.file_id, op.net_price FROM orders.orders_products as op JOIN products as p ON op.product_id = p.id WHERE order_id = $order_id::BIGINT and in_order = true",
+        "selectAll": "SELECT  op.id, order_id, product_id, title, sku, vat, p.file_id, op.net_price FROM orders.orders_products as op JOIN products as p ON op.product_id = p.id",
         "insert": "INSERT INTO orders.orders_products( id, order_id, product_id, net_price ) VALUES ( $id::BIGINT , $order_id::BIGINT, $product_id::BIGINT, $net_price::DOUBLE PRECISION )",
         "selectNextId": "SELECT nextval('orders.orders_products_id'::regclass)",
         "delete": "UPDATE orders.orders_products SET in_order = false WHERE id = $id::BIGINT"
     },
     "statuses": {
         "select": "SELECT s.id, s.order_id, created_at, user_id, s.type as type_id, st.key as type_name FROM orders.statuses as s JOIN orders.status_types as st ON s.type = st.id WHERE s.order_id = $order_id::BIGINT ORDER BY s.id DESC LIMIT 1",
-        "selectAll": "SELECT s.id, s.order_id, created_at, user_id, s.type as type_id, st.key as type_name FROM orders.statuses as s JOIN orders.status_types as st ON s.type = st.id WHERE order_id = $order_id::BIGINT ORDER BY s.id DESC",
         "insert": "INSERT INTO orders.statuses( id, type, order_id, user_id ) VALUES ($id::BIGINT, $type::BIGINT, $order_id::BIGINT, $user_id::BIGINT)",
         "selectNextId": "SELECT nextval('orders.statuses_id'::regclass)"
     },
     "paymentDetails": {
-        "select": "SELECT id, payment_method_id, payment_order_id FROM orders.payment_details  WHERE id = $id::BIGINT",
+        "select": "SELECT * FROM orders.payment_details",
         "insert": "INSERT INTO orders.payment_details(id, payment_method_id, payment_order_id) VALUES ($id::BIGINT, $payment_method_id::BIGINT, $payment_order_id::TEXT)",
         "update": "UPDATE orders.payment_details SET payment_method_id = $payment_method_id::BIGINT, payment_order_id = $payment_order_id::TEXT WHERE id = $id::BIGINT",
         "selectNextId": "SELECT nextval('orders.payment_details_id'::regclass)"
     },
     "files": {
-        "selectId": "SELECT id FROM files.files $WHERE",
-        "selectAll": "SELECT f.id, f.name, f.orginal_name, f.catalog, f.size_kb, f.type, f.created_at FROM files.files as f $WHERE $ORDERBY",
-        "select": "SELECT id, name, orginal_name, catalog, size_kb, type, created_at FROM files.files  WHERE id = $id::BIGINT",
-        "selectForConnection": "SELECT id, name, catalog, type, sequence FROM files.files JOIN files.file_connections ON file_id = id WHERE connection_type = $connection_type::TEXT AND  connection_id = $connection_id::BIGINT ORDER BY sequence",
-        "selectNextId": "SELECT nextval('files.files_id'::regclass)",
+        "select": "SELECT * FROM files.files",
+        "selectId": "SELECT id FROM files.files ",
+        "selectForConnection": "SELECT id, name, catalog, type, sequence FROM files.files JOIN files.file_connections ON file_id = id",
         "insert": "INSERT INTO files.files(  id, name, orginal_name, catalog, size_kb, type, created_at  ) VALUES (  $id::BIGINT, $name::TEXT, $orginal_name::TEXT, $catalog::TEXT, $size_kb::BIGINT, $type::TEXT, now() )",
         "update": "UPDATE files.files SET name = $name::TEXT, orginal_name = $orginal_name::TEXT, catalog = $catalog::TEXT, size_kb = $size_kb::BIGINT, type = $type::TEXT WHERE id = $id::BIGINT ",
-        "count": "SELECT COUNT(*) AS total_rows FROM files.files as f $WHERE ",
-        "delete": "DELETE FROM files.files WHERE id = $id::BIGINT "
+        "count": "SELECT COUNT(*) AS total_rows FROM files.files",
+        "delete": "DELETE FROM files.files WHERE id = $id::BIGINT ",
+        "selectNextId": "SELECT nextval('files.files_id'::regclass)"
     },
     "fileConnections": {
-        "select": "SELECT file_id, sequence FROM files.file_connections WHERE connection_type = $connection_type::BIGINT and connection_id = $connection_id::BIGINT",
-        "selectForFileId": "SELECT * FROM files.file_connections WHERE file_id = $file_id::BIGINT",
+        "select": "SELECT * FROM files.file_connections ",
         "insert": "INSERT INTO files.file_connections( file_id, connection_type, connection_id, sequence) VALUES ($file_id::BIGINT, $connection_type::TEXT, $connection_id::BIGINT, $sequence::BIGINT)",
-        "delete": "DELETE FROM files.file_connections WHERE file_id = $file_id::BIGINT",
-        "deleteForConnection": "DELETE FROM files.file_connections WHERE connection_type = $connection_type::TEXT AND connection_id = $connection_id::BIGINT"
+        "delete": "DELETE FROM files.file_connections WHERE id = $id::BIGINT"
     },
     "paymentMethods": {
-        "select": "SELECT * FROM settings.payment_methods WHERE id = $id::BIGINT",
-        "selectAll": "SELECT * FROM settings.payment_methods ORDER BY id",
-        "selectAllActive": "SELECT * FROM settings.payment_methods WHERE active=true ORDER BY id",
+        "select": "SELECT * FROM settings.payment_methods",
         "insert": "INSERT INTO settings.payment_methods(id, key, active) VALUES ( $id::BIGINT, $key::TEXT, $active::BOOL)",
         "update": "UPDATE settings.payment_methods SET  id = $id::BIGINT, key = $key::TEXT, active = $active::BOOL WHERE id = $id::BIGINT",
         "selectNextId": "SELECT nextval('settings.payment_methods_id'::regclass)"
     },
     "deliveryMethods": {
-        "select": "SELECT * FROM settings.delivery_methods WHERE id = $id::BIGINT",
-        "selectAll": "SELECT * FROM settings.delivery_methods ORDER BY id",
-        "selectAllActive": "SELECT * FROM settings.delivery_methods WHERE active=true ORDER BY id",
+        "select": "SELECT * FROM settings.delivery_methods",
         "insert": "INSERT INTO settings.delivery_methods(id, key, active) VALUES ( $id::BIGINT, $key::TEXT, $active::BOOL)",
         "update": "UPDATE settings.delivery_methods SET  id = $id::BIGINT, key = $key::TEXT, active = $active::BOOL WHERE id = $id::BIGINT",
         "selectNextId": "SELECT nextval('settings.delivery_methods_id'::regclass)"
     },
     "paymentStatusTypes": {
-        "select": "SELECT * FROM orders.payment_status_types WHERE id = $id::BIGINT"
+        "select": "SELECT * FROM orders.payment_status_types"
     },
     "deliveryStatusTypes": {
-        "select": "SELECT * FROM personal_information.delivery_status_types WHERE id = $id::BIGINT"
+        "select": "SELECT * FROM personal_information.delivery_status_types"
     },
     "deliveryStatuses": {
-        "select": "SELECT * FROM personal_information.delivery_statuses WHERE delivery_details_id = $delivery_details_id::BIGINT ORDER BY id DESC LIMIT 1",
-        "selectAll": "SELECT * FROM personal_information.delivery_statuses WHERE delivery_details_id = $delivery_details_id::BIGINT ORDER BY id DESC",
+        "select": "SELECT * FROM personal_information.delivery_statuses",
         "insert": "INSERT INTO personal_information.delivery_statuses( id, delivery_details_id, delivery_status_type_id, user_id ) VALUES ($id::BIGINT, $delivery_details_id::BIGINT, $delivery_status_type_id::BIGINT, $user_id::BIGINT)",
         "selectNextId": "SELECT nextval('personal_information.delivery_statuses_id'::regclass)"
     },
     "paymentStatuses": {
-        "select": "SELECT * FROM orders.payment_statuses WHERE payment_details_id = $payment_details_id::BIGINT ORDER BY id DESC LIMIT 1",
-        "selectAll": "SELECT * FROM orders.payment_statuses WHERE payment_details_id = $payment_details_id::BIGINT ORDER BY id DESC",
+        "select": "SELECT * FROM orders.payment_statuses",
         "insert": "INSERT INTO orders.payment_statuses( id, payment_details_id, payment_status_type_id ) VALUES ($id::BIGINT, $payment_details_id::BIGINT, $payment_status_type_id::BIGINT)",
         "selectNextId": "SELECT nextval('orders.payment_statuses_id'::regclass)"
     },
@@ -155,7 +135,7 @@
         "select": "SELECT * FROM orders.status_types"
     },
     "companyData": {
-        "select": "SELECT * FROM settings.company_data ORDER BY id DESC LIMIT 1",
+        "select": "SELECT * FROM settings.company_data",
         "insert": "INSERT INTO settings.company_data(id, name, tax_number, email, phone_number, address_id) VALUES ( $id::BIGINT, $name::TEXT, $tax_number::TEXT, $email::TEXT, $phone_number::TEXT, $address_id::BIGINT )",
         "update": "UPDATE settings.company_data SET  id = $id::BIGINT, name = $name::TEXT , email = LOWER($email::TEXT), phone_number = $phone_number::TEXT, tax_number = $tax_number::TEXT WHERE id = $id::BIGINT",
         "selectNextId": "SELECT nextval('settings.company_data_id'::regclass)"

package/dist/reader/AddressesReader.d.ts

@@ -1,6 +1,6 @@
+import { QueryOptions } from "@dascompany/database";
 import AddressI from "../types/AddressI";
 export default class AddressesReader {
-    static get(addressId: number): Promise<AddressI>;
-    static getCompanyAddress(): Promise<AddressI>;
+    static get(queryOptions: QueryOptions): Promise<AddressI>;
     private static getCorrectData;
 }

package/dist/reader/AddressesReader.js

@@ -1,11 +1,7 @@
 import DatabaseConnection from "../DatabaseConnection";
 export default class AddressesReader {
-    static async get(addressId) {
-        const address = await DatabaseConnection.getInstance().addresses.select(addressId);
-        return this.getCorrectData(address);
-    }
-    static async getCompanyAddress() {
-        const address = await DatabaseConnection.getInstance().addresses.select(1);
+    static async get(queryOptions) {
+        const address = await DatabaseConnection.getInstance().addresses.select(queryOptions);
         return this.getCorrectData(address);
     }
     static getCorrectData(address) {

package/dist/reader/AdminReader.d.ts

@@ -1,9 +1,9 @@
-import { QueryOptionsI } from "@dascompany/database";
+import { QueryOptions } from "@dascompany/database";
 import AdminI from "../types/AdminI";
 export default class AdminReader {
-    static get(accountId: number): Promise<AdminI>;
-    static getIdForEmail(email: string): Promise<number>;
-    static getAll(queryOptions: QueryOptionsI): Promise<{
+    static get(queryOptions: QueryOptions): Promise<AdminI>;
+    static getId(queryOptions: QueryOptions): Promise<number>;
+    static getAll(queryOptions: QueryOptions): Promise<{
         adminAccounts: AdminI[];
         quantity: number;
     }>;

package/dist/reader/AdminReader.js

@@ -1,11 +1,11 @@
 import DatabaseConnection from "../DatabaseConnection";
 export default class AdminReader {
-    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.correctAdmin(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);

package/dist/reader/ClientAccountReader.d.ts

@@ -1,13 +1,12 @@
 import { QueryOptions } from "@dascompany/database";
 import ClientAccountI from "../types/ClientAccountI";
 export default class ClientAccountReader {
-    static get(accountId: number): Promise<ClientAccountI>;
+    static get(queryOptions: QueryOptions): Promise<ClientAccountI>;
     static getAll(queryOptions: QueryOptions): Promise<{
         clientAccounts: ClientAccountI[];
         quantity: number;
     }>;
-    static getForEmail(email: string): Promise<ClientAccountI>;
-    static getIdForEmail(email: string): Promise<number>;
+    static getId(queryOptions: QueryOptions): Promise<number | null>;
     private static correctClientsFromRows;
     private static correctData;
 }

package/dist/reader/ClientAccountReader.js

@@ -1,7 +1,7 @@
 import DatabaseConnection from "../DatabaseConnection";
 export default class ClientAccountReader {
-    static async get(accountId) {
-        const account = await DatabaseConnection.getInstance().clientAccounts.select(accountId);
+    static async get(queryOptions) {
+        const account = await DatabaseConnection.getInstance().clientAccounts.select(queryOptions);
         return this.correctData(account);
     }
     static async getAll(queryOptions) {
@@ -12,12 +12,8 @@ export default class ClientAccountReader {
             quantity
         };
     }
-    static async getForEmail(email) {
-        const account = await DatabaseConnection.getInstance().clientAccounts.selectForEmail(email);
-        return this.correctData(account);
-    }
-    static async getIdForEmail(email) {
-        const accountId = await DatabaseConnection.getInstance().clientAccounts.getIdForEmail(email);
+    static async getId(queryOptions) {
+        const accountId = await DatabaseConnection.getInstance().clientAccounts.selectId(queryOptions);
         return accountId;
     }
     static correctClientsFromRows(dataRows) {

package/dist/reader/CompanyDataReader.js

@@ -1,10 +1,13 @@
+import { ParameterType, QueryOptions } from "@dascompany/database";
 import DatabaseConnection from "../DatabaseConnection";
 import AddressesReader from "./AddressesReader";
 export default class CompanyDataReader {
     static async get() {
         const companyData = await DatabaseConnection.getInstance().companyData.select();
         if (companyData) {
-            const address = companyData?.address_id ? await AddressesReader.get(companyData.address_id) : null;
+            const queryOptions = new QueryOptions();
+            queryOptions.setWhere([{ name: 'id', type: ParameterType.bigint, value: companyData.address_id }]);
+            const address = companyData?.address_id ? await AddressesReader.get(queryOptions) : null;
             return {
                 id: companyData.id,
                 name: companyData.name,

package/dist/reader/CompanyDetailsReader.d.ts

@@ -1,4 +1,5 @@
+import { QueryOptions } from "@dascompany/database";
 import CompanyDetailsI from "../types/CompanyDetailsI";
 export default class CompanyDetailsReader {
-    static get(companyDetailsId: number): Promise<CompanyDetailsI>;
+    static get(queryOptions: QueryOptions): Promise<CompanyDetailsI>;
 }

package/dist/reader/CompanyDetailsReader.js

@@ -1,7 +1,7 @@
 import DatabaseConnection from "../DatabaseConnection";
 export default class CompanyDetailsReader {
-    static async get(companyDetailsId) {
-        const companyDetails = await DatabaseConnection.getInstance().companyDetails.select(companyDetailsId);
+    static async get(queryOptions) {
+        const companyDetails = await DatabaseConnection.getInstance().companyDetails.select(queryOptions);
         if (companyDetails)
             return {
                 id: companyDetails.id,
@@ -9,6 +9,6 @@ export default class CompanyDetailsReader {
                 taxNumber: companyDetails.tax_number
             };
         else
-            throw Error(`no companyDetails found for id: ${companyDetailsId}`);
+            throw Error(`no companyDetails found with queryOptions: ${queryOptions}`);
     }
 }

package/dist/reader/ContactDetailsReader.d.ts

@@ -1,4 +1,5 @@
+import { QueryOptions } from "@dascompany/database";
 import ContactDetailsI from "../types/ContactDetailsI";
 export default class ContactDetailsReader {
-    static get(contactDetailsId: number): Promise<ContactDetailsI>;
+    static get(queryOptions: QueryOptions): Promise<ContactDetailsI>;
 }

package/dist/reader/ContactDetailsReader.js

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

package/dist/reader/DeliveryDetailsReader.d.ts

@@ -1,4 +1,5 @@
+import { QueryOptions } from "@dascompany/database";
 import DeliveryDetailsI from "../types/DeliveryDetailsI";
 export default class DeliveryDetailsReader {
-    static get(deliveryDetailsId: number): Promise<DeliveryDetailsI>;
+    static get(queryOptions: QueryOptions): Promise<DeliveryDetailsI>;
 }

package/dist/reader/DeliveryDetailsReader.js

@@ -1,20 +1,30 @@
+import { ParameterType, QueryOptions } from "@dascompany/database";
 import DatabaseConnection from "../DatabaseConnection";
 import AddressesReader from "./AddressesReader";
 import DeliveryMethodReader from "./DeliveryMethodReader";
 import PersonalDataReader from "./PersonalDataReader";
 export default class DeliveryDetailsReader {
-    static async get(deliveryDetailsId) {
-        const deliveryDetails = await DatabaseConnection.getInstance().deliveryDetails.select(deliveryDetailsId);
+    static async get(queryOptions) {
+        const deliveryDetails = await DatabaseConnection.getInstance().deliveryDetails.select(queryOptions);
         const id = deliveryDetails.id;
         let personalData = null;
         let address = null;
         let deliveryMethod = null;
-        if (deliveryDetails.personal_data_id)
-            personalData = await PersonalDataReader.get(deliveryDetails.personal_data_id);
-        if (deliveryDetails.address_id)
-            address = await AddressesReader.get(deliveryDetails.address_id);
-        if (deliveryDetails.delivery_method_id)
-            deliveryMethod = await DeliveryMethodReader.get(deliveryDetails.delivery_method_id);
+        if (deliveryDetails.personal_data_id) {
+            const queryOptionsPersonalData = new QueryOptions();
+            queryOptionsPersonalData.setWhere([{ name: 'id', type: ParameterType.bigint, value: deliveryDetails.personal_data_id }]);
+            personalData = await PersonalDataReader.get(queryOptionsPersonalData);
+        }
+        if (deliveryDetails.address_id) {
+            const queryOptionsAddress = new QueryOptions();
+            queryOptionsAddress.setWhere([{ name: 'id', type: ParameterType.bigint, value: deliveryDetails.address_id }]);
+            address = await AddressesReader.get(queryOptionsAddress);
+        }
+        if (deliveryDetails.delivery_method_id) {
+            const queryOptionsDeliveryMethod = new QueryOptions();
+            queryOptionsDeliveryMethod.setWhere([{ name: 'id', type: ParameterType.bigint, value: deliveryDetails.delivery_method_id }]);
+            deliveryMethod = await DeliveryMethodReader.get(queryOptionsDeliveryMethod);
+        }
         return {
             id,
             personalData,

package/dist/reader/DeliveryMethodReader.d.ts

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

package/dist/reader/DeliveryMethodReader.js

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

package/dist/reader/DeliveryStatusReader.d.ts

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

package/dist/reader/DeliveryStatusReader.js

@@ -1,14 +1,15 @@
+import { ParameterType, QueryOptions } from "@dascompany/database";
 import DatabaseConnection from "../DatabaseConnection";
 export default class DeliveryStatusReader {
-    static async get(deliveryDetailsId) {
-        const deliveryStatus = await DatabaseConnection.getInstance().deliveryStatuses.select(deliveryDetailsId);
+    static async get(queryOptions) {
+        const deliveryStatus = await DatabaseConnection.getInstance().deliveryStatuses.select(queryOptions);
         if (deliveryStatus)
             return await this.correctDeliveryStatus(deliveryStatus);
         else
             return {};
     }
-    static async getAll(deliveryDetailsId) {
-        const deliveryStatusesData = await DatabaseConnection.getInstance().deliveryStatuses.selectAll(deliveryDetailsId);
+    static async getAll(queryOptions) {
+        const deliveryStatusesData = await DatabaseConnection.getInstance().deliveryStatuses.selectAll(queryOptions);
         const deliveryStatuses = [];
         for (let i = 0; i < deliveryStatusesData.length; i++) {
             const deliveryStatus = await this.correctDeliveryStatus(deliveryStatusesData[i]);
@@ -17,7 +18,9 @@ export default class DeliveryStatusReader {
         return deliveryStatuses;
     }
     static async correctDeliveryStatus(deliveryStatus) {
-        const deliveryStatusType = await DatabaseConnection.getInstance().deliveryStatusTypes.select(deliveryStatus.delivery_status_type_id);
+        const queryOptions = new QueryOptions();
+        queryOptions.setWhere([{ name: 'id', type: ParameterType.bigint, value: deliveryStatus.delivery_status_type_id }]);
+        const deliveryStatusType = await DatabaseConnection.getInstance().deliveryStatusTypes.select(queryOptions);
         return {
             id: deliveryStatus.id,
             type: deliveryStatusType,

package/dist/reader/FileConnectionsReader.d.ts

@@ -1,6 +1,7 @@
+import { QueryOptions } from "@dascompany/database";
 import FileConnectionI from "../types/FileConnectionI";
 export default class FileConnectionsReader {
-    static getAllForFileId(fileId: number): Promise<FileConnectionI[]>;
+    static getAll(queryOptions: QueryOptions): Promise<FileConnectionI[]>;
     private static correctFileConnections;
     private static correctFileConnection;
 }

package/dist/reader/FileConnectionsReader.js

@@ -1,7 +1,7 @@
 import DatabaseConnection from "../DatabaseConnection";
 export default class FileConnectionsReader {
-    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 correctFileConnections(fileConnectionsRows) {

package/dist/reader/FilesReader.d.ts

@@ -1,12 +1,11 @@
-import { QueryOptionsI } from "@dascompany/database";
-import FileConnectionTypeE from "../types/FileConnectionTypeE";
+import { QueryOptions } from "@dascompany/database";
 import FileI from "../types/FileI";
 export default class FilesReader {
-    static get(fileId: number): Promise<FileI>;
-    static getAll(queryOptions: QueryOptionsI): Promise<FileI[]>;
-    static isExist(queryOptions: QueryOptionsI): Promise<number>;
+    static get(queryOptions: QueryOptions): Promise<FileI>;
+    static getAll(queryOptions: QueryOptions): Promise<FileI[]>;
+    static getId(queryOptions: QueryOptions): Promise<number>;
     static getQuantity(queryOptions: any): Promise<number>;
-    static getForConnection(connectionType: FileConnectionTypeE, connectionId: number): Promise<FileI[]>;
+    static getForConnection(queryOptions: QueryOptions): Promise<FileI[]>;
     private static correctFiles;
     private static correctFile;
 }

package/dist/reader/FilesReader.js

@@ -1,14 +1,14 @@
 import DatabaseConnection from "../DatabaseConnection";
 export default class FilesReader {
-    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.correctFile(file);
     }
     static async getAll(queryOptions) {
         const file = await DatabaseConnection.getInstance().files.selectAll(queryOptions);
         return this.correctFiles(file);
     }
-    static async isExist(queryOptions) {
+    static async getId(queryOptions) {
         const fileId = await DatabaseConnection.getInstance().files.selectId(queryOptions);
         return fileId;
     }
@@ -16,8 +16,8 @@ export default class FilesReader {
         const quantity = await DatabaseConnection.getInstance().files.count(queryOptions);
         return quantity;
     }
-    static async getForConnection(connectionType, connectionId) {
-        const files = await DatabaseConnection.getInstance().files.selectForConnection(connectionType, connectionId);
+    static async getForConnection(queryOptions) {
+        const files = await DatabaseConnection.getInstance().files.selectForConnection(queryOptions);
         return this.correctFiles(files);
     }
     static correctFiles(fileRows) {

package/dist/reader/InvoiceDetailsReader.d.ts

@@ -1,4 +1,5 @@
+import { QueryOptions } from "@dascompany/database";
 import InvoiceDetailsI from "../types/InvoiceDetailsI";
 export default class InvoiceDetailsReader {
-    static get(invoiceDetailsId: number): Promise<InvoiceDetailsI>;
+    static get(queryOptions: QueryOptions): Promise<InvoiceDetailsI>;
 }