@dascompany/product 1.0.0

package/dist/reader/payment/PaymentDetailsReader.js

@@ -0,0 +1,27 @@
+import ProductConnectionFactory from "../../ProductConnectionFactory";
+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);
+        return await this.correctPaymentDetails(paymentDetails);
+    }
+    static async getPaymentOrderId(paymentDetailsId) {
+        const connection = ProductConnectionFactory.get();
+        const paymentDetails = await connection.productsSchema.paymentDetails.select(paymentDetailsId);
+        return paymentDetails.payment_order_id;
+    }
+    static async correctPaymentDetails(paymentDetails) {
+        const id = paymentDetails.id;
+        const [paymentMethod, statuses] = await Promise.all([
+            PaymentMethodReader.get(paymentDetails.payment_method_id),
+            PaymentStatusesReader.getAll(paymentDetails.id)
+        ]);
+        return {
+            id,
+            paymentMethod,
+            statuses,
+        };
+    }
+}

package/dist/reader/payment/PaymentMethodReader.d.ts

@@ -0,0 +1,6 @@
+import PaymentMethodI from "../../types/PaymentMethodI";
+export default class PaymentMethodReader {
+    static get(paymentMethodId: number): Promise<PaymentMethodI>;
+    static getAll(): Promise<PaymentMethodI[]>;
+    static getAllActive(): Promise<PaymentMethodI[]>;
+}

package/dist/reader/payment/PaymentMethodReader.js

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

package/dist/reader/payment/PaymentStatusesReader.d.ts

@@ -0,0 +1,5 @@
+export default class PaymentStatusesReader {
+    static get(paymentDetailsId: number): Promise<any>;
+    static getAll(paymentDetailsId: number): Promise<any[]>;
+    private static correctPaymentStatus;
+}

package/dist/reader/payment/PaymentStatusesReader.js

@@ -0,0 +1,30 @@
+import ProductConnectionFactory from "../../ProductConnectionFactory";
+export default class PaymentStatusesReader {
+    static async get(paymentDetailsId) {
+        const connection = ProductConnectionFactory.get();
+        const paymentStatus = await connection.productsSchema.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 paymentStatuses = [];
+        for (let i = 0; i < paymentStatusesData.length; i++) {
+            const paymentStatus = await this.correctPaymentStatus(paymentStatusesData[i]);
+            paymentStatuses.push(paymentStatus);
+        }
+        return paymentStatuses;
+    }
+    static async correctPaymentStatus(paymentStatus) {
+        const connection = ProductConnectionFactory.get();
+        const paymentStatusType = await connection.productsSchema.paymentStatusTypes.select(paymentStatus.payment_status_type_id);
+        return {
+            id: paymentStatus.id,
+            type: paymentStatusType,
+            createdAt: paymentStatus.created_at
+        };
+    }
+}

package/dist/repo/AddressesRepo.d.ts

@@ -0,0 +1,5 @@
+import Address from "../stockObjects/Address";
+export default class AddressesRepo {
+    static get(addressId: number): Promise<Address>;
+    private static createAddressFromRow;
+}

package/dist/repo/AddressesRepo.js

@@ -0,0 +1,14 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createAddressFromRow(address);
+    }
+    static createAddressFromRow(dataRow) {
+        const address = new Address(dataRow.country, dataRow.city, dataRow.street, dataRow.postal_code, dataRow.house_number, dataRow.apartment_number);
+        address.setId(dataRow.id);
+        return address;
+    }
+}

package/dist/repo/AdminRepo.d.ts

@@ -0,0 +1,12 @@
+import { QueryOptionsI } from "@dascompany/database";
+import Admin from "../stockObjects/Admin";
+export default class AdminRepo {
+    static get(accountId: number): Promise<Admin>;
+    static getIdForEmail(email: string): Promise<number>;
+    static getAll(queryOptions: QueryOptionsI): Promise<{
+        adminAccounts: Admin[];
+        quantity: number;
+    }>;
+    private static createAdminsFromRows;
+    private static createAdminFromRow;
+}

package/dist/repo/AdminRepo.js

