@dascompany/database 3.0.0 → 3.0.2

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

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

package/dist/mappers/DeliveryMethodsMapper.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class DeliveryMethodsMapper {
+    deliveryMethods;
+    deliveryMethodsTable;
+    constructor(deliveryMethods) {
+        this.deliveryMethodsTable = DatabaseConnection.get().deliveryMethods;
+        this.deliveryMethods = deliveryMethods;
+    }
+    async save() {
+        if (this.deliveryMethods.getId())
+            await this.deliveryMethodsTable.update(this.deliveryMethods);
+        else
+            await this.deliveryMethodsTable.insert(this.deliveryMethods);
+    }
+    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/FileConnectionMapper.d.ts

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

package/dist/mappers/FileConnectionMapper.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from '../DatabaseConnection';
+export default class FileConnectionMapper {
+    fileConnection;
+    fileConnectionsTable;
+    constructor(fileConnection) {
+        this.fileConnectionsTable = DatabaseConnection.get().fileConnections;
+        this.fileConnection = fileConnection;
+    }
+    async save() {
+        const id = this.fileConnection.getId();
+        if (id)
+            await this.fileConnectionsTable.delete(id);
+        await this.fileConnectionsTable.insert(this.fileConnection);
+    }
+    async delete() {
+    }
+}

package/dist/mappers/FileMapper.d.ts

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

package/dist/mappers/FileMapper.js

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

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

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

package/dist/mappers/PaymentMethodsMapper.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class PaymentMethodsMapper {
+    paymentMethods;
+    paymentMethodsTable;
+    constructor(paymentMethods) {
+        this.paymentMethodsTable = DatabaseConnection.get().paymentMethods;
+        this.paymentMethods = paymentMethods;
+    }
+    async save() {
+        if (this.paymentMethods.getId())
+            await this.paymentMethodsTable.update(this.paymentMethods);
+        else
+            await this.paymentMethodsTable.insert(this.paymentMethods);
+    }
+    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/ProductMapper.d.ts

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

package/dist/mappers/ProductMapper.js

@@ -0,0 +1,20 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class ProductMapper {
+    product;
+    productTable;
+    constructor(product) {
+        this.productTable = DatabaseConnection.get().products;
+        this.product = product;
+    }
+    async save() {
+        if (this.product.getId() && !this.product.getDeleted())
+            await this.productTable.update(this.product);
+        else
+            await this.productTable.insert(this.product);
+    }
+    async delete() {
+        const id = this.product.getId();
+        if (id)
+            await this.productTable.delete(id);
+    }
+}

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/QueryParamCreator.js

@@ -61,6 +61,8 @@ export default class QueryParamCreator {
     }
     static getBaseTypeForComplexType(paramType) {
         switch (paramType) {
+            case ParameterType.arrayBigint:
+                return ParameterType.bigint;
             case ParameterType.arrayNumber:
                 return ParameterType.number;
             case ParameterType.betweenNumber:

package/dist/query/QueryParams.js

@@ -9,14 +9,16 @@ export default class QueryParams {
         if (orderBy)
             queryString = QueryParams.createOrderParams(queryString, orderBy);
         if (limit)
-            queryString += `LIMIT $limit::BIGINT OFFSET $offset::BIGINT`;
+            queryString += ` LIMIT $limit::BIGINT OFFSET $offset::BIGINT`;
         return queryString;
     }
     static createWhereParams(sql, where) {
         const params = this.createParamsSql(where.parameters);
         const connector = 'WHERE';
-        const sqlWithParams = `${sql} ${connector} ${params.join(` ${where.connector} `)}`;
-        return sqlWithParams;
+        if (params.length > 0)
+            return `${sql} ${connector} ${params.join(` ${where.connector} `)}`;
+        else
+            return sql;
     }
     static createParamsSql(parameters) {
         let sqlParams = [];

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,13 @@
+import QueryOptions from "../query/QueryOptions";
+import ClientAccountI from "../types/ClientAccountI";
+export default class ClientAccountReader {
+    static get(accountId: number): Promise<ClientAccountI>;
+    static getAll(queryOptions: QueryOptions): Promise<{
+        clientAccounts: ClientAccountI[];
+        quantity: number;
+    }>;
+    static getForEmail(email: string): Promise<ClientAccountI>;
+    static getIdForEmail(email: string): Promise<number>;
+    private static correctClientsFromRows;
+    private static correctData;
+}

package/dist/reader/ClientAccountReader.js

@@ -0,0 +1,47 @@
+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 getAll(queryOptions) {
+        const connection = DatabaseConnection.get();
+        const clientAccounts = await connection.accounts.selectAll(queryOptions);
+        const quantity = await connection.accounts.count(queryOptions);
+        return {
+            clientAccounts: this.correctClientsFromRows(clientAccounts),
+            quantity
+        };
+    }
+    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.getIdForEmail(email);
+        return accountId;
+    }
+    static correctClientsFromRows(dataRows) {
+        const clients = [];
+        for (const dataRow of dataRows) {
+            const client = this.correctData(dataRow);
+            clients.push(client);
+        }
+        return clients;
+    }
+    static correctData(client) {
+        return {
+            id: client.id,
+            email: client.email,
+            createdAt: client.created_at,
+            activated: client.activated,
+            deleted: client.deleted,
+            contactDetailsId: client.contact_details_id,
+            deliveryDetailsId: client.delivery_details_id,
+            invoiceDetailsId: client.invoice_details_id,
+        };
+    }
+}

package/dist/reader/CompanyDataReader.d.ts

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

package/dist/reader/CompanyDataReader.js

@@ -0,0 +1,27 @@
+import DatabaseConnection from "../DatabaseConnection";
+import AddressesReader from "./AddressesReader";
+export default class CompanyDataReader {
+    static async get() {
+        const connection = DatabaseConnection.get();
+        const companyData = await connection.companyData.select();
+        if (companyData) {
+            const address = companyData?.address_id ? await AddressesReader.get(companyData.address_id) : null;
+            return {
+                id: companyData.id,
+                name: companyData.name,
+                taxNumber: companyData.tax_number,
+                phoneNumber: companyData.phone_number,
+                address: address
+            };
+        }
+        else {
+            return {
+                id: 0,
+                name: '',
+                taxNumber: '',
+                phoneNumber: '',
+                address: null
+            };
+        }
+    }
+}

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,6 @@
+import DeliveryMethodI from "../types/DeliveryMethodI";
+export default class DeliveryMethodReader {
+    static get(id: number): Promise<DeliveryMethodI>;
+    static getAll(): Promise<DeliveryMethodI[]>;
+    static getAllActive(): Promise<DeliveryMethodI[]>;
+}