@dascompany/database 3.0.0 → 3.0.2

package/dist/reader/DeliveryMethodReader.js

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

package/dist/reader/DeliveryStatusReader.d.ts

@@ -0,0 +1,5 @@
+export default class DeliveryStatusReader {
+    static get(deliveryDetailsId: number): Promise<any>;
+    static getAll(deliveryDetailsId: number): Promise<any[]>;
+    private static correctDeliveryStatus;
+}

package/dist/reader/DeliveryStatusReader.js

@@ -0,0 +1,31 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class DeliveryStatusReader {
+    static async get(deliveryDetailsId) {
+        const connection = DatabaseConnection.get();
+        const deliveryStatus = await connection.deliveryStatuses.select(deliveryDetailsId);
+        if (deliveryStatus)
+            return await this.correctDeliveryStatus(deliveryStatus);
+        else
+            return {};
+    }
+    static async getAll(deliveryDetailsId) {
+        const connection = DatabaseConnection.get();
+        const deliveryStatusesData = await connection.deliveryStatuses.selectAll(deliveryDetailsId);
+        const deliveryStatuses = [];
+        for (let i = 0; i < deliveryStatusesData.length; i++) {
+            const deliveryStatus = await this.correctDeliveryStatus(deliveryStatusesData[i]);
+            deliveryStatuses.push(deliveryStatus);
+        }
+        return deliveryStatuses;
+    }
+    static async correctDeliveryStatus(deliveryStatus) {
+        const connection = DatabaseConnection.get();
+        const deliveryStatusType = await connection.deliveryStatusTypes.select(deliveryStatus.delivery_status_type_id);
+        return {
+            id: deliveryStatus.id,
+            type: deliveryStatusType,
+            userId: deliveryStatus.user_id,
+            createdAt: deliveryStatus.created_at
+        };
+    }
+}

package/dist/reader/FileConnectionsReader.d.ts

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

package/dist/reader/FileConnectionsReader.js

@@ -0,0 +1,25 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class FileConnectionsReader {
+    static async getAllForFileId(fileId) {
+        const connection = DatabaseConnection.get();
+        const fileConnections = await connection.fileConnections.selectForFileId(fileId);
+        return this.correctFileConnections(fileConnections);
+    }
+    static correctFileConnections(fileConnectionsRows) {
+        const fileConnections = [];
+        for (let i = 0; i < fileConnectionsRows.length; i++) {
+            const fileConnection = this.correctFileConnection(fileConnectionsRows[i]);
+            fileConnections.push(fileConnection);
+        }
+        return fileConnections;
+    }
+    static correctFileConnection(fileConnections) {
+        const correctFileConnection = {
+            fileId: fileConnections.file_id,
+            connectionType: fileConnections.connection_type,
+            connectionId: fileConnections.connection_id,
+            sequence: fileConnections.sequence
+        };
+        return correctFileConnection;
+    }
+}

package/dist/reader/FilesReader.d.ts

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

package/dist/reader/FilesReader.js

@@ -0,0 +1,45 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class FilesReader {
+    static async get(fileId) {
+        const connection = DatabaseConnection.get();
+        const file = await connection.files.select(fileId);
+        return this.correctFile(file);
+    }
+    static async getAll(queryOptions) {
+        const connection = DatabaseConnection.get();
+        const file = await connection.files.selectAll(queryOptions);
+        return this.correctFiles(file);
+    }
+    static async isExist(queryOptions) {
+        const connection = DatabaseConnection.get();
+        const fileId = await connection.files.selectId(queryOptions);
+        return fileId;
+    }
+    static async getQuantity(queryOptions) {
+        const connection = DatabaseConnection.get();
+        const quantity = await connection.files.count(queryOptions);
+        return quantity;
+    }
+    static async getForConnection(connectionType, connectionId) {
+        const connection = DatabaseConnection.get();
+        const files = await connection.files.selectForConnection(connectionType, connectionId);
+        return this.correctFiles(files);
+    }
+    static correctFiles(fileRows) {
+        const fileConnections = [];
+        for (let i = 0; i < fileRows.length; i++) {
+            const fileConnection = this.correctFile(fileRows[i]);
+            fileConnections.push(fileConnection);
+        }
+        return fileConnections;
+    }
+    static correctFile(file) {
+        const correctFile = {
+            id: file.id,
+            name: file.name,
+            catalog: file.catalog,
+            type: file.type,
+        };
+        return correctFile;
+    }
+}

