@dascompany/database 0.0.1

package/dist/query/QueryParams.js

@@ -0,0 +1,113 @@
+import QueryParamCreator from './QueryParamCreator';
+import QueryParamsCreator from './QueryParamCreator';
+export default class QueryParams {
+    static where = '$WHERE';
+    static params = '$PARAMS';
+    static order = '$ORDERBY';
+    static limit = '$LIMIT';
+    static values = '$VALUES';
+    static paramConnector = 'AND';
+    static createParams(queryString, options) {
+        if (options.where && (queryString.includes(this.where) || queryString.includes(this.params)))
+            queryString = QueryParams.createWhereParams(queryString, options.where);
+        if (options && queryString.includes(this.order))
+            queryString = QueryParams.createOrderParams(queryString, options.order);
+        if (options && queryString.includes(this.limit))
+            queryString = QueryParams.createLimitParams(queryString, options.limit);
+        if (options.values && queryString.includes(this.values))
+            queryString = QueryParams.createValuesParams(queryString, options.values);
+        return queryString;
+    }
+    static createValuesParams(sql, values) {
+        const vals = [];
+        if (Array.isArray(values[0].value)) {
+            const quantity = values[0].value.length;
+            for (let i = 0; i < quantity; i++) {
+                vals.push(this.createValueParams(values, i));
+            }
+        }
+        else {
+            vals.push(this.createValueParams(values));
+        }
+        sql = sql.replaceAll(this.values, `VALUES ${vals.join(', ')}`);
+        return sql;
+    }
+    static createValueParams(values, index) {
+        const creatingValues = [];
+        values.forEach((value) => {
+            let valueall;
+            if (index) {
+                const paramType = QueryParamCreator.getBaseTypeForArrayType(value.type);
+                valueall = QueryParamCreator.createParamValue(`${value.name}_${index}`, paramType);
+            }
+            else {
+                valueall = QueryParamCreator.createParamValue(`${value.name}_0`, value.type);
+            }
+            creatingValues.push(valueall);
+        });
+        return `( ${creatingValues.join(', ')} )`;
+    }
+    static createWhereParams(sql, where) {
+        let sqlWithParams = '';
+        const params = this.createParamsSql(where.parameters);
+        if (sql.includes(this.where) || sql.includes(this.params)) {
+            if (params.length > 0) {
+                const { leftSql, rightSql } = this.splitSql(sql);
+                const connector = this.getWhereConnector(sql);
+                sqlWithParams = `${leftSql} ${connector} ${params.join(` ${where.connector}`)} ${rightSql}`;
+            }
+            else
+                sqlWithParams = this.removeWhereVariable(sql);
+        }
+        else
+            throw new Error(`Brak zmiennej: ${this.where} lub ${this.params} w zapytaniu sql`);
+        return sqlWithParams;
+    }
+    static createOrderParams(sql, order) {
+        if (order) {
+            sql = sql.replaceAll(this.order, `ORDER BY ${order}`);
+        }
+        else
+            sql = sql.replaceAll(this.order, '');
+        return sql;
+    }
+    static createLimitParams(sql, resultLimitation) {
+        if (resultLimitation) {
+            sql = sql.replaceAll(this.limit, `LIMIT $limit::BIGINT OFFSET $offset::BIGINT`);
+        }
+        else
+            sql = sql.replaceAll(this.limit, '');
+        return sql;
+    }
+    static createParamsSql(parameters) {
+        let sqlParams = [];
+        parameters.forEach((parameter) => {
+            if ((Array.isArray(parameter.value) && parameter.value.length > 0) ||
+                (!Array.isArray(parameter.value) && parameter.value))
+                sqlParams.push(QueryParamsCreator.createParam(parameter));
+        });
+        return sqlParams;
+    }
+    static removeWhereVariable(sql) {
+        sql = sql.replaceAll(this.where, '');
+        sql = sql.replaceAll(this.params, '');
+        return sql;
+    }
+    static splitSql(sql) {
+        let sqlArray = [];
+        if (sql.includes(this.where))
+            sqlArray = sql.split(this.where);
+        else if (sql.includes(this.params))
+            sqlArray = sql.split(this.params);
+        return {
+            leftSql: sqlArray[0],
+            rightSql: sqlArray[1]
+        };
+    }
+    static getWhereConnector(sql) {
+        if (sql.includes(this.where))
+            return 'WHERE';
+        else if (sql.includes(this.params))
+            return 'AND';
+    }
+}

