@dascompany/product 1.1.1 → 1.1.3

package/dist/{ProductsSchema.d.ts → DatabaseConnection.d.ts}

@@ -1,4 +1,3 @@
-import { Connection } from '@dascompany/database';
 import StatusTypesTable from './tables/orders/StatusTypesTable';
 import FilesTable from './tables/files/FilesTable';
 import OrdersTable from './tables/orders/OrdersTable';
@@ -22,10 +21,12 @@ import PaymentStatusesTable from './tables/orders/PaymentStatusesTable';
 import CompanyDataTable from './tables/settings/CompanyDataTable';
 import FileConnectionsTable from './tables/files/FileConnectionsTable';
 import AdminAccountsTable from './tables/public/AdminAccountsTable';
-export default class ProductsSchema {
+export default class DatabaseConnection {
+    static instance: DatabaseConnection;
     private tables;
     private connection;
-    constructor(connection: Connection);
+    private constructor();
+    static getInstance(): DatabaseConnection;
     get statusTypes(): StatusTypesTable;
     get files(): FilesTable;
     get orders(): OrdersTable;

package/dist/{ProductsSchema.js → DatabaseConnection.js}

@@ -1,3 +1,4 @@
+import { ConnectionFactory } from '@dascompany/database';
 import StatusTypesTable from './tables/orders/StatusTypesTable';
 import TableNames from './tables/TableNames';
 import FilesTable from './tables/files/FilesTable';
@@ -22,12 +23,18 @@ import PaymentStatusesTable from './tables/orders/PaymentStatusesTable';
 import CompanyDataTable from './tables/settings/CompanyDataTable';
 import FileConnectionsTable from './tables/files/FileConnectionsTable';
 import AdminAccountsTable from './tables/public/AdminAccountsTable';
-export default class ProductsSchema {
+export default class DatabaseConnection {
+    static instance;
     tables = new Map();
     connection;
     constructor(connection) {
         this.connection = connection;
     }
+    static getInstance() {
+        (!this.instance);
+        this.instance = new DatabaseConnection(ConnectionFactory.get());
+        return this.instance;
+    }
     get statusTypes() {
         if (!this.tables.get(TableNames.statusTypes))
             this.tables.set(TableNames.statusTypes, new StatusTypesTable(this.connection));

package/dist/mappers/AddressMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class AddressMapper {
     address;
     addressesTable;
     constructor(address) {
-        this.addressesTable = ProductConnectionFactory.get().productsSchema.addresses;
+        this.addressesTable = DatabaseConnection.getInstance().addresses;
         this.address = address;
     }
     async save() {

package/dist/mappers/AdminMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from '../ProductConnectionFactory';
+import DatabaseConnection from '../DatabaseConnection';
 export default class AdminMapper {
     admin;
     adminAccountsTable;
     constructor(admin) {
-        this.adminAccountsTable = ProductConnectionFactory.get().productsSchema.adminAccounts;
+        this.adminAccountsTable = DatabaseConnection.getInstance().adminAccounts;
         this.admin = admin;
     }
     async save() {

package/dist/mappers/ClientMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class ClientMapper {
     client;
     clientAccountsTable;
     constructor(client) {
-        this.clientAccountsTable = ProductConnectionFactory.get().productsSchema.clientAccounts;
+        this.clientAccountsTable = DatabaseConnection.getInstance().clientAccounts;
         this.client = client;
     }
     async save() {

package/dist/mappers/CompanyDataMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class CompanyDataMapper {
     companyData;
     companyDataTable;
     constructor(companyData) {
-        this.companyDataTable = ProductConnectionFactory.get().productsSchema.companyData;
+        this.companyDataTable = DatabaseConnection.getInstance().companyData;
         this.companyData = companyData;
     }
     async save() {

package/dist/mappers/CompanyDetailsMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class CompanyDetailsMapper {
     companyDetails;
     companyDetailsTable;
     constructor(companyDetails) {
-        this.companyDetailsTable = ProductConnectionFactory.get().productsSchema.companyDetails;
+        this.companyDetailsTable = DatabaseConnection.getInstance().companyDetails;
         this.companyDetails = companyDetails;
     }
     async save() {

package/dist/mappers/ContactDetailsMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class ContactDetailsMapper {
     contactDetails;
     contactDetailsTable;
     constructor(contactDetails) {
-        this.contactDetailsTable = ProductConnectionFactory.get().productsSchema.contactDetails;
+        this.contactDetailsTable = DatabaseConnection.getInstance().contactDetails;
         this.contactDetails = contactDetails;
     }
     async save() {

package/dist/mappers/DeliveryDetailsMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class DeliveryDetailsMapper {
     deliveryDetails;
     deliveryDetailsTable;
     constructor(deliveryDetails) {
-        this.deliveryDetailsTable = ProductConnectionFactory.get().productsSchema.deliveryDetails;
+        this.deliveryDetailsTable = DatabaseConnection.getInstance().deliveryDetails;
         this.deliveryDetails = deliveryDetails;
     }
     async save() {

package/dist/mappers/DeliveryMethodsMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class DeliveryMethodsMapper {
     deliveryMethods;
     deliveryMethodsTable;
     constructor(deliveryMethods) {
-        this.deliveryMethodsTable = ProductConnectionFactory.get().productsSchema.deliveryMethods;
+        this.deliveryMethodsTable = DatabaseConnection.getInstance().deliveryMethods;
         this.deliveryMethods = deliveryMethods;
     }
     async save() {

package/dist/mappers/DeliveryStatusMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class DeliveryStatusMapper {
     deliveryStatus;
     deliveryStatusesTable;
     constructor(deliveryStatus) {
-        this.deliveryStatusesTable = ProductConnectionFactory.get().productsSchema.deliveryStatuses;
+        this.deliveryStatusesTable = DatabaseConnection.getInstance().deliveryStatuses;
         this.deliveryStatus = deliveryStatus;
     }
     async save() {

package/dist/mappers/FileConnectionMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from '../ProductConnectionFactory';
+import DatabaseConnection from '../DatabaseConnection';
 export default class FileConnectionMapper {
     fileConnection;
     fileConnectionsTable;
     constructor(fileConnection) {
-        this.fileConnectionsTable = ProductConnectionFactory.get().productsSchema.fileConnections;
+        this.fileConnectionsTable = DatabaseConnection.getInstance().fileConnections;
         this.fileConnection = fileConnection;
     }
     async save() {

package/dist/mappers/FileMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class FileMapper {
     file;
     filesTable;
     constructor(file) {
-        this.filesTable = ProductConnectionFactory.get().productsSchema.files;
+        this.filesTable = DatabaseConnection.getInstance().files;
         this.file = file;
     }
     async save() {

package/dist/mappers/InvoiceDetailsMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from '../ProductConnectionFactory';
+import DatabaseConnection from '../DatabaseConnection';
 export default class InvoiceDetailsMapper {
     invoiceDetails;
     invoiceDetailsTable;
     constructor(invoiceDetails) {
-        this.invoiceDetailsTable = ProductConnectionFactory.get().productsSchema.invoiceDetails;
+        this.invoiceDetailsTable = DatabaseConnection.getInstance().invoiceDetails;
         this.invoiceDetails = invoiceDetails;
     }
     async save() {

package/dist/mappers/OrderMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class OrderMapper {
     order;
     orderTable;
     constructor(order) {
-        this.orderTable = ProductConnectionFactory.get().productsSchema.orders;
+        this.orderTable = DatabaseConnection.getInstance().orders;
         this.order = order;
     }
     async save() {

package/dist/mappers/OrderProductMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class OrderProductMapper {
     orderProduct;
     orderProductsTable;
     constructor(orderProduct) {
-        this.orderProductsTable = ProductConnectionFactory.get().productsSchema.ordersProducts;
+        this.orderProductsTable = DatabaseConnection.getInstance().ordersProducts;
         this.orderProduct = orderProduct;
     }
     async save() {

package/dist/mappers/PaymentDetailsMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class PaymentDetailsMapper {
     paymentDetails;
     paymentDetailsTable;
     constructor(paymentDetails) {
-        this.paymentDetailsTable = ProductConnectionFactory.get().productsSchema.paymentDetails;
+        this.paymentDetailsTable = DatabaseConnection.getInstance().paymentDetails;
         this.paymentDetails = paymentDetails;
     }
     async save() {

package/dist/mappers/PaymentMethodsMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class PaymentMethodsMapper {
     paymentMethods;
     paymentMethodsTable;
     constructor(paymentMethods) {
-        this.paymentMethodsTable = ProductConnectionFactory.get().productsSchema.paymentMethods;
+        this.paymentMethodsTable = DatabaseConnection.getInstance().paymentMethods;
         this.paymentMethods = paymentMethods;
     }
     async save() {

package/dist/mappers/PaymentStatusMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class PaymentStatusMapper {
     paymentStatus;
     paymentStatusesTable;
     constructor(paymentStatus) {
-        this.paymentStatusesTable = ProductConnectionFactory.get().productsSchema.paymentStatuses;
+        this.paymentStatusesTable = DatabaseConnection.getInstance().paymentStatuses;
         this.paymentStatus = paymentStatus;
     }
     async save() {

package/dist/mappers/PersonalDataMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class PersonalDataMapper {
     personalData;
     personalDataTable;
     constructor(personalData) {
-        this.personalDataTable = ProductConnectionFactory.get().productsSchema.personalData;
+        this.personalDataTable = DatabaseConnection.getInstance().personalData;
         this.personalData = personalData;
     }
     async save() {

package/dist/mappers/ProductMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class ProductMapper {
     product;
     productTable;
     constructor(product) {
-        this.productTable = ProductConnectionFactory.get().productsSchema.products;
+        this.productTable = DatabaseConnection.getInstance().products;
         this.product = product;
     }
     async save() {

package/dist/mappers/StatusMapper.js

@@ -1,9 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class StatusMapper {
     status;
     statusTable;
     constructor(status) {
-        this.statusTable = ProductConnectionFactory.get().productsSchema.statuses;
+        this.statusTable = DatabaseConnection.getInstance().statuses;
         this.status = status;
     }
     async save() {

package/dist/reader/AddressesReader.js

@@ -1,13 +1,11 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class AddressesReader {
     static async get(addressId) {
-        const connection = ProductConnectionFactory.get();
-        const address = await connection.productsSchema.addresses.select(addressId);
+        const address = await DatabaseConnection.getInstance().addresses.select(addressId);
         return this.getCorrectData(address);
     }
     static async getCompanyAddress() {
-        const connection = ProductConnectionFactory.get();
-        const address = await connection.productsSchema.addresses.select(1);
+        const address = await DatabaseConnection.getInstance().addresses.select(1);
         return this.getCorrectData(address);
     }
     static getCorrectData(address) {

package/dist/reader/AdminReader.js

@@ -1,18 +1,15 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class AdminReader {
     static async get(accountId) {
-        const connection = ProductConnectionFactory.get();
-        const account = await connection.productsSchema.adminAccounts.select(accountId);
+        const account = await DatabaseConnection.getInstance().adminAccounts.select(accountId);
         return this.correctAdmin(account);
     }
     static async getIdForEmail(email) {
-        const connection = ProductConnectionFactory.get();
-        return await connection.productsSchema.adminAccounts.selectForEmail(email);
+        return await DatabaseConnection.getInstance().adminAccounts.selectForEmail(email);
     }
     static async getAll(queryOptions) {
-        const connection = ProductConnectionFactory.get();
-        const adminAccounts = await connection.productsSchema.adminAccounts.selectAll(queryOptions);
-        const quantity = await connection.productsSchema.adminAccounts.count(queryOptions);
+        const adminAccounts = await DatabaseConnection.getInstance().adminAccounts.selectAll(queryOptions);
+        const quantity = await DatabaseConnection.getInstance().adminAccounts.count(queryOptions);
         return {
             adminAccounts: this.correctAdmins(adminAccounts),
             quantity

package/dist/reader/ClientAccountReader.js

@@ -1,27 +1,23 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class ClientAccountReader {
     static async get(accountId) {
-        const connection = ProductConnectionFactory.get();
-        const account = await connection.productsSchema.clientAccounts.select(accountId);
+        const account = await DatabaseConnection.getInstance().clientAccounts.select(accountId);
         return this.correctData(account);
     }
     static async getAll(queryOptions) {
-        const connection = ProductConnectionFactory.get();
-        const clientAccounts = await connection.productsSchema.clientAccounts.selectAll(queryOptions);
-        const quantity = await connection.productsSchema.clientAccounts.count(queryOptions);
+        const clientAccounts = await DatabaseConnection.getInstance().clientAccounts.selectAll(queryOptions);
+        const quantity = await DatabaseConnection.getInstance().clientAccounts.count(queryOptions);
         return {
             clientAccounts: this.correctClientsFromRows(clientAccounts),
             quantity
         };
     }
     static async getForEmail(email) {
-        const connection = ProductConnectionFactory.get();
-        const account = await connection.productsSchema.clientAccounts.selectForEmail(email);
+        const account = await DatabaseConnection.getInstance().clientAccounts.selectForEmail(email);
         return this.correctData(account);
     }
     static async getIdForEmail(email) {
-        const connection = ProductConnectionFactory.get();
-        const accountId = await connection.productsSchema.clientAccounts.getIdForEmail(email);
+        const accountId = await DatabaseConnection.getInstance().clientAccounts.getIdForEmail(email);
         return accountId;
     }
     static correctClientsFromRows(dataRows) {

package/dist/reader/CompanyDataReader.js

@@ -1,9 +1,8 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import AddressesReader from "./AddressesReader";
 export default class CompanyDataReader {
     static async get() {
-        const connection = ProductConnectionFactory.get();
-        const companyData = await connection.productsSchema.companyData.select();
+        const companyData = await DatabaseConnection.getInstance().companyData.select();
         if (companyData) {
             const address = companyData?.address_id ? await AddressesReader.get(companyData.address_id) : null;
             return {

package/dist/reader/CompanyDetailsReader.js

@@ -1,8 +1,7 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class CompanyDetailsReader {
     static async get(companyDetailsId) {
-        const connection = ProductConnectionFactory.get();
-        const companyDetails = await connection.productsSchema.companyDetails.select(companyDetailsId);
+        const companyDetails = await DatabaseConnection.getInstance().companyDetails.select(companyDetailsId);
         if (companyDetails)
             return {
                 id: companyDetails.id,

package/dist/reader/ContactDetailsReader.js

@@ -1,10 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import AddressesReader from "./AddressesReader";
 import PersonalDataReader from "./PersonalDataReader";
 export default class ContactDetailsReader {
     static async get(contactDetailsId) {
-        const connection = ProductConnectionFactory.get();
-        const contactDetails = await connection.productsSchema.contactDetails.select(contactDetailsId);
+        const contactDetails = await DatabaseConnection.getInstance().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 {

package/dist/reader/DeliveryDetailsReader.js

@@ -1,11 +1,10 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import AddressesReader from "./AddressesReader";
 import DeliveryMethodReader from "./DeliveryMethodReader";
 import PersonalDataReader from "./PersonalDataReader";
 export default class DeliveryDetailsReader {
     static async get(deliveryDetailsId) {
-        const connection = ProductConnectionFactory.get();
-        const deliveryDetails = await connection.productsSchema.deliveryDetails.select(deliveryDetailsId);
+        const deliveryDetails = await DatabaseConnection.getInstance().deliveryDetails.select(deliveryDetailsId);
         const id = deliveryDetails.id;
         let personalData = null;
         let address = null;

package/dist/reader/DeliveryMethodReader.js

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

package/dist/reader/DeliveryStatusReader.js

@@ -1,16 +1,14 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class DeliveryStatusReader {
     static async get(deliveryDetailsId) {
-        const connection = ProductConnectionFactory.get();
-        const deliveryStatus = await connection.productsSchema.deliveryStatuses.select(deliveryDetailsId);
+        const deliveryStatus = await DatabaseConnection.getInstance().deliveryStatuses.select(deliveryDetailsId);
         if (deliveryStatus)
             return await this.correctDeliveryStatus(deliveryStatus);
         else
             return {};
     }
     static async getAll(deliveryDetailsId) {
-        const connection = ProductConnectionFactory.get();
-        const deliveryStatusesData = await connection.productsSchema.deliveryStatuses.selectAll(deliveryDetailsId);
+        const deliveryStatusesData = await DatabaseConnection.getInstance().deliveryStatuses.selectAll(deliveryDetailsId);
         const deliveryStatuses = [];
         for (let i = 0; i < deliveryStatusesData.length; i++) {
             const deliveryStatus = await this.correctDeliveryStatus(deliveryStatusesData[i]);
@@ -19,8 +17,7 @@ export default class DeliveryStatusReader {
         return deliveryStatuses;
     }
     static async correctDeliveryStatus(deliveryStatus) {
-        const connection = ProductConnectionFactory.get();
-        const deliveryStatusType = await connection.productsSchema.deliveryStatusTypes.select(deliveryStatus.delivery_status_type_id);
+        const deliveryStatusType = await DatabaseConnection.getInstance().deliveryStatusTypes.select(deliveryStatus.delivery_status_type_id);
         return {
             id: deliveryStatus.id,
             type: deliveryStatusType,

package/dist/reader/FileConnectionsReader.js

@@ -1,8 +1,7 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class FileConnectionsReader {
     static async getAllForFileId(fileId) {
-        const connection = ProductConnectionFactory.get();
-        const fileConnections = await connection.productsSchema.fileConnections.selectForFileId(fileId);
+        const fileConnections = await DatabaseConnection.getInstance().fileConnections.selectForFileId(fileId);
         return this.correctFileConnections(fileConnections);
     }
     static correctFileConnections(fileConnectionsRows) {

package/dist/reader/FilesReader.js

@@ -1,28 +1,23 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class FilesReader {
     static async get(fileId) {
-        const connection = ProductConnectionFactory.get();
-        const file = await connection.productsSchema.files.select(fileId);
+        const file = await DatabaseConnection.getInstance().files.select(fileId);
         return this.correctFile(file);
     }
     static async getAll(queryOptions) {
-        const connection = ProductConnectionFactory.get();
-        const file = await connection.productsSchema.files.selectAll(queryOptions);
+        const file = await DatabaseConnection.getInstance().files.selectAll(queryOptions);
         return this.correctFiles(file);
     }
     static async isExist(queryOptions) {
-        const connection = ProductConnectionFactory.get();
-        const fileId = await connection.productsSchema.files.selectId(queryOptions);
+        const fileId = await DatabaseConnection.getInstance().files.selectId(queryOptions);
         return fileId;
     }
     static async getQuantity(queryOptions) {
-        const connection = ProductConnectionFactory.get();
-        const quantity = await connection.productsSchema.files.count(queryOptions);
+        const quantity = await DatabaseConnection.getInstance().files.count(queryOptions);
         return quantity;
     }
     static async getForConnection(connectionType, connectionId) {
-        const connection = ProductConnectionFactory.get();
-        const files = await connection.productsSchema.files.selectForConnection(connectionType, connectionId);
+        const files = await DatabaseConnection.getInstance().files.selectForConnection(connectionType, connectionId);
         return this.correctFiles(files);
     }
     static correctFiles(fileRows) {

package/dist/reader/InvoiceDetailsReader.js

@@ -1,10 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import AddressesReader from "./AddressesReader";
 import PersonalDataReader from "./PersonalDataReader";
 export default class InvoiceDetailsReader {
     static async get(invoiceDetailsId) {
-        const connection = ProductConnectionFactory.get();
-        const invoiceDetails = await connection.productsSchema.invoiceDetails.select(invoiceDetailsId);
+        const invoiceDetails = await DatabaseConnection.getInstance().invoiceDetails.select(invoiceDetailsId);
         const id = invoiceDetails.id;
         let personalData = null;
         let address = null;

package/dist/reader/OrderProductsReader.js

@@ -1,16 +1,14 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import calculateNetToGrossPrice from "../utils/calculateNetToGrossPrice";
 import FilesReader from "./FilesReader";
 export default class OrderProductsReader {
     static async getAll(orderId) {
-        const connection = ProductConnectionFactory.get();
-        const orderProducts = await connection.productsSchema.ordersProducts.selectAllActive(orderId);
+        const orderProducts = await DatabaseConnection.getInstance().ordersProducts.selectAllActive(orderId);
         const correctProducts = await this.correctOrderProducts(orderProducts);
         return correctProducts;
     }
     static async getForOrder(orderId) {
-        const connection = ProductConnectionFactory.get();
-        const products = await connection.productsSchema.ordersProducts.selectAllActive(orderId);
+        const products = await DatabaseConnection.getInstance().ordersProducts.selectAllActive(orderId);
         const correctProducts = [];
         for (let i = 0; i < products.length; i++) {
             const correctProduct = {

package/dist/reader/OrderReader.js

@@ -1,15 +1,13 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import OrderProductsReader from "./OrderProductsReader";
 import OrderStatusReader from "./OrderStatusReader";
 export default class OrderReader {
     static async get(orderId) {
-        const connection = ProductConnectionFactory.get();
-        const orderData = await connection.productsSchema.orders.select(orderId);
+        const orderData = await DatabaseConnection.getInstance().orders.select(orderId);
         return this.correctOrder(orderData);
     }
     static async getForClient(clientAccountId) {
-        const connection = ProductConnectionFactory.get();
-        const orders = await connection.productsSchema.orders.selectForClient(clientAccountId);
+        const orders = await DatabaseConnection.getInstance().orders.selectForClient(clientAccountId);
         const correctOrders = [];
         for (let i = 0; i < orders.length; i++) {
             const correctOrder = await this.correctOrder(orders[i]);
@@ -19,9 +17,8 @@ export default class OrderReader {
         return correctOrders;
     }
     static async getAll(queryOptions) {
-        const connection = ProductConnectionFactory.get();
-        const orderRows = await connection.productsSchema.orders.selectAll(queryOptions);
-        const quantity = await connection.productsSchema.orders.count(queryOptions);
+        const orderRows = await DatabaseConnection.getInstance().orders.selectAll(queryOptions);
+        const quantity = await DatabaseConnection.getInstance().orders.count(queryOptions);
         const orders = await this.correctOrders(orderRows);
         return { orders, quantity };
     }