@@ -0,0 +1,32 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createAdminFromRow(account);
+    }
+    static async getIdForEmail(email) {
+        const connection = ProductConnectionFactory.get();
+        return await connection.productsSchema.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);
+        return { adminAccounts: this.createAdminsFromRows(adminAccounts), quantity };
+    }
+    static createAdminsFromRows(dataRows) {
+        const admins = [];
+        for (const dataRow of dataRows) {
+            const admin = this.createAdminFromRow(dataRow);
+            admins.push(admin);
+        }
+        return admins;
+    }
+    static createAdminFromRow(dataRow) {
+        const admin = new Admin(dataRow.email, dataRow.first_name, dataRow.last_name, dataRow.activated, dataRow.deleted, dataRow.created_at);
+        admin.setId(dataRow.id);
+        return admin;
+    }
+}

package/dist/repo/ClientAccountRepo.d.ts

@@ -0,0 +1,7 @@
+import Client from "../stockObjects/Client";
+export default class ClientAccountRepo {
+    static get(accountId: number): Promise<Client>;
+    static getById(clientId: number): Promise<Client>;
+    static getEmailForId(clientId: number): Promise<string>;
+    private static createCilentAccountFromRow;
+}

package/dist/repo/ClientAccountRepo.js

@@ -0,0 +1,24 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createCilentAccountFromRow(accountData);
+    }
+    static async getById(clientId) {
+        const connection = ProductConnectionFactory.get();
+        const client = await connection.productsSchema.clientAccounts.select(clientId);
+        return this.createCilentAccountFromRow(client);
+    }
+    static async getEmailForId(clientId) {
+        const connection = ProductConnectionFactory.get();
+        const email = await connection.productsSchema.clientAccounts.selectEmail(clientId);
+        return email;
+    }
+    static createCilentAccountFromRow(accountData) {
+        const client = new Client(accountData.email, accountData.activated, accountData.deleted, accountData.contact_details_id, accountData.delivery_details_id, accountData.invoice_details_id, accountData.created_at);
+        client.setId(accountData.id);
+        return client;
+    }
+}

package/dist/repo/CompanyDataRepo.d.ts

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

package/dist/repo/CompanyDataRepo.js

@@ -0,0 +1,11 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+import CompanyData from "../stockObjects/CompanyData";
+export default class CompanyDataRepo {
+    static async get() {
+        const connection = ProductConnectionFactory.get();
+        const companyDataRow = await connection.productsSchema.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.d.ts

@@ -0,0 +1,5 @@
+import CompanyDetails from "../stockObjects/CompanyDetails";
+export default class CompanyDetailsRepo {
+    static get(id: number): Promise<CompanyDetails>;
+    private static createCompanyDetailsFromRow;
+}

package/dist/repo/CompanyDetailsRepo.js

@@ -0,0 +1,14 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createCompanyDetailsFromRow(companyDetailsRow);
+    }
+    static createCompanyDetailsFromRow(companyDetailsRow) {
+        const companyDetails = new CompanyDetails(companyDetailsRow.name, companyDetailsRow.tax_number);
+        companyDetails.setId(companyDetailsRow.id);
+        return companyDetails;
+    }
+}

package/dist/repo/ContactDetailsRepo.d.ts

@@ -0,0 +1,6 @@
+import ContactDetails from "../stockObjects/ContactDetails";
+export default class ContactDetailsRepo {
+    static get(contactDetailsId: number): Promise<ContactDetails>;
+    static getNextId(): Promise<number>;
+    private static createContactDetailsFromRow;
+}

package/dist/repo/ContactDetailsRepo.js

@@ -0,0 +1,19 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createContactDetailsFromRow(contactDetailsRow);
+    }
+    static async getNextId() {
+        const connection = ProductConnectionFactory.get();
+        const contactDetails = await connection.productsSchema.contactDetails.selectNextId();
+        return contactDetails;
+    }
+    static createContactDetailsFromRow(contactDetailsRow) {
+        const contactDetails = new ContactDetails(contactDetailsRow.personal_data_id, contactDetailsRow.address_id);
+        contactDetails.setId(contactDetailsRow.id);
+        return contactDetails;
+    }
+}

package/dist/repo/DeliveryDetailsRepo.d.ts

@@ -0,0 +1,5 @@
+import DeliveryDetails from "../stockObjects/DeliveryDetails";
+export default class DeliveryDetailsRepo {
+    static get(deliveryDetailsId: number): Promise<DeliveryDetails>;
+    private static createDeliveryDetailsFromRow;
+}

