@dascompany/database 0.0.8 → 0.0.9

package/dist/SQL.json

@@ -62,15 +62,14 @@
     },
     "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 +83,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)"
     },

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/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,11 @@ 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 correctProductWithGraphics;
     private static correctProducts;
     private static correctProduct;
-    private static correctProductForOrderList;
 }

package/dist/reader/ProductReader.js

@@ -6,39 +6,31 @@ 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 await this.correctProductWithGraphics(product);
     }
     static async getForUrl(productUrl) {
         const connection = DatabaseConnection.get();
         const product = await connection.products.selectForUrl(productUrl);
-        return this.correctProduct(product);
+        return await this.correctProductWithGraphics(product);
     }
-    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 async correctProductWithGraphics(product) {
+        const thumbnail = await FilesReader.get(product.file_id);
+        const files = await FilesReader.getForConnection(FileConnectionTypeE.product, product.id);
+        return this.correctProduct(product, thumbnail, files);
     }
     static correctProducts(products) {
         const correctProducts = [];
@@ -65,17 +57,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();

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": "0.0.9",
   "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 {};