package/dist/reader/InvoiceDetailsReader.d.ts

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

package/dist/reader/InvoiceDetailsReader.js

@@ -0,0 +1,21 @@
+import DatabaseConnection from "../DatabaseConnection";
+import AddressesReader from "./AddressesReader";
+import PersonalDataReader from "./PersonalDataReader";
+export default class InvoiceDetailsReader {
+    static async get(invoiceDetailsId) {
+        const connection = DatabaseConnection.get();
+        const invoiceDetails = await connection.invoiceDetails.select(invoiceDetailsId);
+        const id = invoiceDetails.id;
+        let personalData = null;
+        let address = null;
+        if (invoiceDetails.personal_data_id)
+            personalData = await PersonalDataReader.get(invoiceDetails.personal_data_id);
+        if (invoiceDetails.address_id)
+            address = await AddressesReader.get(invoiceDetails.address_id);
+        return {
+            id,
+            personalData,
+            address
+        };
+    }
+}

package/dist/reader/OrderProductsReader.d.ts

@@ -0,0 +1,10 @@
+import OrderProductI from "../types/OrderProductI";
+export default class OrderProductsReader {
+    static getForOrder(orderId: number): Promise<any[]>;
+    static getAll(orderId: number): Promise<OrderProductI[]>;
+    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

@@ -0,0 +1,92 @@
+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 getForOrder(orderId) {
+        const connection = DatabaseConnection.get();
+        const products = await connection.ordersProducts.selectAll(orderId);
+        const correctProducts = [];
+        for (let i = 0; i < products.length; i++) {
+            const correctProduct = {
+                id: products[i].id,
+                orderId: products[i].order_id,
+                productId: products[i].product_id,
+                netPrice: products[i].net_price,
+            };
+            correctProducts.push(correctProduct);
+        }
+        return correctProducts;
+    }
+    static async getAll(orderId) {
+        const connection = DatabaseConnection.get();
+        const products = await connection.ordersProducts.selectAll(orderId);
+        const correctProducts = [];
+        for (let i = 0; i < products.length; i++) {
+            const correctProduct = await this.correctProduct(products[i]);
+            correctProducts.push(correctProduct);
+        }
+        return correctProducts;
+    }
+    static async correctProduct(orderProduct) {
+        const product = await ProductReader.get(orderProduct.product_id);
+        const file = await FilesReader.get(product.fileId);
+        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,
+                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.selectAll(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.d.ts

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

package/dist/reader/OrderReader.js

@@ -0,0 +1,51 @@
+import DatabaseConnection from "../DatabaseConnection";
+import OrderProductsReader from "./OrderProductsReader";
+import OrderStatusReader from "./OrderStatusReader";
+export default class OrderReader {
+    static async get(orderId) {
+        const connection = DatabaseConnection.get();
+        const orderData = await connection.orders.select(orderId);
+        return this.correctOrder(orderData);
+    }
+    static async getForClient(clientAccountId) {
+        const connection = DatabaseConnection.get();
+        const orders = await connection.orders.selectForClient(clientAccountId);
+        const correctOrders = [];
+        for (let i = 0; i < orders.length; i++) {
+            const correctOrder = 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 });
+        }
+        return correctOrders;
+    }
+    static async getAll(queryOptions) {
+        const connection = DatabaseConnection.get();
+        const orders = await connection.orders.selectAll(queryOptions);
+        const quantity = await connection.orders.count(queryOptions);
+        return { orders: this.correctOrders(orders), quantity };
+    }
+    static correctOrders(orderRows) {
+        const orders = [];
+        for (let i = 0; i < orderRows.length; i++) {
+            const order = this.correctOrder(orderRows[i]);
+            orders.push(order);
+        }
+        return orders;
+    }
+    static correctOrder(order) {
+        const correctOrder = {
+            id: order.id,
+            email: order.email,
+            price: order.price,
+            createdAt: order.created_at,
+            clientId: order.client_id,
+            contactDetailsId: order.contact_details_id,
+            deliveryDetailsId: order.delivery_details_id,
+            invoiceDetailsId: order.invoice_details_id,
+            paymentDetailsId: order.payment_details_id,
+            zsiId: order.zsi_id
+        };
+        return correctOrder;
+    }
+}

package/dist/reader/OrderStatusReader.d.ts

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

package/dist/reader/OrderStatusReader.js

@@ -0,0 +1,28 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class OrderStatusReader {
+    static async get(orderId) {
+        const connection = DatabaseConnection.get();
+        const statusRow = await connection.statuses.selectForOrder(orderId);
+        return this.correctStatus(statusRow);
+    }
+    static async getAll(orderId) {
+        const connection = DatabaseConnection.get();
+        const statuses = await connection.statuses.selectAllForOrder(orderId);
+        const correctStatuss = [];
+        for (let i = 0; i < statuses.length; i++) {
+            const correctStatus = this.correctStatus(statuses[i]);
+            correctStatuss.push(correctStatus);
+        }
+        return correctStatuss;
+    }
+    static correctStatus(status) {
+        const correctStatus = {
+            id: status.id,
+            orderId: status.order_id,
+            createdAt: status.created_at,
+            userId: status.user_id,
+            type: status.type,
+        };
+        return correctStatus;
+    }
+}

package/dist/reader/PersonalDataReader.d.ts

@@ -0,0 +1,5 @@
+import PersonalDataI from "../types/PersonalDataI";
+export default class PersonalDataReader {
+    static get(personalDataId: number): Promise<PersonalDataI>;
+    private static getCorrectData;
+}

package/dist/reader/PersonalDataReader.js

@@ -0,0 +1,27 @@
+import DatabaseConnection from "../DatabaseConnection";
+import correctPhoneNumber from "../utils/correctPhoneNumber";
+import CompanyDetailsReader from "./CompanyDetailsReader";
+export default class PersonalDataReader {
+    static async get(personalDataId) {
+        const connection = DatabaseConnection.get();
+        const data = await connection.personalData.select(personalDataId);
+        const correctData = this.getCorrectData(data);
+        if (data.company_details_id) {
+            correctData.companyDetails = await CompanyDetailsReader.get(data.company_details_id);
+            correctData.isCompany = true;
+        }
+        return correctData;
+    }
+    static getCorrectData(data) {
+        const phoneNumber = correctPhoneNumber(data.phone_number);
+        return {
+            id: data.id,
+            firstName: data.first_name,
+            lastName: data.last_name,
+            email: data.email,
+            phoneNumber,
+            companyDetails: null,
+            isCompany: false
+        };
+    }
+}

package/dist/reader/ProductReader.d.ts

@@ -0,0 +1,13 @@
+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 getQuantity(queryOptions: QueryOptionsI): Promise<number>;
+    static getListForOrder(): Promise<any>;
+    private static correctProducts;
+    private static correctProduct;
+    private static correctProductForOrderList;
+}