package/dist/repo/DeliveryDetailsRepo.js

@@ -0,0 +1,14 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createDeliveryDetailsFromRow(deliveryDetailsRow);
+    }
+    static createDeliveryDetailsFromRow(deliveryDetailsRow) {
+        const deliveryDetails = new DeliveryDetails(deliveryDetailsRow.personal_data_id, deliveryDetailsRow.address_id, deliveryDetailsRow.delivery_method_id);
+        deliveryDetails.setId(deliveryDetailsRow.id);
+        return deliveryDetails;
+    }
+}

package/dist/repo/DeliveryMethodRepo.d.ts

@@ -0,0 +1,4 @@
+import DeliveryMethods from "../stockObjects/DeliveryMethods";
+export default class DeliveryMethodRepo {
+    static get(id: number): Promise<DeliveryMethods>;
+}

package/dist/repo/DeliveryMethodRepo.js

@@ -0,0 +1,11 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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 deliveryMethods = new DeliveryMethods(deliveryMethodsRow.key, deliveryMethodsRow.active);
+        deliveryMethods.setId(deliveryMethodsRow.id);
+        return deliveryMethods;
+    }
+}

package/dist/repo/FileConnectionsRepo.d.ts

@@ -0,0 +1,7 @@
+import FileConnection from "../stockObjects/FileConnection";
+export default class FileConnectionsRepo {
+    static getAllForFileId(fileId: number): Promise<FileConnection[]>;
+    static deleteAllForConnection(connectionType: string, connectionId: number): Promise<boolean>;
+    private static correctFileConnections;
+    private static correctFileConnection;
+}

package/dist/repo/FileConnectionsRepo.js

@@ -0,0 +1,25 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.correctFileConnections(fileConnections);
+    }
+    static async deleteAllForConnection(connectionType, connectionId) {
+        const connection = ProductConnectionFactory.get();
+        return await connection.productsSchema.fileConnections.deleteForConnection(connectionType, connectionId);
+    }
+    static correctFileConnections(dataRows) {
+        const fileConnections = [];
+        for (const dataRow of dataRows) {
+            const fileConnection = this.correctFileConnection(dataRow);
+            fileConnections.push(fileConnection);
+        }
+        return fileConnections;
+    }
+    static correctFileConnection(fileConnections) {
+        const correctFileConnection = new FileConnection(fileConnections.file_id, fileConnections.connection_type, fileConnections.connection_id, fileConnections.sequence);
+        return correctFileConnection;
+    }
+}

package/dist/repo/FilesRepo.d.ts

@@ -0,0 +1,7 @@
+import FileConnectionTypeE from "../types/FileConnectionTypeE";
+export default class FilesRepo {
+    static get(fileId: number): Promise<any>;
+    static getAllForConnection(connectionType: FileConnectionTypeE, connectionId: number): Promise<any>;
+    private static createFilesFromRows;
+    private static createFileFromRow;
+}

package/dist/repo/FilesRepo.js

@@ -0,0 +1,26 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createFileFromRow(file);
+    }
+    static async getAllForConnection(connectionType, connectionId) {
+        const connection = ProductConnectionFactory.get();
+        const files = await connection.productsSchema.files.selectForConnection(connectionType, connectionId);
+        return this.createFilesFromRows(files);
+    }
+    static async createFilesFromRows(dataRows) {
+        const files = [];
+        for (const dataRow of dataRows) {
+            const file = await this.createFileFromRow(dataRow);
+            files.push(file);
+        }
+        return files;
+    }
+    static createFileFromRow(file) {
+        const correctFile = new File(file.name, file.catalog, file.size_kb, file.type, file.orginal_name);
+        return correctFile;
+    }
+}

package/dist/repo/InvoiceDetailsRepo.d.ts

@@ -0,0 +1,5 @@
+import InvoiceDetails from "../stockObjects/InvoiceDetails";
+export default class InvoiceDetailsRepo {
+    static get(invoiceDetailsId: number): Promise<InvoiceDetails>;
+    private static createInvoiceDetailsFromRow;
+}

package/dist/repo/InvoiceDetailsRepo.js