package/dist/query/Result.d.ts

@@ -0,0 +1,11 @@
+export default class Result {
+    private pgResult;
+    constructor(pgResult: any);
+    getRows(): Array<any>;
+    getRow(): any;
+    getRowCount(): number;
+    private getFields;
+    isFiledExists(fieldName: string): boolean;
+    private geFieldNames;
+    getValue(fieldName?: string | null): any;
+}

package/dist/query/Result.js

@@ -0,0 +1,43 @@
+import ResultsCorrector from './ResultsCorrector';
+export default class Result {
+    pgResult;
+    constructor(pgResult) {
+        this.pgResult = pgResult;
+    }
+    getRows() {
+        const rows = this.pgResult.rows;
+        return ResultsCorrector.correctRows(rows);
+    }
+    getRow() {
+        if (this.getRowCount() > 0)
+            return this.getRows()[0];
+        else
+            return null;
+    }
+    getRowCount() {
+        return this.pgResult.rowCount;
+    }
+    getFields() {
+        return this.pgResult.fields;
+    }
+    isFiledExists(fieldName) {
+        return this.getFields().some((field) => field.name == fieldName);
+    }
+    geFieldNames() {
+        return this.getFields().map((element) => element.name);
+    }
+    getValue(fieldName = null) {
+        if (this.getRowCount() > 0) {
+            if (fieldName) {
+                if (this.isFiledExists(fieldName))
+                    return this.getRows()[0][fieldName];
+                else
+                    throw Error(`Field: '${fieldName}' not exists in query result. Available fileds: ${this.geFieldNames().join(', ')}`);
+            }
+            else
+                return this.getRows()[0][this.getFields()[0].name];
+        }
+        else
+            return null;
+    }
+}

package/dist/query/ResultsCorrector.d.ts

@@ -0,0 +1,4 @@
+export default class ResultsCorrector {
+    static correctRows(rows: Array<any>): Array<any>;
+    private static isNumber;
+}

package/dist/query/ResultsCorrector.js

@@ -0,0 +1,14 @@
+export default class ResultsCorrector {
+    static correctRows(rows) {
+        rows.forEach((row) => {
+            Object.keys(row).forEach((key) => {
+                if (this.isNumber(row[key]))
+                    row[key] = Number(row[key]);
+            });
+        });
+        return rows;
+    }
+    static isNumber(n) {
+        return !isNaN(parseFloat(n)) && !isNaN(n - 0);
+    }
+}

package/dist/reader/AddressesReader.d.ts

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

package/dist/reader/AddressesReader.js

@@ -0,0 +1,24 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class AddressesReader {
+    static async get(addressId) {
+        const connection = DatabaseConnection.get();
+        const address = await connection.addresses.select(addressId);
+        return this.getCorrectData(address);
+    }
+    static async getCompanyAddress() {
+        const connection = DatabaseConnection.get();
+        const address = await connection.addresses.select(1);
+        return this.getCorrectData(address);
+    }
+    static getCorrectData(address) {
+        return {
+            id: address.id,
+            country: address.country,
+            city: address.city,
+            postalCode: address.postal_code,
+            street: address.street,
+            houseNumber: address.house_number,
+            apartmentNumber: address.apartment_number,
+        };
+    }
+}

package/dist/reader/ClientAccountReader.d.ts

@@ -0,0 +1,7 @@
+import ClientAccountI from "../types/ClientAccountI";
+export default class ClientAccountReader {
+    static get(accountId: number): Promise<ClientAccountI>;
+    static getForEmail(email: string): Promise<ClientAccountI>;
+    static getIdForEmail(email: string): Promise<number>;
+    private static correctData;
+}

package/dist/reader/ClientAccountReader.js

@@ -0,0 +1,30 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class ClientAccountReader {
+    static async get(accountId) {
+        const connection = DatabaseConnection.get();
+        const account = await connection.accounts.select(accountId);
+        return this.correctData(account);
+    }
+    static async getForEmail(email) {
+        const connection = DatabaseConnection.get();
+        const account = await connection.accounts.selectForEmail(email);
+        return this.correctData(account);
+    }
+    static async getIdForEmail(email) {
+        const connection = DatabaseConnection.get();
+        const accountId = await connection.accounts.selectIdForEmail(email);
+        return accountId;
+    }
+    static correctData(account) {
+        return {
+            id: account.id,
+            email: account.email,
+            createdAt: account.created_at,
+            activated: account.activated,
+            deleted: account.deleted,
+            contactDetailsId: account.contact_details_id,
+            deliveryDetailsId: account.delivery_details_id,
+            invoiceDetailsId: account.invoice_details_id,
+        };
+    }
+}

