@dascompany/database 0.0.8 → 1.0.0

package/dist/SQL.json

@@ -40,8 +40,6 @@
     },
     "addresses": {
         "select": "SELECT id, country, city, postal_code, street, house_number, apartment_number FROM personal_information.addresses WHERE id = $id::BIGINT",
-        "selectTypes": "SELECT type FROM personal_information.addresses WHERE account_id = $account_id::BIGINT",
-        "selectId": "SELECT id FROM personal_information.addresses WHERE account_id = $account_id::BIGINT AND type = $type::SMALLINT",
         "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)"
@@ -57,20 +55,18 @@
         "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",
-        "selectIfIs": "SELECT FROM personal_information.company_details WHERE id = $id::BIGINT",
         "selectNextId": "SELECT nextval('personal_information.company_details_id'::regclass)"
     },
     "products": {
         "select": "SELECT id, sku, url, title, description,  net_price, vat, color, quantity, width, height, length, file_id, created_at, deleted FROM products WHERE id = $id::BIGINT",
-        "selectAll": "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",
-        "selectListForOrder": "SELECT id, title, sku, file_id, net_price FROM products WHERE deleted = false",
+        "selectForUrl": "SELECT id, sku, url, title, description, net_price, vat, color, quantity, width, height, length, file_id, created_at, deleted 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",
         "insert": "INSERT INTO products( id, sku, url, title, description, net_price, vat, color, quantity, width, length, height, file_id, 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 ,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  WHERE id = $id::BIGINT",
+        "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  WHERE id = $id::BIGINT",
         "delete": "UPDATE products SET deleted = true WHERE id = $id::BIGINT",
-        "restore": "UPDATE products SET deleted = false WHERE id = $id::BIGINT",
-        "selectForSku": "SELECT * FROM products WHERE LOWER( sku ) = LOWER($sku::TEXT)",
-        "selectForUrl": "SELECT id, sku, url, title, description, net_price, vat, color, quantity, width, height, length, file_id, created_at, deleted FROM products WHERE LOWER( url ) = LOWER($url::TEXT)",
         "selectNextId": "SELECT nextval('product_id'::regclass)",
         "count": "SELECT COUNT(*) AS total_rows FROM products WHERE deleted = false $PARAMS"
     },