@@ -0,0 +1,14 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createInvoiceDetailsFromRow(invoiceDetailsRow);
+    }
+    static createInvoiceDetailsFromRow(invoiceDetailsRow) {
+        const invoiceDetails = new InvoiceDetails(invoiceDetailsRow.personal_data_id, invoiceDetailsRow.address_id);
+        invoiceDetails.setId(invoiceDetailsRow.id);
+        return invoiceDetails;
+    }
+}

package/dist/repo/OrderProductsRepo.d.ts

@@ -0,0 +1,7 @@
+import OrderProduct from "../stockObjects/OrderProduct";
+export default class OrderProductsRepo {
+    static getAllActive(orderId: number): Promise<OrderProduct[]>;
+    static getAllForIds(orderProductsIds: number[]): Promise<OrderProduct[]>;
+    private static createOrdersProductsFromRows;
+    private static createOrdersProductFromRow;
+}

package/dist/repo/OrderProductsRepo.js

@@ -0,0 +1,36 @@
+import { ConnectorE, ParameterType } from "@dascompany/database";
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createOrdersProductsFromRows(orderProducts);
+    }
+    static async getAllForIds(orderProductsIds) {
+        const connection = ProductConnectionFactory.get();
+        const queryOptions = {
+            where: {
+                connector: ConnectorE.and,
+                parameters: [
+                    { name: 'id', type: ParameterType.arrayBigint, value: orderProductsIds },
+                ]
+            }
+        };
+        const orderProducts = await connection.productsSchema.ordersProducts.selectAllForIds(queryOptions);
+        return this.createOrdersProductsFromRows(orderProducts);
+    }
+    static async createOrdersProductsFromRows(dataRows) {
+        const products = [];
+        for (const dataRow of dataRows) {
+            const product = await this.createOrdersProductFromRow(dataRow);
+            products.push(product);
+        }
+        return products;
+    }
+    static async createOrdersProductFromRow(dataRow) {
+        const orderProduct = new OrderProduct(dataRow.order_id, dataRow.product_id, dataRow.net_price, dataRow.in_order);
+        orderProduct.setId(dataRow.id);
+        return orderProduct;
+    }
+}

package/dist/repo/OrderRepo.d.ts

@@ -0,0 +1,5 @@
+import Order from "../stockObjects/Order";
+export default class OrderRepo {
+    static get(orderId: number): Promise<Order>;
+    private static createOrderFromRow;
+}

package/dist/repo/OrderRepo.js

@@ -0,0 +1,14 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createOrderFromRow(orderData);
+    }
+    static createOrderFromRow(orderData) {
+        const order = new Order(orderData.email, orderData.price, orderData.client_id, orderData.contact_details_id, orderData.delivery_details_id, orderData.invoice_details_id, orderData.payment_details_id);
+        order.setId(orderData.id);
+        return order;
+    }
+}

package/dist/repo/OrderStatusRepo.d.ts

@@ -0,0 +1,7 @@
+import Status from "../stockObjects/Status";
+export default class OrderStatusRepo {
+    static get(orderId: number): Promise<Status>;
+    static getAll(orderId: number): Promise<Status[]>;
+    private static createStatusesFromRows;
+    private static createStatusFromRow;
+}

package/dist/repo/OrderStatusRepo.js

@@ -0,0 +1,27 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createStatusFromRow(status);
+    }
+    static async getAll(orderId) {
+        const connection = ProductConnectionFactory.get();
+        const statuses = await connection.productsSchema.statuses.selectAll(orderId);
+        return this.createStatusesFromRows(statuses);
+    }
+    static async createStatusesFromRows(dataRows) {
+        const statuses = [];
+        for (const dataRow of dataRows) {
+            const status = await this.createStatusFromRow(dataRow);
+            statuses.push(status);
+        }
+        return statuses;
+    }
+    static async createStatusFromRow(dataRow) {
+        const status = new Status(dataRow.order_id, dataRow.user_id, dataRow.type_id, dataRow.type_name, dataRow.created_at);
+        status.setId(dataRow.id);
+        return status;
+    }
+}

package/dist/repo/PaymentDetailsRepo.d.ts

@@ -0,0 +1,5 @@
+import PaymentDetails from "../stockObjects/PaymentDetails";
+export default class PaymentDetailsRepo {
+    static get(paymentDetailsId: number): Promise<PaymentDetails>;
+    private static createPaymentDetailsFromRow;
+}

package/dist/repo/PaymentDetailsRepo.js