package/dist/reader/ProductReader.js

@@ -0,0 +1,81 @@
+import DatabaseConnection from "../DatabaseConnection";
+import FileConnectionTypeE from "../types/FileConnectionTypeE";
+import calculateNetToGrossPrice from "../utils/calculateNetToGrossPrice";
+import FilesReader from "./FilesReader";
+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);
+    }
+    static async getForUrl(productUrl) {
+        const connection = DatabaseConnection.get();
+        const product = await connection.products.selectForUrl(productUrl);
+        return this.correctProduct(product);
+    }
+    static async getAll(queryOptions) {
+        const connection = DatabaseConnection.get();
+        const products = await connection.products.selectAll(queryOptions);
+        return this.correctProducts(products);
+    }
+    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) {
+        const correctProducts = [];
+        for (let i = 0; i < products.length; i++) {
+            const correctProduct = this.correctProduct(products[i]);
+            correctProducts.push(correctProduct);
+        }
+        return correctProducts;
+    }
+    static correctProduct(product, thumbnail, files) {
+        return {
+            id: product.id,
+            sku: product.sku,
+            url: product.url,
+            title: product.title,
+            description: product.description,
+            netPrice: product.net_price,
+            vat: product.vat,
+            color: product.color,
+            quantity: product.quantity,
+            width: product.width,
+            height: product.height,
+            length: product.length,
+            createdAt: product.created_at,
+            deleted: product.deleted,
+            thumbnail: thumbnail ? thumbnail : null,
+            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/reader/StatusTypesReader.d.ts

@@ -0,0 +1,3 @@
+export default class StatusTypesReader {
+    static get(): Promise<any[]>;
+}

package/dist/reader/StatusTypesReader.js

@@ -0,0 +1,8 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class StatusTypesReader {
+    static async get() {
+        const connection = DatabaseConnection.get();
+        const statusTypes = await connection.statusTypes.select();
+        return statusTypes;
+    }
+}

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

@@ -0,0 +1,5 @@
+export default class PaymentDetailsReader {
+    static get(paymentDetailsId: number): Promise<any>;
+    static getPaymentOrderId(paymentDetailsId: number): Promise<any>;
+    private static correctPaymentDetails;
+}

package/dist/reader/payment/PaymentDetailsReader.js

@@ -0,0 +1,27 @@
+import DatabaseConnection from "../../DatabaseConnection";
+import PaymentMethodReader from "./PaymentMethodReader";
+import PaymentStatusesReader from "./PaymentStatusesReader";
+export default class PaymentDetailsReader {
+    static async get(paymentDetailsId) {
+        const connection = DatabaseConnection.get();
+        const paymentDetails = await connection.paymentDetails.select(paymentDetailsId);
+        return await this.correctPaymentDetails(paymentDetails);
+    }
+    static async getPaymentOrderId(paymentDetailsId) {
+        const connection = DatabaseConnection.get();
+        const paymentDetails = await connection.paymentDetails.select(paymentDetailsId);
+        return paymentDetails.payment_order_id;
+    }
+    static async correctPaymentDetails(paymentDetails) {
+        const id = paymentDetails.id;
+        const [paymentMethod, statuses] = await Promise.all([
+            PaymentMethodReader.get(paymentDetails.payment_method_id),
+            PaymentStatusesReader.getAll(paymentDetails.id)
+        ]);
+        return {
+            id,
+            paymentMethod,
+            statuses,
+        };
+    }
+}

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

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

package/dist/reader/payment/PaymentMethodReader.js

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

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

@@ -0,0 +1,5 @@
+export default class PaymentStatusesReader {
+    static get(paymentDetailsId: number): Promise<any>;
+    static getAll(paymentDetailsId: number): Promise<any[]>;
+    private static correctPaymentStatus;
+}

package/dist/reader/payment/PaymentStatusesReader.js

@@ -0,0 +1,30 @@
+import DatabaseConnection from "../../DatabaseConnection";
+export default class PaymentStatusesReader {
+    static async get(paymentDetailsId) {
+        const connection = DatabaseConnection.get();
+        const paymentStatus = await connection.paymentStatuses.select(paymentDetailsId);
+        if (paymentStatus)
+            return await this.correctPaymentStatus(paymentStatus);
+        else
+            return {};
+    }
+    static async getAll(paymentDetailsId) {
+        const connection = DatabaseConnection.get();
+        const paymentStatusesData = await connection.paymentStatuses.selectAll(paymentDetailsId);
+        const paymentStatuses = [];
+        for (let i = 0; i < paymentStatusesData.length; i++) {
+            const paymentStatus = await this.correctPaymentStatus(paymentStatusesData[i]);
+            paymentStatuses.push(paymentStatus);
+        }
+        return paymentStatuses;
+    }
+    static async correctPaymentStatus(paymentStatus) {
+        const connection = DatabaseConnection.get();
+        const paymentStatusType = await connection.paymentStatusTypes.select(paymentStatus.payment_status_type_id);
+        return {
+            id: paymentStatus.id,
+            type: paymentStatusType,
+            createdAt: paymentStatus.created_at
+        };
+    }
+}

package/dist/repo/AddressesRepo.d.ts

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

package/dist/repo/AddressesRepo.js

@@ -0,0 +1,14 @@
+import DatabaseConnection from "../DatabaseConnection";
+import Address from "../stockObjects/Address";
+export default class AddressesRepo {
+    static async get(addressId) {
+        const connection = DatabaseConnection.get();
+        const address = await connection.addresses.select(addressId);
+        return this.createAddressFromRow(address);
+    }
+    static createAddressFromRow(dataRow) {
+        const address = new Address(dataRow.country, dataRow.city, dataRow.street, dataRow.postal_code, dataRow.house_number, dataRow.apartment_number);
+        address.setId(dataRow.id);
+        return address;
+    }
+}