@dascompany/database 0.0.1

package/dist/mappers/ClientMapper.js

@@ -0,0 +1,24 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class ClientMapper {
+    client;
+    clientAccountsTable;
+    constructor(client) {
+        this.clientAccountsTable = DatabaseConnection.get().accounts;
+        this.client = client;
+    }
+    async save() {
+        if (!this.client.getDeleted()) {
+            if (this.client.getId())
+                await this.clientAccountsTable.update(this.client);
+            else
+                await this.clientAccountsTable.insert(this.client);
+        }
+        else
+            throw new Error(`Client account ${this.client.getId()} is deleted. Restore before updating.`);
+    }
+    async delete() {
+        const id = this.client.getId();
+        if (id)
+            await this.clientAccountsTable.delete(id);
+    }
+}

package/dist/mappers/CompanyDetailsMapper.d.ts

@@ -0,0 +1,9 @@
+import CompanyDetails from "../stockObjects/CompanyDetails";
+import StockObjectMapper from "../types/StockObjectMapper";
+export default class CompanyDetailsMapper implements StockObjectMapper {
+    private companyDetails;
+    private companyDetailsTable;
+    constructor(companyDetails: CompanyDetails);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/CompanyDetailsMapper.js

@@ -0,0 +1,22 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class CompanyDetailsMapper {
+    companyDetails;
+    companyDetailsTable;
+    constructor(companyDetails) {
+        this.companyDetailsTable = DatabaseConnection.get().companyDetails;
+        this.companyDetails = companyDetails;
+    }
+    async save() {
+        if (this.companyDetails.getId())
+            await this.companyDetailsTable.update(this.companyDetails);
+        else
+            await this.companyDetailsTable.insert(this.companyDetails);
+    }
+    async delete() {
+        const id = this.companyDetails.getId();
+        if (id)
+            await this.companyDetailsTable.delete(id);
+        else
+            throw Error('Uncreated companyDetails cannot be deleted');
+    }
+}

package/dist/mappers/ContactDetailsMapper.d.ts

@@ -0,0 +1,9 @@
+import ContactDetails from "../stockObjects/ContactDetails";
+import StockObjectMapper from "../types/StockObjectMapper";
+export default class ContactDetailsMapper implements StockObjectMapper {
+    private contactDetails;
+    private contactDetailsTable;
+    constructor(contactDetails: ContactDetails);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/ContactDetailsMapper.js

@@ -0,0 +1,18 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class ContactDetailsMapper {
+    contactDetails;
+    contactDetailsTable;
+    constructor(contactDetails) {
+        this.contactDetailsTable = DatabaseConnection.get().contactDetails;
+        this.contactDetails = contactDetails;
+    }
+    async save() {
+        if (this.contactDetails.getId())
+            await this.contactDetailsTable.update(this.contactDetails);
+        else
+            await this.contactDetailsTable.insert(this.contactDetails);
+    }
+    async delete() {
+        throw Error('Method not impemented');
+    }
+}

package/dist/mappers/DeliveryDetailsMapper.d.ts

@@ -0,0 +1,9 @@
+import DeliveryDetails from "../stockObjects/DeliveryDetails";
+import StockObjectMapper from "../types/StockObjectMapper";
+export default class DeliveryDetailsMapper implements StockObjectMapper {
+    private deliveryDetails;
+    private deliveryDetailsTable;
+    constructor(deliveryDetails: DeliveryDetails);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/DeliveryDetailsMapper.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class DeliveryDetailsMapper {
+    deliveryDetails;
+    deliveryDetailsTable;
+    constructor(deliveryDetails) {
+        this.deliveryDetailsTable = DatabaseConnection.get().deliveryDetails;
+        this.deliveryDetails = deliveryDetails;
+    }
+    async save() {
+        if (this.deliveryDetails.getId())
+            await this.deliveryDetailsTable.update(this.deliveryDetails);
+        else
+            await this.deliveryDetailsTable.insert(this.deliveryDetails);
+    }
+    async delete() {
+    }
+}

package/dist/mappers/DeliveryStatusMapper.d.ts

@@ -0,0 +1,9 @@
+import DeliveryStatus from "../stockObjects/DeliveryStatus";
+import StockObjectMapper from "../types/StockObjectMapper";
+export default class DeliveryStatusMapper implements StockObjectMapper {
+    private deliveryStatus;
+    private deliveryStatusesTable;
+    constructor(deliveryStatus: DeliveryStatus);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/DeliveryStatusMapper.js

@@ -0,0 +1,15 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class DeliveryStatusMapper {
+    deliveryStatus;
+    deliveryStatusesTable;
+    constructor(deliveryStatus) {
+        this.deliveryStatusesTable = DatabaseConnection.get().deliveryStatuses;
+        this.deliveryStatus = deliveryStatus;
+    }
+    async save() {
+        await this.deliveryStatusesTable.insert(this.deliveryStatus);
+    }
+    async delete() {
+        throw Error('Method not implemented');
+    }
+}

package/dist/mappers/InvoiceDetailsMapper.d.ts

@@ -0,0 +1,9 @@
+import InvoiceDetails from '../stockObjects/InvoiceDetails';
+import StockObjectMapper from '../types/StockObjectMapper';
+export default class InvoiceDetailsMapper implements StockObjectMapper {
+    private invoiceDetails;
+    private invoiceDetailsTable;
+    constructor(invoiceDetails: InvoiceDetails);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/InvoiceDetailsMapper.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from '../DatabaseConnection';
+export default class InvoiceDetailsMapper {
+    invoiceDetails;
+    invoiceDetailsTable;
+    constructor(invoiceDetails) {
+        this.invoiceDetailsTable = DatabaseConnection.get().invoiceDetails;
+        this.invoiceDetails = invoiceDetails;
+    }
+    async save() {
+        if (this.invoiceDetails.getId())
+            await this.invoiceDetailsTable.update(this.invoiceDetails);
+        else
+            await this.invoiceDetailsTable.insert(this.invoiceDetails);
+    }
+    async delete() {
+    }
+}

package/dist/mappers/OrderMapper.d.ts

@@ -0,0 +1,9 @@
+import Order from "../stockObjects/Order";
+import StockObjectMapper from "../types/StockObjectMapper";
+export default class OrderMapper implements StockObjectMapper {
+    private order;
+    private orderTable;
+    constructor(order: Order);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/OrderMapper.js

@@ -0,0 +1,19 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class OrderMapper {
+    order;
+    orderTable;
+    constructor(order) {
+        this.orderTable = DatabaseConnection.get().orders;
+        this.order = order;
+    }
+    async save() {
+        const orderId = this.order.getId();
+        if (orderId)
+            await this.orderTable.update(this.order);
+        else
+            await this.orderTable.insert(this.order);
+    }
+    async delete() {
+        throw Error('method not implemented');
+    }
+}

package/dist/mappers/OrderProductMapper.d.ts

@@ -0,0 +1,9 @@
+import OrderProduct from "../stockObjects/OrderProduct";
+import StockObjectMapper from "../types/StockObjectMapper";
+export default class OrderProductMapper implements StockObjectMapper {
+    private orderProduct;
+    private orderProductsTable;
+    constructor(orderProduct: OrderProduct);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/OrderProductMapper.js

@@ -0,0 +1,15 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class OrderProductMapper {
+    orderProduct;
+    orderProductsTable;
+    constructor(orderProduct) {
+        this.orderProductsTable = DatabaseConnection.get().ordersProducts;
+        this.orderProduct = orderProduct;
+    }
+    async save() {
+        await this.orderProductsTable.insert(this.orderProduct);
+    }
+    async delete() {
+        throw Error('NOT IMPLEMENTED');
+    }
+}

package/dist/mappers/PaymentDetailsMapper.d.ts

@@ -0,0 +1,9 @@
+import PaymentDetails from "../stockObjects/PaymentDetails";
+import StockObjectMapper from "../types/StockObjectMapper";
+export default class PaymentDetailsMapper implements StockObjectMapper {
+    private paymentDetails;
+    private paymentDetailsTable;
+    constructor(paymentDetails: PaymentDetails);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/PaymentDetailsMapper.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class PaymentDetailsMapper {
+    paymentDetails;
+    paymentDetailsTable;
+    constructor(paymentDetails) {
+        this.paymentDetailsTable = DatabaseConnection.get().paymentDetails;
+        this.paymentDetails = paymentDetails;
+    }
+    async save() {
+        if (this.paymentDetails.getId())
+            await this.paymentDetailsTable.update(this.paymentDetails);
+        else
+            await this.paymentDetailsTable.insert(this.paymentDetails);
+    }
+    async delete() {
+    }
+}

package/dist/mappers/PaymentStatusMapper.d.ts

@@ -0,0 +1,9 @@
+import PaymentStatus from "../stockObjects/PaymentStatus";
+import StockObjectMapper from "../types/StockObjectMapper";
+export default class PaymentStatusMapper implements StockObjectMapper {
+    private paymentStatus;
+    private paymentStatusesTable;
+    constructor(paymentStatus: PaymentStatus);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/PaymentStatusMapper.js

@@ -0,0 +1,15 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class PaymentStatusMapper {
+    paymentStatus;
+    paymentStatusesTable;
+    constructor(paymentStatus) {
+        this.paymentStatusesTable = DatabaseConnection.get().paymentStatuses;
+        this.paymentStatus = paymentStatus;
+    }
+    async save() {
+        await this.paymentStatusesTable.insert(this.paymentStatus);
+    }
+    async delete() {
+        throw Error('Method not implemented');
+    }
+}

package/dist/mappers/PersonalDataMapper.d.ts

@@ -0,0 +1,9 @@
+import PersonalData from "../stockObjects/PersonalData";
+import StockObjectMapper from "../types/StockObjectMapper";
+export default class PersonalDataMapper implements StockObjectMapper {
+    private personalData;
+    private personalDataTable;
+    constructor(personalData: PersonalData);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/PersonalDataMapper.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class PersonalDataMapper {
+    personalData;
+    personalDataTable;
+    constructor(personalData) {
+        this.personalDataTable = DatabaseConnection.get().personalData;
+        this.personalData = personalData;
+    }
+    async save() {
+        if (this.personalData.getId())
+            await this.personalDataTable.update(this.personalData);
+        else
+            await this.personalDataTable.insert(this.personalData);
+    }
+    async delete() {
+    }
+}

package/dist/mappers/StatusMapper.d.ts

@@ -0,0 +1,9 @@
+import Status from "../stockObjects/Status";
+import StockObjectMapper from "../types/StockObjectMapper";
+export default class StatusMapper implements StockObjectMapper {
+    private status;
+    private statusTable;
+    constructor(status: Status);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/StatusMapper.js

@@ -0,0 +1,15 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class StatusMapper {
+    status;
+    statusTable;
+    constructor(status) {
+        this.statusTable = DatabaseConnection.get().statuses;
+        this.status = status;
+    }
+    async save() {
+        await this.statusTable.insert(this.status);
+    }
+    async delete() {
+        throw Error('method not implemented');
+    }
+}

package/dist/query/BindParams.d.ts

@@ -0,0 +1,9 @@
+import QueryOptionsI from "../types/QueryOptionsI";
+import Query from "./Query";
+export default class BindParams {
+    static bindParams(query: Query, options: QueryOptionsI): void;
+    private static bindWhereParams;
+    private static bindWhereParam;
+    private static bindLimitParams;
+    private static bindValuesParams;
+}

package/dist/query/BindParams.js

@@ -0,0 +1,56 @@
+import ParameterType from "../types/parameters/ParameterType";
+import QueryParamCreator from "./QueryParamCreator";
+export default class BindParams {
+    static bindParams(query, options) {
+        if (options?.where)
+            BindParams.bindWhereParams(query, options.where.parameters);
+        if (options?.limit)
+            BindParams.bindLimitParams(query, options.limit);
+        if (options?.values) {
+            BindParams.bindValuesParams(query, options.values);
+        }
+    }
+    static bindWhereParams(query, parameters) {
+        parameters.forEach((parameter) => {
+            this.bindWhereParam(query, parameter);
+        });
+    }
+    static bindWhereParam(query, parameter) {
+        if (QueryParamCreator.isArrayType(parameter.type)) {
+            parameter.value.forEach((value, index) => {
+                if (parameter.type == ParameterType.arrayString)
+                    value = `%${value}%`;
+                query.bindParameter(`${parameter.name}_param${index}`, value);
+            });
+        }
+        else {
+            if (parameter.type == ParameterType.string)
+                parameter.value = `%${parameter.value}%`;
+            query.bindParameter(parameter.name, parameter.value);
+        }
+    }
+    static bindLimitParams(query, resultLimitation) {
+        query.bindParameter("limit", resultLimitation.limit);
+        query.bindParameter("offset", resultLimitation.offset);
+    }
+    static bindValuesParams(query, values) {
+        if (Array.isArray(values[0].value)) {
+            const quantity = values[0].value.length;
+            for (let i = 0; i < quantity; i++) {
+                values.forEach((value) => {
+                    if (Array.isArray(value.value)) {
+                        query.bindParameter(`${value.name}_${i}`, value.value[i]);
+                    }
+                    else {
+                        query.bindParameter(`${value.name}_${i}`, value.value);
+                    }
+                });
+            }
+        }
+        else {
+            values.forEach((value) => {
+                query.bindParameter(`${value.name}_0`, value.value);
+            });
+        }
+    }
+}

package/dist/query/Parameters.d.ts

@@ -0,0 +1,11 @@
+export default class Parameters {
+    private parameters;
+    private requireParameters;
+    constructor(queryString: string);
+    getValues(): Array<any>;
+    getRequireParameters(): any[];
+    addParameter(name: string, value: any): void;
+    private getValueForParameterName;
+    private getParameterForName;
+    private getRequiredParametersFromQueryString;
+}

package/dist/query/Parameters.js

@@ -0,0 +1,54 @@
+export default class Parameters {
+    parameters;
+    requireParameters;
+    constructor(queryString) {
+        this.parameters = [];
+        this.requireParameters = this.getRequiredParametersFromQueryString(queryString);
+    }
+    getValues() {
+        let values = [];
+        this.requireParameters.forEach((parameterName) => {
+            values.push(this.getValueForParameterName(parameterName));
+        });
+        return values;
+    }
+    getRequireParameters() {
+        return this.requireParameters;
+    }
+    addParameter(name, value) {
+        const parameter = this.getParameterForName(name);
+        if (parameter) {
+            parameter.value = value;
+        }
+        else {
+            this.parameters.push({ name, value });
+        }
+    }
+    getValueForParameterName(parameterName) {
+        const parameter = this.getParameterForName(parameterName);
+        if (parameter)
+            return parameter.value;
+        else
+            throw Error(`Missing required parameter: ${parameterName}`);
+    }
+    getParameterForName(parameterName) {
+        return this.parameters.find((parameter) => {
+            if (parameter.name == parameterName)
+                return parameter;
+        });
+    }
+    getRequiredParametersFromQueryString(queryString) {
+        let requireParameters = [];
+        const dolarSplit = queryString.split("$");
+        if (dolarSplit.length > 1) {
+            dolarSplit.forEach((dolarSplitElement, index) => {
+                if (index > 0) {
+                    const doubleColonSplit = dolarSplitElement.split("::");
+                    if (doubleColonSplit.length > 1)
+                        requireParameters.push(doubleColonSplit[0]);
+                }
+            });
+        }
+        return requireParameters;
+    }
+}

package/dist/query/Query.d.ts

@@ -0,0 +1,11 @@
+import Result from './Result';
+export default class Query {
+    private pgClient;
+    private queryString;
+    private parameters;
+    constructor(pgClient: any, queryString: string);
+    bindParameter(name: string, value: any): this;
+    execute(): Promise<Result>;
+    private getQueryConfig;
+    private getQueryString;
+}

package/dist/query/Query.js

@@ -0,0 +1,42 @@
+import Result from './Result';
+import Parameters from './Parameters';
+export default class Query {
+    pgClient;
+    queryString;
+    parameters;
+    constructor(pgClient, queryString) {
+        this.pgClient = pgClient;
+        this.queryString = queryString;
+        this.parameters = new Parameters(queryString);
+    }
+    bindParameter(name, value) {
+        this.parameters.addParameter(name, value);
+        return this;
+    }
+    async execute() {
+        const queryConfig = this.getQueryConfig();
+        try {
+            const pgResult = await this.pgClient.query(queryConfig);
+            return new Result(pgResult);
+        }
+        catch (error) {
+            error.message += `\n\nQuery: "${queryConfig.text}" \nParameters: "${queryConfig.values}" \n\n`;
+            throw error;
+        }
+    }
+    getQueryConfig() {
+        return {
+            text: this.getQueryString(),
+            values: this.parameters.getValues()
+        };
+    }
+    getQueryString() {
+        let queryString = this.queryString;
+        const requireParameters = this.parameters.getRequireParameters();
+        for (let index = 0; index < requireParameters.length; index++) {
+            const parameterName = requireParameters[index];
+            queryString = queryString.replace('$' + parameterName + '::', '$' + (index + 1) + '::');
+        }
+        return queryString;
+    }
+}

package/dist/query/QueryParamCreator.d.ts

@@ -0,0 +1,10 @@
+import ParameterI from "../types/ParameterI";
+import ParameterType from "../types/parameters/ParameterType";
+export default class QueryParamCreator {
+    static createParam(parameter: ParameterI): string;
+    static isArrayType(type: ParameterType): boolean;
+    private static createArrayParam;
+    static createParamValue(paramName: string, paramType: ParameterType): string;
+    static getBaseTypeForArrayType(paramType: ParameterType): ParameterType;
+    private static getOperatorForType;
+}

package/dist/query/QueryParamCreator.js

@@ -0,0 +1,67 @@
+import ParameterType from "../types/parameters/ParameterType";
+export default class QueryParamCreator {
+    static createParam(parameter) {
+        if (this.isArrayType(parameter.type))
+            return this.createArrayParam(parameter);
+        else {
+            const paramName = parameter.name;
+            const operator = this.getOperatorForType(parameter.type);
+            const value = this.createParamValue(paramName, parameter.type);
+            return `${paramName} ${operator} ${value}`;
+        }
+    }
+    static isArrayType(type) {
+        if (type == ParameterType.arrayString || type == ParameterType.arrayNumber || type == ParameterType.arrayBoolean)
+            return true;
+        else
+            return false;
+    }
+    static createArrayParam(parameter) {
+        const paramName = parameter.name;
+        let sqlArrayParam = '(';
+        let arrayParam = [];
+        parameter.value.forEach((paramValue, index) => {
+            const paramType = this.getBaseTypeForArrayType(parameter.type);
+            const operator = this.getOperatorForType(paramType);
+            const value = this.createParamValue(`${paramName}_param${index}`, paramType);
+            arrayParam.push(`${paramName} ${operator} ${value}`);
+        });
+        sqlArrayParam += arrayParam.join(' OR ');
+        return sqlArrayParam += ')';
+    }
+    static createParamValue(paramName, paramType) {
+        switch (paramType) {
+            case ParameterType.bigint:
+                return `$${paramName}::BIGINT`;
+            case ParameterType.number:
+                return ` $${paramName}::NUMERIC`;
+            case ParameterType.string:
+                return `$${paramName}::TEXT`;
+            case ParameterType.boolean:
+                return `$${paramName}::BOOL`;
+            case ParameterType.smallint:
+                return `$${paramName}::SMALLINT`;
+            case 0:
+                return `$${paramName}::NUMERIC`;
+            default: throw new Error(`Nieznany typ parametru: ${paramName} typu: ${paramType} `);
+        }
+    }
+    static getBaseTypeForArrayType(paramType) {
+        switch (paramType) {
+            case ParameterType.arrayNumber:
+                return ParameterType.number;
+            case ParameterType.arrayString:
+                return ParameterType.string;
+            case ParameterType.arrayBoolean:
+                return ParameterType.boolean;
+            default: throw new Error(`Nieznany typ  podstawowy dla typu: ${paramType} `);
+        }
+    }
+    static getOperatorForType(type) {
+        switch (type) {
+            case ParameterType.string:
+                return 'ILIKE';
+            default: return `=`;
+        }
+    }
+}

package/dist/query/QueryParams.d.ts

@@ -0,0 +1,20 @@
+import ParameterI from '../types/ParameterI';
+import QueryOptionsI from '../types/QueryOptionsI';
+export default class QueryParams {
+    private static where;
+    private static params;
+    private static order;
+    private static limit;
+    private static values;
+    private static paramConnector;
+    static createParams(queryString: string, options: QueryOptionsI): string;
+    static createValuesParams(sql: string, values: ParameterI[]): string;
+    private static createValueParams;
+    private static createWhereParams;
+    private static createOrderParams;
+    private static createLimitParams;
+    private static createParamsSql;
+    private static removeWhereVariable;
+    private static splitSql;
+    private static getWhereConnector;
+}