@@ -0,0 +1,14 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createPaymentDetailsFromRow(paymentDetailsRow);
+    }
+    static createPaymentDetailsFromRow(paymentDetailsRow) {
+        const paymentDetails = new PaymentDetails(paymentDetailsRow.payment_method_id, String(paymentDetailsRow.payment_order_id));
+        paymentDetails.setId(paymentDetailsRow.id);
+        return paymentDetails;
+    }
+}

package/dist/repo/PaymentMethodRepo.d.ts

@@ -0,0 +1,4 @@
+import PaymentMethods from "../stockObjects/PaymentMethods";
+export default class PaymentMethodRepo {
+    static get(id: number): Promise<PaymentMethods>;
+}

package/dist/repo/PaymentMethodRepo.js

@@ -0,0 +1,11 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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 paymentMethods = new PaymentMethods(paymentMethodsRow.key, paymentMethodsRow.active);
+        paymentMethods.setId(paymentMethodsRow.id);
+        return paymentMethods;
+    }
+}

package/dist/repo/PersonalDataRepo.d.ts

@@ -0,0 +1,5 @@
+import PersonalData from "../stockObjects/PersonalData";
+export default class PersonalDataRepo {
+    static get(personalDataId: number): Promise<PersonalData>;
+    private static createPersonalDataFromRow;
+}

package/dist/repo/PersonalDataRepo.js

@@ -0,0 +1,16 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+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);
+        return this.createPersonalDataFromRow(personalData);
+    }
+    static createPersonalDataFromRow(dataRow) {
+        const phoneNumber = correctPhoneNumber(dataRow.phone_number);
+        const personalData = new PersonalData(dataRow.email, dataRow.first_name, dataRow.last_name, phoneNumber, dataRow.company_details_id);
+        personalData.setId(dataRow.id);
+        return personalData;
+    }
+}

package/dist/repo/ProductRepo.d.ts

@@ -0,0 +1,6 @@
+import Product from "../stockObjects/Product";
+export default class ProductRepo {
+    static get(productId: number): Promise<Product>;
+    static getForSku(productSku: string): Promise<Product>;
+    private static createProductFromRow;
+}

package/dist/repo/ProductRepo.js

@@ -0,0 +1,20 @@
+import Product from "../stockObjects/Product";
+import ProductConnectionFactory from "../ProductConnectionFactory";
+export default class ProductRepo {
+    static async get(productId) {
+        const connection = await ProductConnectionFactory.get();
+        const product = await connection.productsSchema.products.select(productId);
+        return this.createProductFromRow(product);
+    }
+    static async getForSku(productSku) {
+        const connection = await ProductConnectionFactory.get();
+        const product = await connection.productsSchema.products.selectForSku(productSku);
+        return this.createProductFromRow(product);
+    }
+    static createProductFromRow(productRow) {
+        const product = new Product(productRow.sku, productRow.url, productRow.title, productRow.description, productRow.net_price, productRow.vat, productRow.color, productRow.quantity, productRow.width, productRow.length, productRow.height, productRow.file_id, productRow.deleted);
+        product.setId(productRow.id);
+        product.setCreatedAt(productRow.created_at);
+        return product;
+    }
+}

package/dist/stockObjects/Address.d.ts

@@ -0,0 +1,32 @@
+import { StockObject, StockObjectMapper } from "@dascompany/database";
+export default class Address extends StockObject {
+    private country;
+    private city;
+    private street;
+    private postalCode;
+    private houseNumber;
+    private apartmentNumber;
+    constructor(country: string, city: string, street: string, postalCode: string, houseNumber: string, apartmentNumber?: string | null);
+    getData(): {
+        id: number | null;
+        country: string;
+        city: string;
+        street: string;
+        postalCode: string;
+        houseNumber: string;
+        apartmentNumber: string | null;
+    };
+    getCountry(): string;
+    getCity(): string;
+    getStreet(): string;
+    getPostalCode(): string;
+    getHouseNumber(): string;
+    getApartmentNumber(): string | null;
+    setCountry(country: string): void;
+    setCity(city: string): void;
+    setStreet(street: string): void;
+    setPostalCode(postalCode: string): void;
+    setHouseNumber(houseNumber: string): void;
+    setApartmentNumber(apartmentNumber: string): void;
+    protected getMapper(): StockObjectMapper;
+}