package/dist/reader/CompanyDetailsReader.d.ts

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

package/dist/reader/CompanyDetailsReader.js

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

package/dist/reader/ContactDetailsReader.d.ts

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

package/dist/reader/ContactDetailsReader.js

@@ -0,0 +1,16 @@
+import DatabaseConnection from "../DatabaseConnection";
+import AddressesReader from "./AddressesReader";
+import PersonalDataReader from "./PersonalDataReader";
+export default class ContactDetailsReader {
+    static async get(contactDetailsId) {
+        const connection = DatabaseConnection.get();
+        const contactDetails = await connection.contactDetails.select(contactDetailsId);
+        const personalData = await PersonalDataReader.get(contactDetails.personal_data_id);
+        const address = contactDetails.address_id ? await AddressesReader.get(contactDetails.address_id) : null;
+        return {
+            id: contactDetails.id,
+            personalData,
+            address
+        };
+    }
+}

package/dist/reader/DeliveryDetailsReader.d.ts

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

package/dist/reader/DeliveryDetailsReader.js

@@ -0,0 +1,31 @@
+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) {
+        const connection = DatabaseConnection.get();
+        const deliveryDetails = await connection.deliveryDetails.select(deliveryDetailsId);
+        const id = deliveryDetails.id;
+        let personalData = null;
+        let address = null;
+        let deliveryMethod = null;
+        if (deliveryDetails.personal_data_id)
+            personalData = await PersonalDataReader.get(deliveryDetails.personal_data_id);
+        if (deliveryDetails.address_id)
+            address = await AddressesReader.get(deliveryDetails.address_id);
+        if (deliveryDetails.delivery_method_id)
+            deliveryMethod = await DeliveryMethodReader.get(deliveryDetails.delivery_method_id);
+        const status = await DeliveryStatusReader.get(deliveryDetails.id);
+        const statuses = await DeliveryStatusReader.getAll(deliveryDetails.id);
+        return {
+            id,
+            personalData,
+            address,
+            deliveryMethod,
+            status,
+            statuses,
+        };
+    }
+}

package/dist/reader/DeliveryMethodReader.d.ts

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

package/dist/reader/DeliveryMethodReader.js

@@ -0,0 +1,13 @@
+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;
+    }
+}

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/FilesReader.d.ts

@@ -0,0 +1,7 @@
+import FileConnectionE from "../types/FileConnectionE";
+import FileI from "../types/FileI";
+export default class FilesReader {
+    static get(fileId: number): Promise<FileI>;
+    static getForConnection(connectionType: FileConnectionE, connectionId: number): Promise<FileI[]>;
+    private static correctFile;
+}

package/dist/reader/FilesReader.js

@@ -0,0 +1,26 @@
+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 getForConnection(connectionType, connectionId) {
+        const connection = DatabaseConnection.get();
+        const files = await connection.files.selectForConnection(connectionType, connectionId);
+        const correctFiles = [];
+        files.forEach((file) => {
+            correctFiles.push(this.correctFile(file));
+        });
+        return correctFiles;
+    }
+    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,6 @@
+import OrderProductI from "../types/OrderProductI";
+export default class OrderProductsReader {
+    static getForOrder(orderId: number): Promise<OrderProductI[]>;
+    static getAll(orderId: number): Promise<OrderProductI[]>;
+    private static correctProduct;
+}

package/dist/reader/OrderProductsReader.js

@@ -0,0 +1,50 @@
+import DatabaseConnection from "../DatabaseConnection";
+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;
+    }
+}

package/dist/reader/OrderReader.d.ts

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

package/dist/reader/OrderReader.js

@@ -0,0 +1,37 @@
+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 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,10 @@
+import ProductI from "../types/ProductI";
+import QueryOptionsI from "../types/QueryOptionsI";
+export default class ProductReader {
+    static get(productId: number): Promise<ProductI>;
+    static getForUrl(productUrl: string): Promise<ProductI>;
+    static getAll(queryOptions: QueryOptionsI): Promise<ProductI[]>;
+    static getQuantity(queryOptions: QueryOptionsI): Promise<number>;
+    private static correctProducts;
+    private static correctProduct;
+}