@@ -84,18 +80,15 @@
         "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"
     },
     "ordersProducts": {
-        "selectProducts": "SELECT op.id, order_id, product_id, title, sku, 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",
-        "select": "SELECT id, order_id, product_id, in_order FROM orders.orders_products  WHERE order_id = $order_id::BIGINT AND in_order = true",
-        "selectAll": "SELECT * FROM orders.orders_products $WHERE",
-        "getAllActiveForOrderId": "SELECT * FROM orders.orders_products 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  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",
         "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": {
-        "selectLatest": "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",
-        "selectForOrder": "SELECT s.id, order_id, created_at, user_id, st.key as type 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 LIMIT 1",
-        "selectAllForOrder": "SELECT s.id, order_id, created_at, user_id, st.key as type 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",
+        "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)"
     },
@@ -109,7 +102,7 @@
         "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 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",
+        "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)",
         "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 ",

package/dist/index.d.ts

@@ -1,71 +1,91 @@
 import DatabaseConnection from "./DatabaseConnection";
 import StockObject from "./types/StockObject";
 import StockObjectMapper from "./types/StockObjectMapper";
-import AddressesReader from "./reader/AddressesReader";
+import Table from "./Table";
+import Query from "./query/Query";
+import TableConnection from './TableConnection';
+import ParameterType from './types/parameters/ParameterType';
+import ParameterFilter from './types/parameters/ParameterFilter';
+import ConnectorE from './types/ConnectorE';
+import ParameterI from './types/ParameterI';
+import QueryOptionsI from './types/QueryOptionsI';
+import ResultLimitationI from './types/ResultLimitationI';
+import Parameters from './utils/Parameters';
+import OrderByI from "./utils/OrderByI";
+import QueryOptions from './query/QueryOptions';
+import Client from "./stockObjects/Client";
+import ClientAccountRepo from "./repo/ClientAccountRepo";
 import ClientAccountReader from "./reader/ClientAccountReader";
-import CompanyDetailsReader from "./reader/CompanyDetailsReader";
-import ContactDetailsReader from "./reader/ContactDetailsReader";
-import DeliveryDetailsReader from "./reader/DeliveryDetailsReader";
-import DeliveryMethodReader from "./reader/DeliveryMethodReader";
-import InvoiceDetailsReader from "./reader/InvoiceDetailsReader";
-import OrderProductsReader from "./reader/OrderProductsReader";
-import OrderReader from "./reader/OrderReader";
-import FilesReader from './reader/FilesReader';
-import OrderStatusReader from "./reader/OrderStatusReader";
-import OrderStatusRepo from "./repo/OrderStatusRepo";
-import PaymentDetailsReader from "./reader/payment/PaymentDetailsReader";
-import PaymentMethodReader from "./reader/payment/PaymentMethodReader";
-import PaymentStatusesReader from "./reader/payment/PaymentStatusesReader";
-import PersonalDataReader from "./reader/PersonalDataReader";
-import ProductReader from "./reader/ProductReader";
+import Admin from "./stockObjects/Admin";
+import AdminRepo from './repo/AdminRepo';
+import Address from "./stockObjects/Address";
+import AddressI from "./types/AddressI";
 import AddressesRepo from "./repo/AddressesRepo";
-import ClientAccountRepo from "./repo/ClientAccountRepo";
-import CompanyDetailsRepo from "./repo/CompanyDetailsRepo";
-import CompanyDataRepo from "./repo/CompanyDataRepo";
-import ContactDetailsRepo from "./repo/ContactDetailsRepo";
-import DeliveryDetailsRepo from "./repo/DeliveryDetailsRepo";
-import InvoiceDetailsRepo from "./repo/InvoiceDetailsRepo";
-import OrderRepo from "./repo/OrderRepo";
-import PaymentDetailsRepo from "./repo/PaymentDetailsRepo";
+import AddressesReader from "./reader/AddressesReader";
+import PersonalData from "./stockObjects/PersonalData";
 import PersonalDataRepo from "./repo/PersonalDataRepo";
-import PaymentMethodRepo from './repo/PaymentMethodRepo';
-import ProductRepo from "./repo/ProductRepo";
-import Address from "./stockObjects/Address";
-import Admin from "./stockObjects/Admin";
+import PersonalDataReader from "./reader/PersonalDataReader";
+import PersonalDataI from "./types/PersonalDataI";
 import CompanyDetails from "./stockObjects/CompanyDetails";
+import CompanyDetailsRepo from "./repo/CompanyDetailsRepo";
+import CompanyDetailsReader from "./reader/CompanyDetailsReader";
+import CompanyDetailsI from "./types/CompanyDetailsI";
 import ContactDetails from "./stockObjects/ContactDetails";
+import ContactDetailsRepo from "./repo/ContactDetailsRepo";
+import ContactDetailsReader from "./reader/ContactDetailsReader";
+import ContactDetailsI from "./types/ContactDetailsI";
 import DeliveryDetails from "./stockObjects/DeliveryDetails";
+import DeliveryDetailsRepo from "./repo/DeliveryDetailsRepo";
+import DeliveryDetailsReader from "./reader/DeliveryDetailsReader";
+import DeliveryDetailsI from "./types/DeliveryDetailsI";
+import DeliveryMethods from "./stockObjects/DeliveryMethods";
+import DeliveryMethodRepo from './repo/DeliveryMethodRepo';
+import DeliveryMethodReader from "./reader/DeliveryMethodReader";
+import DeliveryMethodI from "./types/DeliveryMethodI";
 import DeliveryStatus from "./stockObjects/DeliveryStatus";
+import DeliveryStatusReader from './reader/DeliveryStatusReader';
 import InvoiceDetails from "./stockObjects/InvoiceDetails";
-import Order from "./stockObjects/Order";
-import OrderProduct from "./stockObjects/OrderProduct";
+import InvoiceDetailsRepo from "./repo/InvoiceDetailsRepo";
+import InvoiceDetailsReader from "./reader/InvoiceDetailsReader";
+import InvoiceDetailsI from "./types/InvoiceDetailsI";
 import PaymentDetails from "./stockObjects/PaymentDetails";
+import PaymentDetailsRepo from "./repo/PaymentDetailsRepo";
+import PaymentDetailsReader from "./reader/payment/PaymentDetailsReader";
+import PaymentDetailsI from "./types/PaymentDetailsI";
+import PaymentMethods from "./stockObjects/PaymentMethods";
+import PaymentMethodRepo from './repo/PaymentMethodRepo';
+import PaymentMethodReader from "./reader/payment/PaymentMethodReader";
+import PaymentMethodE from "./types/PaymentMethodE";
+import PaymentMethodI from "./types/PaymentMethodI";
 import PaymentStatus from "./stockObjects/PaymentStatus";
-import PersonalData from "./stockObjects/PersonalData";
-import Product from "./stockObjects/Product";
-import Status from "./stockObjects/Status";
-import Client from "./stockObjects/Client";
-import AdminRepo from './repo/AdminRepo';
-import TableConnection from './TableConnection';
-import ParameterType from './types/parameters/ParameterType';
-import DeliveryStatusReader from './reader/DeliveryStatusReader';
-import ConnectorE from './types/ConnectorE';
-import ParameterI from './types/ParameterI';
-import QueryOptionsI from './types/QueryOptionsI';
-import ResultLimitationI from './types/ResultLimitationI';
-import ParameterFilter from './types/parameters/ParameterFilter';
+import PaymentStatusesReader from "./reader/payment/PaymentStatusesReader";
 import PaymentStatusE from './types/PaymentStatusE';
+import Order from "./stockObjects/Order";
+import OrderRepo from "./repo/OrderRepo";
+import OrderReader from "./reader/OrderReader";
+import OrderProduct from "./stockObjects/OrderProduct";
+import OrderProductsRepo from "./repo/OrderProductsRepo";
+import OrderProductsReader from "./reader/OrderProductsReader";
 import OrderProductI from './types/OrderProductI';
-import Parameters from './utils/Parameters';
-import DeliveryMethodRepo from './repo/DeliveryMethodRepo';
-import StatusTypesReader from './reader/StatusTypesReader';
-import FileConnectionsReader from "./reader/FileConnectionsReader";
-import FileConnectionsRepo from "./repo/FileConnectionsRepo";
-import CompanyDataReader from "./reader/CompanyDataReader";
-import OrderByI from "./utils/OrderByI";
-import FilesRepo from './repo/FilesRepo';
+import Status from "./stockObjects/Status";
+import OrderStatusRepo from "./repo/OrderStatusRepo";
+import OrderStatusReader from "./reader/OrderStatusReader";
+import StatusI from "./types/StatusI";
+import ProductI from './types/ProductI';
+import Product from "./stockObjects/Product";
+import ProductRepo from "./repo/ProductRepo";
+import ProductReader from "./reader/ProductReader";
 import File from './stockObjects/File';
-import QueryOptions from './query/QueryOptions';
-import OrderProductsRepo from "./repo/OrderProductsRepo";
+import FilesRepo from './repo/FilesRepo';
+import FilesReader from './reader/FilesReader';
+import FileI from "./types/FileI";
+import FileConnection from "./stockObjects/FileConnection";
+import FileConnectionsRepo from "./repo/FileConnectionsRepo";
+import FileConnectionsReader from "./reader/FileConnectionsReader";
 import FileConnectionTypeE from './types/FileConnectionTypeE';
-export { TableConnection, StockObject, StockObjectMapper, DatabaseConnection, File, OrderByI, ParameterType, ConnectorE, FileConnectionTypeE, PaymentStatusE, Parameters, ParameterI, QueryOptions, QueryOptionsI, ResultLimitationI, OrderProductI, ParameterFilter, PaymentDetailsReader, FilesReader, PaymentMethodReader, DeliveryStatusReader, PaymentStatusesReader, AddressesReader, ClientAccountReader, CompanyDetailsReader, ContactDetailsReader, DeliveryDetailsReader, DeliveryMethodReader, InvoiceDetailsReader, OrderProductsReader, OrderReader, OrderStatusReader, PersonalDataReader, ProductReader, StatusTypesReader, FileConnectionsReader, CompanyDataReader, DeliveryMethodRepo, AdminRepo, PaymentDetailsRepo, AddressesRepo, ClientAccountRepo, CompanyDetailsRepo, ContactDetailsRepo, DeliveryDetailsRepo, CompanyDataRepo, InvoiceDetailsRepo, OrderRepo, PersonalDataRepo, PaymentMethodRepo, ProductRepo, FileConnectionsRepo, FilesRepo, OrderProductsRepo, OrderStatusRepo, Address, Admin, Client, CompanyDetails, ContactDetails, DeliveryDetails, InvoiceDetails, DeliveryStatus, Order, OrderProduct, PaymentDetails, PaymentStatus, PersonalData, Product, Status, };
+import CompanyData from "./stockObjects/CompanyData";
+import CompanyDataRepo from "./repo/CompanyDataRepo";
+import CompanyDataReader from "./reader/CompanyDataReader";
+import CompanyDataI from "./types/CompanyDataI";
+import StatusTypesReader from './reader/StatusTypesReader';
+export { DatabaseConnection, StockObject, StockObjectMapper, Table, Query, TableConnection, ParameterType, ParameterFilter, ConnectorE, ParameterI, QueryOptionsI, ResultLimitationI, Parameters, OrderByI, QueryOptions, Client, ClientAccountRepo, ClientAccountReader, Admin, AdminRepo, Address, AddressI, AddressesRepo, AddressesReader, PersonalData, PersonalDataRepo, PersonalDataReader, PersonalDataI, CompanyDetails, CompanyDetailsRepo, CompanyDetailsReader, CompanyDetailsI, ContactDetails, ContactDetailsRepo, ContactDetailsReader, ContactDetailsI, DeliveryDetails, DeliveryDetailsRepo, DeliveryDetailsReader, DeliveryDetailsI, DeliveryMethods, DeliveryMethodRepo, DeliveryMethodReader, DeliveryMethodI, DeliveryStatus, DeliveryStatusReader, InvoiceDetails, InvoiceDetailsRepo, InvoiceDetailsReader, InvoiceDetailsI, PaymentDetails, PaymentDetailsRepo, PaymentDetailsReader, PaymentDetailsI, PaymentMethods, PaymentMethodRepo, PaymentMethodReader, PaymentMethodE, PaymentMethodI, PaymentStatus, PaymentStatusesReader, PaymentStatusE, Order, OrderRepo, OrderReader, OrderProduct, OrderProductsRepo, OrderProductsReader, OrderProductI, Status, OrderStatusRepo, OrderStatusReader, StatusI, ProductI, Product, ProductRepo, ProductReader, File, FilesRepo, FilesReader, FileI, FileConnection, FileConnectionsRepo, FileConnectionsReader, FileConnectionTypeE, CompanyData, CompanyDataRepo, CompanyDataReader, CompanyDataI, StatusTypesReader, };

package/dist/index.js

@@ -1,64 +1,71 @@
 import DatabaseConnection from "./DatabaseConnection";
 import StockObject from "./types/StockObject";
-import AddressesReader from "./reader/AddressesReader";
+import Table from "./Table";
+import Query from "./query/Query";
+import TableConnection from './TableConnection';
+import ParameterType from './types/parameters/ParameterType';
+import ConnectorE from './types/ConnectorE';
+import Parameters from './utils/Parameters';
+import QueryOptions from './query/QueryOptions';
+import Client from "./stockObjects/Client";
+import ClientAccountRepo from "./repo/ClientAccountRepo";
 import ClientAccountReader from "./reader/ClientAccountReader";
+import Admin from "./stockObjects/Admin";
+import AdminRepo from './repo/AdminRepo';
+import Address from "./stockObjects/Address";
+import AddressesRepo from "./repo/AddressesRepo";
+import AddressesReader from "./reader/AddressesReader";
+import PersonalData from "./stockObjects/PersonalData";
+import PersonalDataRepo from "./repo/PersonalDataRepo";
+import PersonalDataReader from "./reader/PersonalDataReader";
+import CompanyDetails from "./stockObjects/CompanyDetails";
+import CompanyDetailsRepo from "./repo/CompanyDetailsRepo";
 import CompanyDetailsReader from "./reader/CompanyDetailsReader";
+import ContactDetails from "./stockObjects/ContactDetails";
+import ContactDetailsRepo from "./repo/ContactDetailsRepo";
 import ContactDetailsReader from "./reader/ContactDetailsReader";
+import DeliveryDetails from "./stockObjects/DeliveryDetails";
+import DeliveryDetailsRepo from "./repo/DeliveryDetailsRepo";
 import DeliveryDetailsReader from "./reader/DeliveryDetailsReader";
+import DeliveryMethods from "./stockObjects/DeliveryMethods";
+import DeliveryMethodRepo from './repo/DeliveryMethodRepo';
 import DeliveryMethodReader from "./reader/DeliveryMethodReader";
+import DeliveryStatus from "./stockObjects/DeliveryStatus";
+import DeliveryStatusReader from './reader/DeliveryStatusReader';
+import InvoiceDetails from "./stockObjects/InvoiceDetails";
+import InvoiceDetailsRepo from "./repo/InvoiceDetailsRepo";
 import InvoiceDetailsReader from "./reader/InvoiceDetailsReader";
-import OrderProductsReader from "./reader/OrderProductsReader";
-import OrderReader from "./reader/OrderReader";
-import FilesReader from './reader/FilesReader';
-import OrderStatusReader from "./reader/OrderStatusReader";
-import OrderStatusRepo from "./repo/OrderStatusRepo";
+import PaymentDetails from "./stockObjects/PaymentDetails";
+import PaymentDetailsRepo from "./repo/PaymentDetailsRepo";
 import PaymentDetailsReader from "./reader/payment/PaymentDetailsReader";
+import PaymentMethods from "./stockObjects/PaymentMethods";
+import PaymentMethodRepo from './repo/PaymentMethodRepo';
 import PaymentMethodReader from "./reader/payment/PaymentMethodReader";
+import PaymentMethodE from "./types/PaymentMethodE";
+import PaymentStatus from "./stockObjects/PaymentStatus";
 import PaymentStatusesReader from "./reader/payment/PaymentStatusesReader";
-import PersonalDataReader from "./reader/PersonalDataReader";
-import ProductReader from "./reader/ProductReader";
-import AddressesRepo from "./repo/AddressesRepo";
-import ClientAccountRepo from "./repo/ClientAccountRepo";
-import CompanyDetailsRepo from "./repo/CompanyDetailsRepo";
-import CompanyDataRepo from "./repo/CompanyDataRepo";
-import ContactDetailsRepo from "./repo/ContactDetailsRepo";
-import DeliveryDetailsRepo from "./repo/DeliveryDetailsRepo";
-import InvoiceDetailsRepo from "./repo/InvoiceDetailsRepo";
-import OrderRepo from "./repo/OrderRepo";
-import PaymentDetailsRepo from "./repo/PaymentDetailsRepo";
-import PersonalDataRepo from "./repo/PersonalDataRepo";
-import PaymentMethodRepo from './repo/PaymentMethodRepo';
-import ProductRepo from "./repo/ProductRepo";
-import Address from "./stockObjects/Address";
-import Admin from "./stockObjects/Admin";
-import CompanyDetails from "./stockObjects/CompanyDetails";
-import ContactDetails from "./stockObjects/ContactDetails";
-import DeliveryDetails from "./stockObjects/DeliveryDetails";
-import DeliveryStatus from "./stockObjects/DeliveryStatus";
-import InvoiceDetails from "./stockObjects/InvoiceDetails";
+import PaymentStatusE from './types/PaymentStatusE';
 import Order from "./stockObjects/Order";
+import OrderRepo from "./repo/OrderRepo";
+import OrderReader from "./reader/OrderReader";
 import OrderProduct from "./stockObjects/OrderProduct";
-import PaymentDetails from "./stockObjects/PaymentDetails";
-import PaymentStatus from "./stockObjects/PaymentStatus";
-import PersonalData from "./stockObjects/PersonalData";
-import Product from "./stockObjects/Product";
+import OrderProductsRepo from "./repo/OrderProductsRepo";
+import OrderProductsReader from "./reader/OrderProductsReader";
 import Status from "./stockObjects/Status";
-import Client from "./stockObjects/Client";
-import AdminRepo from './repo/AdminRepo';
-import TableConnection from './TableConnection';
-import ParameterType from './types/parameters/ParameterType';
-import DeliveryStatusReader from './reader/DeliveryStatusReader';
-import ConnectorE from './types/ConnectorE';
-import PaymentStatusE from './types/PaymentStatusE';
-import Parameters from './utils/Parameters';
-import DeliveryMethodRepo from './repo/DeliveryMethodRepo';
-import StatusTypesReader from './reader/StatusTypesReader';
-import FileConnectionsReader from "./reader/FileConnectionsReader";
-import FileConnectionsRepo from "./repo/FileConnectionsRepo";
-import CompanyDataReader from "./reader/CompanyDataReader";
-import FilesRepo from './repo/FilesRepo';
+import OrderStatusRepo from "./repo/OrderStatusRepo";
+import OrderStatusReader from "./reader/OrderStatusReader";
+import Product from "./stockObjects/Product";
+import ProductRepo from "./repo/ProductRepo";
+import ProductReader from "./reader/ProductReader";
 import File from './stockObjects/File';
-import QueryOptions from './query/QueryOptions';
-import OrderProductsRepo from "./repo/OrderProductsRepo";
+import FilesRepo from './repo/FilesRepo';
+import FilesReader from './reader/FilesReader';
+import FileConnection from "./stockObjects/FileConnection";
+import FileConnectionsRepo from "./repo/FileConnectionsRepo";
+import FileConnectionsReader from "./reader/FileConnectionsReader";
 import FileConnectionTypeE from './types/FileConnectionTypeE';
-export { TableConnection, StockObject, DatabaseConnection, File, ParameterType, ConnectorE, FileConnectionTypeE, PaymentStatusE, Parameters, QueryOptions, PaymentDetailsReader, FilesReader, PaymentMethodReader, DeliveryStatusReader, PaymentStatusesReader, AddressesReader, ClientAccountReader, CompanyDetailsReader, ContactDetailsReader, DeliveryDetailsReader, DeliveryMethodReader, InvoiceDetailsReader, OrderProductsReader, OrderReader, OrderStatusReader, PersonalDataReader, ProductReader, StatusTypesReader, FileConnectionsReader, CompanyDataReader, DeliveryMethodRepo, AdminRepo, PaymentDetailsRepo, AddressesRepo, ClientAccountRepo, CompanyDetailsRepo, ContactDetailsRepo, DeliveryDetailsRepo, CompanyDataRepo, InvoiceDetailsRepo, OrderRepo, PersonalDataRepo, PaymentMethodRepo, ProductRepo, FileConnectionsRepo, FilesRepo, OrderProductsRepo, OrderStatusRepo, Address, Admin, Client, CompanyDetails, ContactDetails, DeliveryDetails, InvoiceDetails, DeliveryStatus, Order, OrderProduct, PaymentDetails, PaymentStatus, PersonalData, Product, Status, };
+import CompanyData from "./stockObjects/CompanyData";
+import CompanyDataRepo from "./repo/CompanyDataRepo";
+import CompanyDataReader from "./reader/CompanyDataReader";
+import StatusTypesReader from './reader/StatusTypesReader';
+export { DatabaseConnection, StockObject, Table, Query, TableConnection, ParameterType, ConnectorE, Parameters, QueryOptions, Client, ClientAccountRepo, ClientAccountReader, Admin, AdminRepo, Address, AddressesRepo, AddressesReader, PersonalData, PersonalDataRepo, PersonalDataReader, CompanyDetails, CompanyDetailsRepo, CompanyDetailsReader, ContactDetails, ContactDetailsRepo, ContactDetailsReader, DeliveryDetails, DeliveryDetailsRepo, DeliveryDetailsReader, DeliveryMethods, DeliveryMethodRepo, DeliveryMethodReader, DeliveryStatus, DeliveryStatusReader, InvoiceDetails, InvoiceDetailsRepo, InvoiceDetailsReader, PaymentDetails, PaymentDetailsRepo, PaymentDetailsReader, PaymentMethods, PaymentMethodRepo, PaymentMethodReader, PaymentMethodE, PaymentStatus, PaymentStatusesReader, PaymentStatusE, Order, OrderRepo, OrderReader, OrderProduct, OrderProductsRepo, OrderProductsReader, Status, OrderStatusRepo, OrderStatusReader, Product, ProductRepo, ProductReader, File, FilesRepo, FilesReader, FileConnection, FileConnectionsRepo, FileConnectionsReader, FileConnectionTypeE, CompanyData, CompanyDataRepo, CompanyDataReader, StatusTypesReader, };

package/dist/reader/DeliveryDetailsReader.js

@@ -1,7 +1,6 @@
 import DatabaseConnection from "../DatabaseConnection";
 import AddressesReader from "./AddressesReader";
 import DeliveryMethodReader from "./DeliveryMethodReader";
-import DeliveryStatusReader from "./DeliveryStatusReader";
 import PersonalDataReader from "./PersonalDataReader";
 export default class DeliveryDetailsReader {
     static async get(deliveryDetailsId) {
@@ -17,15 +16,11 @@ export default class DeliveryDetailsReader {
             address = await AddressesReader.get(deliveryDetails.address_id);
         if (deliveryDetails.delivery_method_id)
             deliveryMethod = await DeliveryMethodReader.get(deliveryDetails.delivery_method_id);
-        const status = await DeliveryStatusReader.get(deliveryDetails.id);
-        const statuses = await DeliveryStatusReader.getAll(deliveryDetails.id);
         return {
             id,
             personalData,
             address,
-            deliveryMethod,
-            status,
-            statuses,
+            deliveryMethod
         };
     }
 }

package/dist/reader/FilesReader.js

@@ -39,6 +39,7 @@ export default class FilesReader {
             name: file.name,
             catalog: file.catalog,
             type: file.type,
+            createdAt: file.created_at
         };
         return correctFile;
     }

package/dist/reader/OrderProductsReader.d.ts

@@ -1,10 +1,7 @@
 import OrderProductI from "../types/OrderProductI";
 export default class OrderProductsReader {
-    static getForOrder(orderId: number): Promise<any[]>;
     static getAll(orderId: number): Promise<OrderProductI[]>;
+    static getForOrder(orderId: number): Promise<any[]>;
+    private static correctOrderProducts;
     private static correctProduct;
-    static get(orderId: number): Promise<OrderProductI[]>;
-    static getAllForIds(orderProductsIds: number[]): Promise<any[]>;
-    private static correctOrdersProducts;
-    private static correctOrderProduct;
 }

package/dist/reader/OrderProductsReader.js

@@ -1,13 +1,16 @@
 import DatabaseConnection from "../DatabaseConnection";
-import ConnectorE from "../types/ConnectorE";
-import ParameterType from "../types/parameters/ParameterType";
 import calculateNetToGrossPrice from "../utils/calculateNetToGrossPrice";
 import FilesReader from "./FilesReader";
-import ProductReader from "./ProductReader";
 export default class OrderProductsReader {
+    static async getAll(orderId) {
+        const connection = DatabaseConnection.get();
+        const orderProducts = await connection.ordersProducts.selectAllActive(orderId);
+        const correctProducts = await this.correctOrderProducts(orderProducts);
+        return correctProducts;
+    }
     static async getForOrder(orderId) {
         const connection = DatabaseConnection.get();
-        const products = await connection.ordersProducts.selectAll(orderId);
+        const products = await connection.ordersProducts.selectAllActive(orderId);
         const correctProducts = [];
         for (let i = 0; i < products.length; i++) {
             const correctProduct = {
@@ -20,9 +23,7 @@ export default class OrderProductsReader {
         }
         return correctProducts;
     }
-    static async getAll(orderId) {
-        const connection = DatabaseConnection.get();
-        const products = await connection.ordersProducts.selectAll(orderId);
+    static async correctOrderProducts(products) {
         const correctProducts = [];
         for (let i = 0; i < products.length; i++) {
             const correctProduct = await this.correctProduct(products[i]);
@@ -31,62 +32,20 @@ export default class OrderProductsReader {
         return correctProducts;
     }
     static async correctProduct(orderProduct) {
-        const product = await ProductReader.get(orderProduct.product_id);
-        const file = await FilesReader.get(product.fileId);
+        const file = await FilesReader.get(orderProduct.file_id);
         const correctProduct = {
             id: orderProduct.id,
-            productId: orderProduct.product_id,
             orderId: orderProduct.order_id,
             product: {
-                id: product.id,
-                sku: product.sku,
-                title: product.title,
-                netPrice: product.netPrice,
-                grossPrice: calculateNetToGrossPrice(product.netPrice, product.vat),
-                vat: product.vat,
+                id: orderProduct.product_id,
+                sku: orderProduct.sku,
+                title: orderProduct.title,
+                netPrice: orderProduct.net_price,
+                grossPrice: calculateNetToGrossPrice(orderProduct.net_price, orderProduct.vat),
+                vat: orderProduct.vat,
                 file,
             }
         };
         return correctProduct;
     }
-    static async get(orderId) {
-        const connection = DatabaseConnection.get();
-        const orderProducts = await connection.ordersProducts.selectProducts(orderId);
-        for (const product of orderProducts) {
-            const file = await FilesReader.get(product.file_id);
-            product.file = file;
-        }
-        return this.correctOrdersProducts(orderProducts);
-    }
-    static async getAllForIds(orderProductsIds) {
-        const connection = DatabaseConnection.get();
-        const queryOptions = {
-            where: {
-                connector: ConnectorE.and,
-                parameters: [
-                    { name: 'id', type: ParameterType.arrayBigint, value: orderProductsIds },
-                ]
-            }
-        };
-        const orderProducts = await connection.ordersProducts.selectAllForIds(queryOptions);
-        return orderProducts;
-    }
-    static correctOrdersProducts(productRows) {
-        const products = [];
-        for (let i = 0; i < productRows.length; i++) {
-            const product = this.correctOrderProduct(productRows[i]);
-            products.push(product);
-        }
-        return products;
-    }
-    static correctOrderProduct(product) {
-        return {
-            orderProductId: product.id,
-            netPrice: product.net_price,
-            id: product.product_id,
-            title: product.title,
-            sku: product.sku,
-            file: product.file
-        };
-    }
 }

package/dist/reader/OrderReader.js

@@ -12,28 +12,29 @@ export default class OrderReader {
         const orders = await connection.orders.selectForClient(clientAccountId);
         const correctOrders = [];
         for (let i = 0; i < orders.length; i++) {
-            const correctOrder = this.correctOrder(orders[i]);
+            const correctOrder = await this.correctOrder(orders[i]);
             const products = await OrderProductsReader.getAll(orders[i].id);
-            const status = await OrderStatusReader.get(orders[i].id);
-            correctOrders.push({ ...correctOrder, status, products });
+            correctOrders.push({ ...correctOrder, products });
         }
         return correctOrders;
     }
     static async getAll(queryOptions) {
         const connection = DatabaseConnection.get();
-        const orders = await connection.orders.selectAll(queryOptions);
+        const orderRows = await connection.orders.selectAll(queryOptions);
         const quantity = await connection.orders.count(queryOptions);
-        return { orders: this.correctOrders(orders), quantity };
+        const orders = await this.correctOrders(orderRows);
+        return { orders, quantity };
     }
-    static correctOrders(orderRows) {
+    static async correctOrders(orderRows) {
         const orders = [];
         for (let i = 0; i < orderRows.length; i++) {
-            const order = this.correctOrder(orderRows[i]);
+            const order = await this.correctOrder(orderRows[i]);
             orders.push(order);
         }
         return orders;
     }
-    static correctOrder(order) {
+    static async correctOrder(order) {
+        const status = await OrderStatusReader.get(order.id);
         const correctOrder = {
             id: order.id,
             email: order.email,
@@ -44,7 +45,8 @@ export default class OrderReader {
             deliveryDetailsId: order.delivery_details_id,
             invoiceDetailsId: order.invoice_details_id,
             paymentDetailsId: order.payment_details_id,
-            zsiId: order.zsi_id
+            zsiId: order.zsi_id,
+            status
         };
         return correctOrder;
     }

package/dist/reader/OrderStatusReader.d.ts

@@ -1,4 +1,4 @@
-import OrderStatusI from "../types/OrderStatusI";
+import OrderStatusI from "../types/StatusI";
 export default class OrderStatusReader {
     static get(orderId: number): Promise<OrderStatusI>;
     static getAll(orderId: number): Promise<OrderStatusI[]>;

package/dist/reader/OrderStatusReader.js

@@ -2,12 +2,12 @@ import DatabaseConnection from "../DatabaseConnection";
 export default class OrderStatusReader {
     static async get(orderId) {
         const connection = DatabaseConnection.get();
-        const statusRow = await connection.statuses.selectForOrder(orderId);
+        const statusRow = await connection.statuses.select(orderId);
         return this.correctStatus(statusRow);
     }
     static async getAll(orderId) {
         const connection = DatabaseConnection.get();
-        const statuses = await connection.statuses.selectAllForOrder(orderId);
+        const statuses = await connection.statuses.selectAll(orderId);
         const correctStatuss = [];
         for (let i = 0; i < statuses.length; i++) {
             const correctStatus = this.correctStatus(statuses[i]);
@@ -21,7 +21,8 @@ export default class OrderStatusReader {
             orderId: status.order_id,
             createdAt: status.created_at,
             userId: status.user_id,
-            type: status.type,
+            typeId: status.type_id,
+            typeName: status.type_name,
         };
         return correctStatus;
     }

package/dist/reader/ProductReader.d.ts

@@ -2,12 +2,10 @@ import ProductI from "../types/ProductI";
 import QueryOptionsI from "../types/QueryOptionsI";
 export default class ProductReader {
     static get(productId: number): Promise<ProductI>;
-    static getIdForSku(productSku: string): Promise<number>;
     static getForUrl(productUrl: string): Promise<ProductI>;
-    static getAll(queryOptions: QueryOptionsI): Promise<ProductI[]>;
+    static getAllActive(queryOptions: QueryOptionsI): Promise<ProductI[]>;
+    static getIdForSku(productSku: string): Promise<number>;
     static getQuantity(queryOptions: QueryOptionsI): Promise<number>;
-    static getListForOrder(): Promise<any>;
     private static correctProducts;
     private static correctProduct;
-    private static correctProductForOrderList;
 }

package/dist/reader/ProductReader.js

@@ -6,49 +6,39 @@ export default class ProductReader {
     static async get(productId) {
         const connection = DatabaseConnection.get();
         const product = await connection.products.select(productId);
-        const thumbnail = await FilesReader.get(product.file_id);
         const files = await FilesReader.getForConnection(FileConnectionTypeE.product, product.id);
-        return this.correctProduct(product, thumbnail, files);
-    }
-    static async getIdForSku(productSku) {
-        const connection = DatabaseConnection.get();
-        return await connection.products.selectIdForSku(productSku);
+        return this.correctProduct(product, files);
     }
     static async getForUrl(productUrl) {
         const connection = DatabaseConnection.get();
         const product = await connection.products.selectForUrl(productUrl);
-        return this.correctProduct(product);
+        const files = await FilesReader.getForConnection(FileConnectionTypeE.product, product.id);
+        return this.correctProduct(product, files);
     }
-    static async getAll(queryOptions) {
+    static async getAllActive(queryOptions) {
         const connection = DatabaseConnection.get();
-        const products = await connection.products.selectAll(queryOptions);
+        const products = await connection.products.selectAllActive(queryOptions);
         return this.correctProducts(products);
     }
+    static async getIdForSku(productSku) {
+        const connection = DatabaseConnection.get();
+        return await connection.products.selectIdForSku(productSku);
+    }
     static async getQuantity(queryOptions) {
         const connection = DatabaseConnection.get();
         const quantity = await connection.products.count(queryOptions);
         return quantity;
     }
-    static async getListForOrder() {
-        const connection = DatabaseConnection.get();
-        let correctProducts = [];
-        const products = await connection.products.selectListForOrder();
-        for (const product of products) {
-            const file = await FilesReader.get(product.file_id);
-            product.file = file;
-            correctProducts.push(this.correctProductForOrderList(product));
-        }
-        return correctProducts;
-    }
-    static correctProducts(products) {
+    static async correctProducts(products) {
         const correctProducts = [];
         for (let i = 0; i < products.length; i++) {
-            const correctProduct = this.correctProduct(products[i]);
+            const correctProduct = await this.correctProduct(products[i]);
             correctProducts.push(correctProduct);
         }
         return correctProducts;
     }
-    static correctProduct(product, thumbnail, files) {
+    static async correctProduct(product, files) {
+        const thumbnail = await FilesReader.get(product.file_id);
         return {
             id: product.id,
             sku: product.sku,
@@ -65,17 +55,8 @@ export default class ProductReader {
             createdAt: product.created_at,
             deleted: product.deleted,
             thumbnail: thumbnail ? thumbnail : null,
-            files: files,
+            files,
             grossPrice: calculateNetToGrossPrice(product.net_price, product.vat)
         };
     }
-    static correctProductForOrderList(product) {
-        return {
-            id: product.id,
-            title: product.title,
-            sku: product.sku,
-            file: product.file,
-            netPrice: product.net_price
-        };
-    }
 }

package/dist/repo/OrderProductsRepo.d.ts

@@ -1,6 +1,6 @@
 import OrderProduct from "../stockObjects/OrderProduct";
 export default class OrderProductsRepo {
-    static getAllActiveForOrderId(orderId: number): Promise<OrderProduct[]>;
+    static getAllActive(orderId: number): Promise<OrderProduct[]>;
     static getAllForIds(orderProductsIds: number[]): Promise<OrderProduct[]>;
     private static createOrdersProductsFromRows;
     private static createOrdersProductFromRow;

package/dist/repo/OrderProductsRepo.js

@@ -3,9 +3,9 @@ import OrderProduct from "../stockObjects/OrderProduct";
 import ConnectorE from "../types/ConnectorE";
 import ParameterType from "../types/parameters/ParameterType";
 export default class OrderProductsRepo {
-    static async getAllActiveForOrderId(orderId) {
+    static async getAllActive(orderId) {
         const connection = DatabaseConnection.get();
-        const orderProducts = await connection.ordersProducts.selectAll(orderId);
+        const orderProducts = await connection.ordersProducts.selectAllActive(orderId);
         return this.createOrdersProductsFromRows(orderProducts);
     }
     static async getAllForIds(orderProductsIds) {

package/dist/repo/OrderStatusRepo.js

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

package/dist/repo/ProductRepo.js

@@ -9,7 +9,6 @@ export default class ProductRepo {
     static async getForSku(productSku) {
         const connection = DatabaseConnection.get();
         const product = await connection.products.selectForSku(productSku);
-        console.log(product);
         return this.createProductFromRow(product);
     }
     static createProductFromRow(productRow) {

package/dist/stockObjects/Order.js

@@ -84,12 +84,17 @@ export default class Order extends StockObject {
         this.zsiId = zsiId;
     }
     async calculateAndUpdatePrice() {
-        let totalPrice = 0;
-        const orderProducts = await OrderProductsRepo.getAllActiveForOrderId(this.getId());
-        for (const product of orderProducts) {
-            totalPrice += product.getNetPrice();
+        const id = this.getId();
+        if (id) {
+            let totalPrice = 0;
+            const orderProducts = await OrderProductsRepo.getAllActive(id);
+            for (const product of orderProducts) {
+                totalPrice += product.getNetPrice();
+            }
+            this.setPrice(totalPrice);
         }
-        this.setPrice(totalPrice);
+        else
+            throw Error('The price of an uncreated order cannot be calculated');
     }
     getMapper() {
         return new OrderMapper(this);

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

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

package/dist/tables/orders/OrdersProductsTable.js

@@ -1,20 +1,8 @@
 import Table from '../../Table';
 import * as SQL from '../../SQL.json';
 export default class OrdersProductsTable extends Table {
-    async selectAll(orderId) {
-        const query = this.createQuery(SQL.ordersProducts.getAllActiveForOrderId);
-        query.bindParameter('order_id', orderId);
-        const result = await query.execute();
-        return result.getRows();
-    }
-    async getAllActiveForOrderId(orderId) {
-        const query = this.createQuery(SQL.ordersProducts.getAllActiveForOrderId);
-        query.bindParameter('order_id', orderId);
-        const result = await query.execute();
-        return result.getRows();
-    }
-    async selectProducts(orderId) {
-        const query = this.createQuery(SQL.ordersProducts.selectProducts);
+    async selectAllActive(orderId) {
+        const query = this.createQuery(SQL.ordersProducts.selectAllActive);
         query.bindParameter('order_id', orderId);
         const result = await query.execute();
         return result.getRows();

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

@@ -2,9 +2,8 @@ import Table from '../../Table';
 import Status from '../../stockObjects/Status';
 import StatusRow from '../../types/rows/StatusRow';
 export default class StatusesTable extends Table {
-    selectForOrder(orderId: number): Promise<StatusRow>;
-    selectLatest(orderId: number): Promise<StatusRow>;
-    selectAllForOrder(orderId: number): Promise<StatusRow[]>;
+    select(orderId: number): Promise<StatusRow>;
+    selectAll(orderId: number): Promise<StatusRow[]>;
     insert(status: Status): Promise<void>;
     private bindParameters;
     private selectNextId;

package/dist/tables/orders/StatusesTable.js

@@ -1,20 +1,14 @@
 import Table from '../../Table';
 import * as SQL from '../../SQL.json';
 export default class StatusesTable extends Table {
-    async selectForOrder(orderId) {
-        const query = this.createQuery(SQL.statuses.selectForOrder);
+    async select(orderId) {
+        const query = this.createQuery(SQL.statuses.select);
         query.bindParameter('order_id', orderId);
         const result = await query.execute();
         return result.getRow();
     }
-    async selectLatest(orderId) {
-        const query = this.createQuery(SQL.statuses.selectLatest);
-        query.bindParameter('order_id', orderId);
-        const result = await query.execute();
-        return result.getRow();
-    }
-    async selectAllForOrder(orderId) {
-        const query = this.createQuery(SQL.statuses.selectAllForOrder);
+    async selectAll(orderId) {
+        const query = this.createQuery(SQL.statuses.selectAll);
         query.bindParameter('order_id', orderId);
         const result = await query.execute();
         return result.getRows();
@@ -30,7 +24,7 @@ export default class StatusesTable extends Table {
     bindParameters(query, status) {
         query.bindParameter('order_id', status.getOrderId());
         query.bindParameter('user_id', status.getUserId());
-        query.bindParameter('type', status.getType());
+        query.bindParameter('type', status.getTypeId());
     }
     async selectNextId() {
         const query = this.createQuery(SQL.statuses.selectNextId);

package/dist/tables/public/ProductsTable.d.ts

@@ -4,16 +4,15 @@ import QueryOptionsI from '../../types/QueryOptionsI';
 import ProductRow from '../../types/rows/ProductRow';
 export default class ProductsTable extends Table {
     select(productId: number): Promise<ProductRow>;
-    selectForSku(sku: string): Promise<ProductRow>;
-    selectIdForSku(sku: string): Promise<number>;
-    selectListForOrder(): Promise<ProductRow[]>;
     selectAll(queryOption: QueryOptionsI): Promise<ProductRow[]>;
+    selectAllActive(queryOption: QueryOptionsI): Promise<ProductRow[]>;
+    selectForSku(sku: string): Promise<ProductRow>;
     selectForUrl(url: string): Promise<ProductRow>;
+    selectIdForSku(sku: string): Promise<number>;
     insert(productData: Product): Promise<number>;
-    count(queryOption: QueryOptionsI): Promise<number>;
     update(product: Product): Promise<boolean>;
     delete(productId: number): Promise<number>;
-    restore(product: Product): Promise<number>;
+    count(queryOption: QueryOptionsI): Promise<number>;
     private bindParameters;
     private selectNextId;
 }

package/dist/tables/public/ProductsTable.js

@@ -7,27 +7,21 @@ export default class ProductsTable extends Table {
         const result = await query.execute();
         return result.getRow();
     }
-    async selectForSku(sku) {
-        const query = this.createQuery(SQL.products.selectForSku);
-        query.bindParameter('sku', String(sku).toUpperCase());
-        const result = await query.execute();
-        return result.getRow();
-    }
-    async selectIdForSku(sku) {
-        const query = this.createQuery(SQL.products.selectIdForSku);
-        query.bindParameter('sku', String(sku).toUpperCase());
+    async selectAll(queryOption) {
+        const query = this.createQuery(SQL.products.selectAll, queryOption);
         const result = await query.execute();
-        return result.getValue();
+        return result.getRows();
     }
-    async selectListForOrder() {
-        const query = this.createQuery(SQL.products.selectListForOrder);
+    async selectAllActive(queryOption) {
+        const query = this.createQuery(SQL.products.selectAllActive, queryOption);
         const result = await query.execute();
         return result.getRows();
     }
-    async selectAll(queryOption) {
-        const query = this.createQuery(SQL.products.selectAll, queryOption);
+    async selectForSku(sku) {
+        const query = this.createQuery(SQL.products.selectForSku);
+        query.bindParameter('sku', String(sku).toUpperCase());
         const result = await query.execute();
-        return result.getRows();
+        return result.getRow();
     }
     async selectForUrl(url) {
         const query = this.createQuery(SQL.products.selectForUrl);
@@ -35,6 +29,12 @@ export default class ProductsTable extends Table {
         const result = await query.execute();
         return result.getRow();
     }
+    async selectIdForSku(sku) {
+        const query = this.createQuery(SQL.products.selectIdForSku);
+        query.bindParameter('sku', String(sku).toUpperCase());
+        const result = await query.execute();
+        return result.getValue();
+    }
     async insert(productData) {
         const sku = productData.getSku();
         let productId = await this.selectIdForSku(sku);
@@ -49,11 +49,6 @@ export default class ProductsTable extends Table {
         await query.execute();
         return productId;
     }
-    async count(queryOption) {
-        const query = this.createQuery(SQL.products.count, queryOption);
-        const result = await query.execute();
-        return result.getValue();
-    }
     async update(product) {
         const query = this.createQuery(SQL.products.update);
         query.bindParameter('id', product.getId());
@@ -67,14 +62,10 @@ export default class ProductsTable extends Table {
         const result = await query.execute();
         return result.getRowCount();
     }
-    async restore(product) {
-        const productId = await this.selectIdForSku(product.getSku());
-        if (productId)
-            throw Error(`This product cannot be restored because it has been edited. There is a newer version of this product (id: ${productId})`);
-        const query = this.createQuery(SQL.products.restore);
-        query.bindParameter('id', product.getId());
+    async count(queryOption) {
+        const query = this.createQuery(SQL.products.count, queryOption);
         const result = await query.execute();
-        return result.getRowCount();
+        return result.getValue();
     }
     bindParameters(query, productData) {
         query.bindParameter('sku', productData.getSku());

package/dist/types/DeliveryDetailsI.d.ts

@@ -1,8 +1,9 @@
 import AddressI from "./AddressI";
+import DeliveryMethodI from "./DeliveryMethodI";
 import PersonalDataI from "./PersonalDataI";
 export default interface DeliveryDetailsI {
     id: number;
     personalData: PersonalDataI | null;
     address: AddressI | null;
-    deliveryMethodId: number | null;
+    deliveryMethod: DeliveryMethodI | null;
 }

package/dist/types/OrderProductI.d.ts

@@ -1,7 +1,6 @@
 import FileI from "./FileI";
 export default interface OrderProductI {
     id: number;
-    productId: number;
     orderId: number;
     product: {
         id: number;

package/dist/types/ProductI.d.ts

@@ -13,10 +13,8 @@ export default interface ProductI {
     width: number;
     length: number;
     height: number;
-    fileId: number;
     thumbnail: FileI | null;
     createdAt: string;
     deleted: boolean;
-    file?: FileI;
     files?: FileI[];
 }

package/dist/types/StatusI.d.ts

@@ -1,5 +1,7 @@
 export default interface StatusI {
     id: number;
+    createdAt: string;
+    userId: number;
     typeId: number;
-    key: string;
+    typeName: string;
 }

package/dist/types/rows/OrderProductRow.d.ts

@@ -3,4 +3,8 @@ export default interface OrderProductRow {
     order_id: number;
     product_id: number;
     net_price: number;
+    title: string;
+    sku: string;
+    vat: number;
+    file_id: number;
 }

package/dist/utils/parameters/ParameterFilterSystem.js

@@ -1,11 +1,15 @@
 import ParameterType from "../../types/parameters/ParameterType";
 export default class ParameterFilterSystem {
     static filter(parameter, parameterFilter) {
-        switch (parameterFilter.type) {
-            case ParameterType.string: return parameterFilter.filter(parameter);
-            case ParameterType.arrayString:
-                return parameter.map((stringParameter) => parameterFilter.filter(stringParameter));
-            default: return parameter;
+        if (parameterFilter.filter && typeof parameterFilter.filter === 'function') {
+            switch (parameterFilter.type) {
+                case ParameterType.string: return parameterFilter.filter(parameter);
+                case ParameterType.arrayString:
+                    return parameter.map((stringParameter) => parameterFilter.filter(stringParameter));
+                default: return parameter;
+            }
         }
+        else
+            return parameter;
     }
 }

package/package.json

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

package/dist/types/OrderStatusI.d.ts

@@ -1,7 +0,0 @@
-export default interface OrderStatusI {
-    id: number;
-    orderId: number;
-    createdAt: string;
-    userId: number;
-    type: number;
-}

package/dist/types/OrderStatusI.js

@@ -1 +0,0 @@
-export {};