@dascompany/product 1.1.2 → 1.1.4

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 };
     }

package/dist/reader/OrderStatusReader.js

@@ -1,13 +1,11 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class OrderStatusReader {
     static async get(orderId) {
-        const connection = ProductConnectionFactory.get();
-        const statusRow = await connection.productsSchema.statuses.select(orderId);
+        const statusRow = await DatabaseConnection.getInstance().statuses.select(orderId);
         return this.correctStatus(statusRow);
     }
     static async getAll(orderId) {
-        const connection = ProductConnectionFactory.get();
-        const statuses = await connection.productsSchema.statuses.selectAll(orderId);
+        const statuses = await DatabaseConnection.getInstance().statuses.selectAll(orderId);
         const correctStatuss = [];
         for (let i = 0; i < statuses.length; i++) {
             const correctStatus = this.correctStatus(statuses[i]);

package/dist/reader/PersonalDataReader.js

@@ -1,10 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import correctPhoneNumber from "../utils/correctPhoneNumber";
 import CompanyDetailsReader from "./CompanyDetailsReader";
 export default class PersonalDataReader {
     static async get(personalDataId) {
-        const connection = ProductConnectionFactory.get();
-        const personalDataRow = await connection.productsSchema.personalData.select(personalDataId);
+        const personalDataRow = await DatabaseConnection.getInstance().personalData.select(personalDataId);
         const personalData = this.correctPersonalData(personalDataRow);
         if (personalDataRow.company_details_id) {
             personalData.companyDetails = await CompanyDetailsReader.get(personalDataRow.company_details_id);

package/dist/reader/ProductReader.js

@@ -1,32 +1,27 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
 import FileConnectionTypeE from "../types/FileConnectionTypeE";
 import calculateNetToGrossPrice from "../utils/calculateNetToGrossPrice";
 import FilesReader from "./FilesReader";
+import DatabaseConnection from "../DatabaseConnection";
 export default class ProductReader {
     static async get(productId) {
-        const connection = await ProductConnectionFactory.get();
-        const product = await connection.productsSchema.products.select(productId);
+        const product = await DatabaseConnection.getInstance().products.select(productId);
         const files = await FilesReader.getForConnection(FileConnectionTypeE.product, product.id);
         return this.correctProduct(product, files);
     }
     static async getForUrl(productUrl) {
-        const connection = await ProductConnectionFactory.get();
-        const product = await connection.productsSchema.products.selectForUrl(productUrl);
+        const product = await DatabaseConnection.getInstance().products.selectForUrl(productUrl);
         const files = await FilesReader.getForConnection(FileConnectionTypeE.product, product.id);
         return this.correctProduct(product, files);
     }
     static async getAllActive(queryOptions) {
-        const connection = await ProductConnectionFactory.get();
-        const products = await connection.productsSchema.products.selectAllActive(queryOptions);
+        const products = await DatabaseConnection.getInstance().products.selectAllActive(queryOptions);
         return this.correctProducts(products);
     }
     static async getIdForSku(productSku) {
-        const connection = await ProductConnectionFactory.get();
-        return await connection.productsSchema.products.selectIdForSku(productSku);
+        return await DatabaseConnection.getInstance().products.selectIdForSku(productSku);
     }
     static async getQuantity(queryOptions) {
-        const connection = await ProductConnectionFactory.get();
-        const quantity = await connection.productsSchema.products.count(queryOptions);
+        const quantity = await DatabaseConnection.getInstance().products.count(queryOptions);
         return quantity;
     }
     static async correctProducts(products) {

package/dist/reader/StatusTypesReader.js

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

package/dist/reader/payment/PaymentDetailsReader.js

@@ -1,15 +1,13 @@
-import ProductConnectionFactory from "../../ProductConnectionFactory";
+import DatabaseConnection from "../../DatabaseConnection";
 import PaymentMethodReader from "./PaymentMethodReader";
 import PaymentStatusesReader from "./PaymentStatusesReader";
 export default class PaymentDetailsReader {
     static async get(paymentDetailsId) {
-        const connection = ProductConnectionFactory.get();
-        const paymentDetails = await connection.productsSchema.paymentDetails.select(paymentDetailsId);
+        const paymentDetails = await DatabaseConnection.getInstance().paymentDetails.select(paymentDetailsId);
         return await this.correctPaymentDetails(paymentDetails);
     }
     static async getPaymentOrderId(paymentDetailsId) {
-        const connection = ProductConnectionFactory.get();
-        const paymentDetails = await connection.productsSchema.paymentDetails.select(paymentDetailsId);
+        const paymentDetails = await DatabaseConnection.getInstance().paymentDetails.select(paymentDetailsId);
         return paymentDetails.payment_order_id;
     }
     static async correctPaymentDetails(paymentDetails) {

package/dist/reader/payment/PaymentMethodReader.js

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

package/dist/reader/payment/PaymentStatusesReader.js

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

package/dist/repo/AddressesRepo.js

@@ -1,9 +1,8 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import Address from "../stockObjects/Address";
 export default class AddressesRepo {
     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.createAddressFromRow(address);
     }
     static createAddressFromRow(dataRow) {

package/dist/repo/AdminRepo.js

@@ -1,19 +1,16 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import Admin from "../stockObjects/Admin";
 export default class AdminRepo {
     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.createAdminFromRow(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.createAdminsFromRows(adminAccounts), quantity };
     }
     static createAdminsFromRows(dataRows) {

package/dist/repo/ClientAccountRepo.js

@@ -1,19 +1,16 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import Client from "../stockObjects/Client";
 export default class ClientAccountRepo {
     static async get(accountId) {
-        const connection = ProductConnectionFactory.get();
-        const accountData = await connection.productsSchema.clientAccounts.select(accountId);
+        const accountData = await DatabaseConnection.getInstance().clientAccounts.select(accountId);
         return this.createCilentAccountFromRow(accountData);
     }
     static async getById(clientId) {
-        const connection = ProductConnectionFactory.get();
-        const client = await connection.productsSchema.clientAccounts.select(clientId);
+        const client = await DatabaseConnection.getInstance().clientAccounts.select(clientId);
         return this.createCilentAccountFromRow(client);
     }
     static async getEmailForId(clientId) {
-        const connection = ProductConnectionFactory.get();
-        const email = await connection.productsSchema.clientAccounts.selectEmail(clientId);
+        const email = await DatabaseConnection.getInstance().clientAccounts.selectEmail(clientId);
         return email;
     }
     static createCilentAccountFromRow(accountData) {

package/dist/repo/CompanyDataRepo.js

@@ -1,9 +1,8 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import CompanyData from "../stockObjects/CompanyData";
 export default class CompanyDataRepo {
     static async get() {
-        const connection = ProductConnectionFactory.get();
-        const companyDataRow = await connection.productsSchema.companyData.select();
+        const companyDataRow = await DatabaseConnection.getInstance().companyData.select();
         const companyData = new CompanyData(companyDataRow.name, companyDataRow.tax_number, companyDataRow.phone_number, companyDataRow.email, companyDataRow.address_id);
         companyData.setId(companyDataRow.id);
         return companyData;

package/dist/repo/CompanyDetailsRepo.js

@@ -1,9 +1,8 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import CompanyDetails from "../stockObjects/CompanyDetails";
 export default class CompanyDetailsRepo {
     static async get(id) {
-        const connection = ProductConnectionFactory.get();
-        const companyDetailsRow = await connection.productsSchema.companyDetails.select(id);
+        const companyDetailsRow = await DatabaseConnection.getInstance().companyDetails.select(id);
         return this.createCompanyDetailsFromRow(companyDetailsRow);
     }
     static createCompanyDetailsFromRow(companyDetailsRow) {

package/dist/repo/ContactDetailsRepo.js

@@ -1,14 +1,12 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import ContactDetails from "../stockObjects/ContactDetails";
 export default class ContactDetailsRepo {
     static async get(contactDetailsId) {
-        const connection = ProductConnectionFactory.get();
-        const contactDetailsRow = await connection.productsSchema.contactDetails.select(contactDetailsId);
+        const contactDetailsRow = await DatabaseConnection.getInstance().contactDetails.select(contactDetailsId);
         return this.createContactDetailsFromRow(contactDetailsRow);
     }
     static async getNextId() {
-        const connection = ProductConnectionFactory.get();
-        const contactDetails = await connection.productsSchema.contactDetails.selectNextId();
+        const contactDetails = await DatabaseConnection.getInstance().contactDetails.selectNextId();
         return contactDetails;
     }
     static createContactDetailsFromRow(contactDetailsRow) {

package/dist/repo/DeliveryDetailsRepo.js

@@ -1,9 +1,8 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import DeliveryDetails from "../stockObjects/DeliveryDetails";
 export default class DeliveryDetailsRepo {
     static async get(deliveryDetailsId) {
-        const connection = ProductConnectionFactory.get();
-        const deliveryDetailsRow = await connection.productsSchema.deliveryDetails.select(deliveryDetailsId);
+        const deliveryDetailsRow = await DatabaseConnection.getInstance().deliveryDetails.select(deliveryDetailsId);
         return this.createDeliveryDetailsFromRow(deliveryDetailsRow);
     }
     static createDeliveryDetailsFromRow(deliveryDetailsRow) {

package/dist/repo/DeliveryMethodRepo.js

@@ -1,9 +1,8 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import DeliveryMethods from "../stockObjects/DeliveryMethods";
 export default class DeliveryMethodRepo {
     static async get(id) {
-        const connection = ProductConnectionFactory.get();
-        const deliveryMethodsRow = await connection.productsSchema.deliveryMethods.select(id);
+        const deliveryMethodsRow = await DatabaseConnection.getInstance().deliveryMethods.select(id);
         const deliveryMethods = new DeliveryMethods(deliveryMethodsRow.key, deliveryMethodsRow.active);
         deliveryMethods.setId(deliveryMethodsRow.id);
         return deliveryMethods;

package/dist/repo/FileConnectionsRepo.js

@@ -1,14 +1,12 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import FileConnection from "../stockObjects/FileConnection";
 export default class FileConnectionsRepo {
     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 async deleteAllForConnection(connectionType, connectionId) {
-        const connection = ProductConnectionFactory.get();
-        return await connection.productsSchema.fileConnections.deleteForConnection(connectionType, connectionId);
+        return await DatabaseConnection.getInstance().fileConnections.deleteForConnection(connectionType, connectionId);
     }
     static correctFileConnections(dataRows) {
         const fileConnections = [];

package/dist/repo/FilesRepo.js

@@ -1,14 +1,12 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import File from "../stockObjects/File";
 export default class FilesRepo {
     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.createFileFromRow(file);
     }
     static async getAllForConnection(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.createFilesFromRows(files);
     }
     static async createFilesFromRows(dataRows) {

package/dist/repo/InvoiceDetailsRepo.js

@@ -1,9 +1,8 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import InvoiceDetails from "../stockObjects/InvoiceDetails";
 export default class InvoiceDetailsRepo {
     static async get(invoiceDetailsId) {
-        const connection = ProductConnectionFactory.get();
-        const invoiceDetailsRow = await connection.productsSchema.invoiceDetails.select(invoiceDetailsId);
+        const invoiceDetailsRow = await DatabaseConnection.getInstance().invoiceDetails.select(invoiceDetailsId);
         return this.createInvoiceDetailsFromRow(invoiceDetailsRow);
     }
     static createInvoiceDetailsFromRow(invoiceDetailsRow) {

package/dist/repo/OrderProductsRepo.js

@@ -1,14 +1,12 @@
 import { ConnectorE, ParameterType } from "@dascompany/database";
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import OrderProduct from "../stockObjects/OrderProduct";
 export default class OrderProductsRepo {
     static async getAllActive(orderId) {
-        const connection = ProductConnectionFactory.get();
-        const orderProducts = await connection.productsSchema.ordersProducts.selectAllActive(orderId);
+        const orderProducts = await DatabaseConnection.getInstance().ordersProducts.selectAllActive(orderId);
         return this.createOrdersProductsFromRows(orderProducts);
     }
     static async getAllForIds(orderProductsIds) {
-        const connection = ProductConnectionFactory.get();
         const queryOptions = {
             where: {
                 connector: ConnectorE.and,
@@ -17,7 +15,7 @@ export default class OrderProductsRepo {
                 ]
             }
         };
-        const orderProducts = await connection.productsSchema.ordersProducts.selectAllForIds(queryOptions);
+        const orderProducts = await DatabaseConnection.getInstance().ordersProducts.selectAllForIds(queryOptions);
         return this.createOrdersProductsFromRows(orderProducts);
     }
     static async createOrdersProductsFromRows(dataRows) {

package/dist/repo/OrderRepo.js

@@ -1,9 +1,8 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import Order from "../stockObjects/Order";
 export default class OrderRepo {
     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.createOrderFromRow(orderData);
     }
     static createOrderFromRow(orderData) {

package/dist/repo/OrderStatusRepo.js

@@ -1,14 +1,12 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import Status from "../stockObjects/Status";
 export default class OrderStatusRepo {
     static async get(orderId) {
-        const connection = ProductConnectionFactory.get();
-        const status = await connection.productsSchema.statuses.select(orderId);
+        const status = await DatabaseConnection.getInstance().statuses.select(orderId);
         return this.createStatusFromRow(status);
     }
     static async getAll(orderId) {
-        const connection = ProductConnectionFactory.get();
-        const statuses = await connection.productsSchema.statuses.selectAll(orderId);
+        const statuses = await DatabaseConnection.getInstance().statuses.selectAll(orderId);
         return this.createStatusesFromRows(statuses);
     }
     static async createStatusesFromRows(dataRows) {

package/dist/repo/PaymentDetailsRepo.js

@@ -1,9 +1,8 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import PaymentDetails from "../stockObjects/PaymentDetails";
 export default class PaymentDetailsRepo {
     static async get(paymentDetailsId) {
-        const connection = ProductConnectionFactory.get();
-        const paymentDetailsRow = await connection.productsSchema.paymentDetails.select(paymentDetailsId);
+        const paymentDetailsRow = await DatabaseConnection.getInstance().paymentDetails.select(paymentDetailsId);
         return this.createPaymentDetailsFromRow(paymentDetailsRow);
     }
     static createPaymentDetailsFromRow(paymentDetailsRow) {

package/dist/repo/PaymentMethodRepo.js

@@ -1,9 +1,8 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import PaymentMethods from "../stockObjects/PaymentMethods";
 export default class PaymentMethodRepo {
     static async get(id) {
-        const connection = ProductConnectionFactory.get();
-        const paymentMethodsRow = await connection.productsSchema.paymentMethods.select(id);
+        const paymentMethodsRow = await DatabaseConnection.getInstance().paymentMethods.select(id);
         const paymentMethods = new PaymentMethods(paymentMethodsRow.key, paymentMethodsRow.active);
         paymentMethods.setId(paymentMethodsRow.id);
         return paymentMethods;

package/dist/repo/PersonalDataRepo.js

@@ -1,10 +1,9 @@
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 import PersonalData from "../stockObjects/PersonalData";
 import correctPhoneNumber from "../utils/correctPhoneNumber";
 export default class PersonalDataRepo {
     static async get(personalDataId) {
-        const connection = ProductConnectionFactory.get();
-        const personalData = await connection.productsSchema.personalData.select(personalDataId);
+        const personalData = await DatabaseConnection.getInstance().personalData.select(personalDataId);
         return this.createPersonalDataFromRow(personalData);
     }
     static createPersonalDataFromRow(dataRow) {

package/dist/repo/ProductRepo.js

@@ -1,14 +1,12 @@
 import Product from "../stockObjects/Product";
-import ProductConnectionFactory from "../ProductConnectionFactory";
+import DatabaseConnection from "../DatabaseConnection";
 export default class ProductRepo {
     static async get(productId) {
-        const connection = await ProductConnectionFactory.get();
-        const product = await connection.productsSchema.products.select(productId);
+        const product = await DatabaseConnection.getInstance().products.select(productId);
         return this.createProductFromRow(product);
     }
     static async getForSku(productSku) {
-        const connection = await ProductConnectionFactory.get();
-        const product = await connection.productsSchema.products.selectForSku(productSku);
+        const product = await DatabaseConnection.getInstance().products.selectForSku(productSku);
         return this.createProductFromRow(product);
     }
     static createProductFromRow(productRow) {

package/dist/stockObjects/Product.d.ts

@@ -16,8 +16,9 @@ export default class Product extends StockObject {
     private deleted;
     private createdAt;
     private file;
+    private jsonData;
     private files;
-    constructor(sku: string, url: string, title: string, description: string, netPrice: number, vat: number, color: string, quantity: number, width: number, length: number, height: number, fileId: number, deleted?: boolean);
+    constructor(sku: string, url: string, title: string, description: string, netPrice: number, vat: number, color: string, quantity: number, width: number, length: number, height: number, fileId: number, jsonData: any, deleted?: boolean);
     getSku(): string;
     getUrl(): string;
     getTitle(): string;
@@ -31,6 +32,7 @@ export default class Product extends StockObject {
     getLength(): number;
     getHeight(): number;
     getFileId(): number;
+    getJsonData(): any;
     getDeleted(): boolean;
     getFile(): Promise<FileI | null>;
     getFiles(): Promise<FileI[] | null>;
@@ -64,6 +66,7 @@ export default class Product extends StockObject {
     setLength(length: number): number;
     setHeight(height: number): number;
     setFileId(fileId: number): number;
+    setJsonData(jsonData: any): any;
     setDeleted(deleted: boolean): boolean;
     protected getMapper(): StockObjectMapper;
 }

package/dist/stockObjects/Product.js

@@ -19,8 +19,9 @@ export default class Product extends StockObject {
     deleted;
     createdAt;
     file;
+    jsonData;
     files;
-    constructor(sku, url, title, description, netPrice, vat, color, quantity, width, length, height, fileId, deleted = false) {
+    constructor(sku, url, title, description, netPrice, vat, color, quantity, width, length, height, fileId, jsonData, deleted = false) {
         super();
         this.sku = sku;
         this.url = url;
@@ -34,6 +35,7 @@ export default class Product extends StockObject {
         this.length = length;
         this.height = height;
         this.fileId = fileId;
+        this.jsonData = jsonData;
         this.deleted = deleted;
         this.createdAt = null;
         this.file = null;
@@ -78,6 +80,9 @@ export default class Product extends StockObject {
     getFileId() {
         return this.fileId;
     }
+    getJsonData() {
+        return this.jsonData;
+    }
     getDeleted() {
         return this.deleted;
     }
@@ -154,6 +159,9 @@ export default class Product extends StockObject {
     setFileId(fileId) {
         return this.fileId = fileId;
     }
+    setJsonData(jsonData) {
+        return this.jsonData = jsonData;
+    }
     setDeleted(deleted) {
         return this.deleted = deleted;
     }

package/dist/tables/public/ProductsTable.js

@@ -80,6 +80,7 @@ export default class ProductsTable extends Table {
         query.bindParameter('length', productData.getLength());
         query.bindParameter('height', productData.getHeight());
         query.bindParameter('file_id', productData.getFileId());
+        query.bindParameter('json_data', productData.getJsonData());
     }
     async selectNextId() {
         const query = this.createQuery(SQL.products.selectNextId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dascompany/product",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "main": "dist/index.js",
   "scripts": {
     "test": "vitest",
@@ -20,7 +20,7 @@
     "vitest": "^3.0.6"
   },
   "peerDependencies": {
-    "@dascompany/database": "^2.1.0",
+    "@dascompany/database": "^2.1.3",
     "@types/pg": "^8.11.11",
     "pg": "^8.13.3"
   }

package/dist/ProductConnectionFactory.d.ts

@@ -1,6 +0,0 @@
-import { ConnectionFactory } from '@dascompany/database';
-import ProductServiceConnection from './ProductServiceConnection';
-export default class ProductConnectionFactory extends ConnectionFactory {
-    private static subdomain;
-    static get(): ProductServiceConnection;
-}

package/dist/ProductConnectionFactory.js

@@ -1,11 +0,0 @@
-import { ConnectionFactory } from '@dascompany/database';
-import ProductsSchema from './ProductsSchema';
-export default class ProductConnectionFactory extends ConnectionFactory {
-    static subdomain = 'defaultDatabaseName';
-    static get() {
-        const connection = super.get(this.subdomain);
-        if (!connection.productsSchema)
-            connection.productsSchema = new ProductsSchema(connection);
-        return connection;
-    }
-}

package/dist/ProductServiceConnection.d.ts

@@ -1,9 +0,0 @@
-import { Client } from 'pg';
-import { Connection } from '@dascompany/database';
-import ProductsSchema from './ProductsSchema';
-export default class ProductServiceConnection extends Connection {
-    private tables;
-    constructor(pgClient: Client);
-    get productsSchema(): ProductsSchema;
-    set productsSchema(tables: ProductsSchema);
-}