@dascompany/database 0.0.1 → 0.0.3

package/dist/SQL.json

@@ -11,11 +11,14 @@
     },
     "accounts": {
         "select": "SELECT  id, email, created_at, activated, deleted, contact_details_id, delivery_details_id, invoice_details_id FROM clients.accounts WHERE id = $account_id::BIGINT",
+        "selectAll": "SELECT id, email, created_at, activated, deleted FROM clients.accounts $WHERE $ORDERBY $LIMIT",
         "selectNextId": "SELECT nextval('clients.accounts_id'::regclass)",
         "getIdForEmail": "SELECT id FROM clients.accounts WHERE LOWER( email ) = LOWER($email::TEXT)",
         "insert": "INSERT INTO clients.accounts( id, email, activated, contact_details_id) VALUES ($id::BIGINT, LOWER($email::TEXT), $activated::BOOL, $contact_details_id::BIGINT)",
         "update": "UPDATE clients.accounts SET activated = $activated::BOOL, deleted = $deleted::BOOL, contact_details_id = $contact_details_id::BIGINT, delivery_details_id = $delivery_details_id::BIGINT, invoice_details_id = $invoice_details_id::BIGINT WHERE id = $id::BIGINT",
-        "delete": "DELETE FROM clients.accounts WHERE id = $account_id::BIGINT"
+        "delete": "DELETE FROM clients.accounts WHERE id = $account_id::BIGINT",
+        "count": "SELECT COUNT(*) AS total_rows FROM clients.accounts $WHERE ",
+        "selectEmail": "SELECT email FROM clients.accounts WHERE id = $id:BIGINT"
     },
     "contactDetails": {
         "select": "SELECT id, personal_data_id, address_id FROM personal_information.contact_details  WHERE id = $id::BIGINT",
@@ -37,6 +40,8 @@
     },
     "addresses": {
         "select": "SELECT id, country, city, postal_code, street, house_number, apartment_number FROM personal_information.addresses WHERE id = $id::BIGINT",
+        "selectTypes": "SELECT type FROM personal_information.addresses WHERE account_id = $account_id::BIGINT",
+        "selectId": "SELECT id FROM personal_information.addresses WHERE account_id = $account_id::BIGINT AND type = $type::SMALLINT",
         "insert": "INSERT INTO personal_information.addresses( id, country, city, postal_code, street, house_number, apartment_number) VALUES( $id::BIGINT, $country::TEXT, $city::TEXT, $postal_code::TEXT, $street::TEXT, $house_number::TEXT, $apartment_number::TEXT) ",
         "update": "UPDATE personal_information.addresses SET  country = $country::TEXT, city = $city::TEXT, postal_code = $postal_code::TEXT , street = $street::TEXT , house_number = $house_number::TEXT , apartment_number = $apartment_number::TEXT  WHERE id = $id::BIGINT",
         "selectNextId": "SELECT nextval('personal_information.addresses_id'::regclass)"
@@ -58,6 +63,12 @@
     "products": {
         "select": "SELECT id, sku, url, title, description,  net_price, vat, color, quantity, width, height, length, file_id, created_at, deleted FROM products WHERE id = $id::BIGINT",
         "selectAll": "SELECT id, sku, url, title, description, net_price, vat, color, quantity, width, height, length, file_id, created_at, deleted FROM products WHERE deleted = false  $PARAMS $ORDERBY LIMIT $limit::BIGINT OFFSET $offset::BIGINT",
+        "selectListForOrder": "SELECT id, title, sku, file_id, net_price FROM products WHERE deleted = false",
+        "selectIdForSku": "SELECT id FROM products WHERE LOWER( sku ) = LOWER($sku::TEXT) AND deleted = false",
+        "insert": "INSERT INTO products( id, sku, url, title, description, net_price, vat, color, quantity, width, length, height, file_id, deleted) VALUES ($id::BIGINT, $sku::TEXT, $url::TEXT, $title::TEXT, $description::TEXT, $net_price::DOUBLE PRECISION, $vat::INT, $color::TEXT, $quantity::INT, $width::INT,  $length::INT, $height::DOUBLE PRECISION,$file_id::BIGINT ,false::BOOL)",
+        "update": "UPDATE products SET url = $url::TEXT, title = $title::TEXT , description = $description::TEXT , net_price = $net_price::DOUBLE PRECISION, vat = $vat::INT, color = $color::TEXT, quantity = $quantity::INT, width = $width::INT, length = $length::INT, height = $height::DOUBLE PRECISION, file_id = $file_id::BIGINT  WHERE id = $id::BIGINT",
+        "delete": "UPDATE products SET deleted = true WHERE id = $id::BIGINT",
+        "restore": "UPDATE products SET deleted = false WHERE id = $id::BIGINT",
         "selectForSku": "SELECT id as product_id FROM products WHERE LOWER( sku ) = LOWER($sku::TEXT)",
         "selectForUrl": "SELECT id, sku, url, title, description, net_price, vat, color, quantity, width, height, length, file_id, created_at, deleted FROM products WHERE LOWER( url ) = LOWER($url::TEXT)",
         "selectNextId": "SELECT nextval('product_id'::regclass)",
@@ -97,7 +108,11 @@
     },
     "deliveryMethods": {
         "select": "SELECT * FROM settings.delivery_methods WHERE id = $id::BIGINT",
-        "selectAll": "SELECT * FROM settings.delivery_methods WHERE active = true ORDER BY id"
+        "selectAll": "SELECT * FROM settings.delivery_methods ORDER BY id",
+        "selectAllActive": "SELECT * FROM settings.delivery_methods WHERE active=true ORDER BY id",
+        "insert": "INSERT INTO settings.delivery_methods(id, key, active) VALUES ( $id::BIGINT, $key::TEXT, $active::BOOL)",
+        "update": "UPDATE settings.delivery_methods SET  id = $id::BIGINT, key = $key::TEXT, active = $active::BOOL WHERE id = $id::BIGINT",
+        "selectNextId": "SELECT nextval('settings.delivery_methods_id'::regclass)"
     },
     "paymentStatusTypes": {
         "select": "SELECT * FROM orders.payment_status_types WHERE id = $id::BIGINT"

package/dist/index.d.ts

@@ -8,6 +8,7 @@ import DeliveryMethodReader from "./reader/DeliveryMethodReader";
 import InvoiceDetailsReader from "./reader/InvoiceDetailsReader";
 import OrderProductsReader from "./reader/OrderProductsReader";
 import OrderReader from "./reader/OrderReader";
+import FilesReader from './reader/FilesReader';
 import OrderStatusReader from "./reader/OrderStatusReader";
 import PaymentDetailsReader from "./reader/payment/PaymentDetailsReader";
 import PaymentMethodReader from "./reader/payment/PaymentMethodReader";
@@ -39,4 +40,16 @@ import PersonalData from "./stockObjects/PersonalData";
 import Product from "./stockObjects/Product";
 import Status from "./stockObjects/Status";
 import Client from "./stockObjects/Client";
-export { DatabaseConnection, PaymentDetailsReader, PaymentMethodReader, PaymentStatusesReader, AddressesReader, ClientAccountReader, CompanyDetailsReader, ContactDetailsReader, DeliveryDetailsReader, DeliveryMethodReader, InvoiceDetailsReader, OrderProductsReader, OrderReader, OrderStatusReader, PersonalDataReader, ProductReader, PaymentDetailsRepo, AddressesRepo, ClientAccountRepo, CompanyDetailsRepo, ContactDetailsRepo, DeliveryDetailsRepo, InvoiceDetailsRepo, OrderRepo, PersonalDataRepo, ProductRepo, Address, Admin, Client, CompanyDetails, ContactDetails, DeliveryDetails, InvoiceDetails, DeliveryStatus, Order, OrderProduct, PaymentDetails, PaymentStatus, PersonalData, Product, Status, };
+import AdminRepo from './repo/AdminRepo';
+import TableConnection from './TableConnection';
+import ParameterType from './types/parameters/ParameterType';
+import DeliveryStatusReader from './reader/DeliveryStatusReader';
+import FileConnectionE from './types/FileConnectionE';
+import ConnectorE from './types/ConnectorE';
+import ParameterI from './types/ParameterI';
+import QueryOptionsI from './types/QueryOptionsI';
+import ResultLimitationI from './types/ResultLimitationI';
+import ParameterFilter from './types/parameters/ParameterFilter';
+import PaymentStatusE from './types/PaymentStatusE';
+import OrderProductI from './types/OrderProductI';
+export { TableConnection, DatabaseConnection, ParameterType, ConnectorE, FileConnectionE, PaymentStatusE, ParameterI, QueryOptionsI, ResultLimitationI, OrderProductI, ParameterFilter, PaymentDetailsReader, FilesReader, PaymentMethodReader, DeliveryStatusReader, PaymentStatusesReader, AddressesReader, ClientAccountReader, CompanyDetailsReader, ContactDetailsReader, DeliveryDetailsReader, DeliveryMethodReader, InvoiceDetailsReader, OrderProductsReader, OrderReader, OrderStatusReader, PersonalDataReader, ProductReader, AdminRepo, PaymentDetailsRepo, AddressesRepo, ClientAccountRepo, CompanyDetailsRepo, ContactDetailsRepo, DeliveryDetailsRepo, InvoiceDetailsRepo, OrderRepo, PersonalDataRepo, ProductRepo, Address, Admin, Client, CompanyDetails, ContactDetails, DeliveryDetails, InvoiceDetails, DeliveryStatus, Order, OrderProduct, PaymentDetails, PaymentStatus, PersonalData, Product, Status, };

package/dist/index.js

@@ -8,6 +8,7 @@ import DeliveryMethodReader from "./reader/DeliveryMethodReader";
 import InvoiceDetailsReader from "./reader/InvoiceDetailsReader";
 import OrderProductsReader from "./reader/OrderProductsReader";
 import OrderReader from "./reader/OrderReader";
+import FilesReader from './reader/FilesReader';
 import OrderStatusReader from "./reader/OrderStatusReader";
 import PaymentDetailsReader from "./reader/payment/PaymentDetailsReader";
 import PaymentMethodReader from "./reader/payment/PaymentMethodReader";
@@ -39,4 +40,11 @@ import PersonalData from "./stockObjects/PersonalData";
 import Product from "./stockObjects/Product";
 import Status from "./stockObjects/Status";
 import Client from "./stockObjects/Client";
-export { DatabaseConnection, PaymentDetailsReader, PaymentMethodReader, PaymentStatusesReader, AddressesReader, ClientAccountReader, CompanyDetailsReader, ContactDetailsReader, DeliveryDetailsReader, DeliveryMethodReader, InvoiceDetailsReader, OrderProductsReader, OrderReader, OrderStatusReader, PersonalDataReader, ProductReader, PaymentDetailsRepo, AddressesRepo, ClientAccountRepo, CompanyDetailsRepo, ContactDetailsRepo, DeliveryDetailsRepo, InvoiceDetailsRepo, OrderRepo, PersonalDataRepo, ProductRepo, Address, Admin, Client, CompanyDetails, ContactDetails, DeliveryDetails, InvoiceDetails, DeliveryStatus, Order, OrderProduct, PaymentDetails, PaymentStatus, PersonalData, Product, Status, };
+import AdminRepo from './repo/AdminRepo';
+import TableConnection from './TableConnection';
+import ParameterType from './types/parameters/ParameterType';
+import DeliveryStatusReader from './reader/DeliveryStatusReader';
+import FileConnectionE from './types/FileConnectionE';
+import ConnectorE from './types/ConnectorE';
+import PaymentStatusE from './types/PaymentStatusE';
+export { TableConnection, DatabaseConnection, ParameterType, ConnectorE, FileConnectionE, PaymentStatusE, PaymentDetailsReader, FilesReader, PaymentMethodReader, DeliveryStatusReader, PaymentStatusesReader, AddressesReader, ClientAccountReader, CompanyDetailsReader, ContactDetailsReader, DeliveryDetailsReader, DeliveryMethodReader, InvoiceDetailsReader, OrderProductsReader, OrderReader, OrderStatusReader, PersonalDataReader, ProductReader, AdminRepo, PaymentDetailsRepo, AddressesRepo, ClientAccountRepo, CompanyDetailsRepo, ContactDetailsRepo, DeliveryDetailsRepo, InvoiceDetailsRepo, OrderRepo, PersonalDataRepo, ProductRepo, Address, Admin, Client, CompanyDetails, ContactDetails, DeliveryDetails, InvoiceDetails, DeliveryStatus, Order, OrderProduct, PaymentDetails, PaymentStatus, PersonalData, Product, Status, };

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

@@ -0,0 +1,6 @@
+import ResultLimitationI from "../types/ResultLimitationI";
+import OrderByI from "../utils/OrderByI";
+export default class QueryOptions {
+    static correctingSorting(querySortBy: any): OrderByI[];
+    static correctingLimitation(queryLimit: any, queryOffset: any): ResultLimitationI;
+}

package/dist/query/QueryOptions.js

@@ -0,0 +1,25 @@
+import ParameterType from "../types/parameters/ParameterType";
+import Filters from "../utils/Filters";
+import Parameters from "../utils/Parameters";
+export default class QueryOptions {
+    static correctingSorting(querySortBy) {
+        const sortBy = Parameters.correct(querySortBy, { type: ParameterType.arrayObject });
+        const table = [];
+        if (sortBy[0]) {
+            sortBy.forEach((element) => {
+                const key = Parameters.correct(element.key, { type: ParameterType.string, filter: Filters.databaseColumn });
+                const order = Parameters.correct(element.order, { type: ParameterType.string });
+                table.push({ key, order });
+            });
+        }
+        return table;
+    }
+    static correctingLimitation(queryLimit, queryOffset) {
+        const limit = Parameters.correct(queryLimit, { type: ParameterType.bigint });
+        const offset = Parameters.correct(queryOffset, { type: ParameterType.bigint });
+        return {
+            limit,
+            offset
+        };
+    }
+}

package/dist/reader/ClientAccountReader.d.ts

@@ -1,7 +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

@@ -5,6 +5,15 @@ export default class ClientAccountReader {
         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);
@@ -12,19 +21,27 @@ export default class ClientAccountReader {
     }
     static async getIdForEmail(email) {
         const connection = DatabaseConnection.get();
-        const accountId = await connection.accounts.selectIdForEmail(email);
+        const accountId = await connection.accounts.getIdForEmail(email);
         return accountId;
     }
-    static correctData(account) {
+    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: account.id,
-            email: account.email,
-            createdAt: account.created_at,
-            activated: account.activated,
-            deleted: account.deleted,
-            contactDetailsId: account.contact_details_id,
-            deliveryDetailsId: account.delivery_details_id,
-            invoiceDetailsId: account.invoice_details_id,
+            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/DeliveryMethodReader.d.ts

@@ -2,4 +2,5 @@ import DeliveryMethodI from "../types/DeliveryMethodI";
 export default class DeliveryMethodReader {
     static get(id: number): Promise<DeliveryMethodI>;
     static getAll(): Promise<DeliveryMethodI[]>;
+    static getAllActive(): Promise<DeliveryMethodI[]>;
 }

package/dist/reader/DeliveryMethodReader.js

@@ -10,4 +10,9 @@ export default class DeliveryMethodReader {
         const deliveryMethods = await connection.deliveryMethods.selectAll();
         return deliveryMethods;
     }
+    static async getAllActive() {
+        const connection = DatabaseConnection.get();
+        const deliveryMethods = await connection.deliveryMethods.selectAllActive();
+        return deliveryMethods;
+    }
 }

package/dist/repo/AdminRepo.d.ts

@@ -0,0 +1,12 @@
+import Admin from "../stockObjects/Admin";
+import QueryOptionsI from "../types/QueryOptionsI";
+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 DatabaseConnection from "../DatabaseConnection";
+import Admin from "../stockObjects/Admin";
+export default class AdminRepo {
+    static async get(accountId) {
+        const connection = DatabaseConnection.get();
+        const account = await connection.adminAccounts.select(accountId);
+        return this.createAdminFromRow(account);
+    }
+    static async getIdForEmail(email) {
+        const connection = DatabaseConnection.get();
+        return await connection.adminAccounts.selectForEmail(email);
+    }
+    static async getAll(queryOptions) {
+        const connection = DatabaseConnection.get();
+        const adminAccounts = await connection.adminAccounts.selectAll(queryOptions);
+        const quantity = await connection.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

@@ -1,5 +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

@@ -6,6 +6,16 @@ export default class ClientAccountRepo {
         const accountData = await connection.accounts.select(accountId);
         return this.createCilentAccountFromRow(accountData);
     }
+    static async getById(clientId) {
+        const connection = DatabaseConnection.get();
+        const client = await connection.accounts.select(clientId);
+        return this.createCilentAccountFromRow(client);
+    }
+    static async getEmailForId(clientId) {
+        const connection = DatabaseConnection.get();
+        const email = await connection.accounts.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);

package/dist/repo/ContactDetailsRepo.d.ts

@@ -1,5 +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

@@ -6,9 +6,14 @@ export default class ContactDetailsRepo {
         const contactDetailsRow = await connection.contactDetails.select(contactDetailsId);
         return this.createContactDetailsFromRow(contactDetailsRow);
     }
+    static async getNextId() {
+        const connection = DatabaseConnection.get();
+        const contactDetails = await connection.contactDetails.selectNextId();
+        return contactDetails;
+    }
     static createContactDetailsFromRow(contactDetailsRow) {
-        const invoiceDetails = new ContactDetails(contactDetailsRow.personal_data_id, contactDetailsRow.address_id);
-        invoiceDetails.setId(contactDetailsRow.id);
-        return invoiceDetails;
+        const contactDetails = new ContactDetails(contactDetailsRow.personal_data_id, contactDetailsRow.address_id);
+        contactDetails.setId(contactDetailsRow.id);
+        return contactDetails;
     }
 }

package/dist/repo/ProductRepo.d.ts

@@ -1,5 +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

@@ -6,6 +6,11 @@ export default class ProductRepo {
         const product = await connection.products.select(productId);
         return this.createProductFromRow(product);
     }
+    static async getForSku(productSku) {
+        const connection = DatabaseConnection.get();
+        const product = await connection.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);

package/dist/stockObjects/DeliveryMethods.d.ts

@@ -0,0 +1,12 @@
+import StockObject from "../types/StockObject";
+import StockObjectMapper from "../types/StockObjectMapper";
+export default class DeliveryMethods extends StockObject {
+    private key;
+    private active;
+    constructor(key: string, active: boolean);
+    getKey(): string;
+    getActive(): boolean;
+    setKey(key: string): string;
+    setActive(active: boolean): boolean;
+    protected getMapper(): StockObjectMapper;
+}

package/dist/stockObjects/DeliveryMethods.js

@@ -0,0 +1,26 @@
+import DeliveryMethodsMapper from "../mappers/DeliveryMethodsMapper";
+import StockObject from "../types/StockObject";
+export default class DeliveryMethods extends StockObject {
+    key;
+    active;
+    constructor(key, active) {
+        super();
+        this.key = key;
+        this.active = active;
+    }
+    getKey() {
+        return this.key;
+    }
+    getActive() {
+        return this.active;
+    }
+    setKey(key) {
+        return this.key = key;
+    }
+    setActive(active) {
+        return this.active = active;
+    }
+    getMapper() {
+        return new DeliveryMethodsMapper(this);
+    }
+}

package/dist/stockObjects/Order.d.ts

@@ -22,7 +22,7 @@ export default class Order extends StockObject {
     }>;
     getEmail(): string;
     getPrice(): number;
-    getZsiId(): number;
+    getZsiId(): number | null;
     getGrossPrice(): number;
     getclientId(): number;
     getContactDetailsId(): number | null;

package/dist/stockObjects/Product.d.ts

@@ -34,7 +34,7 @@ export default class Product extends StockObject {
     getFileId(): number;
     getDeleted(): boolean;
     getFile(): Promise<FileI | null>;
-    getFiles(): Promise<FileI[]>;
+    getFiles(): Promise<FileI[] | null>;
     setCreatedAt(createdAt: any): void;
     protected getMapper(): StockObjectMapper;
 }

package/dist/stockObjects/Product.js

@@ -87,8 +87,11 @@ export default class Product extends StockObject {
     }
     async getFiles() {
         if (!this.files) {
-            const files = await FilesReader.getForConnection(FileConnectionE.product, this.getId());
-            this.files = files;
+            const id = this.getId();
+            if (id) {
+                const files = await FilesReader.getForConnection(FileConnectionE.product, id);
+                this.files = files;
+            }
         }
         return this.files;
     }

package/dist/tables/ClientAccountsTable.d.ts

@@ -1,14 +1,17 @@
 import Table from '../Table';
 import ClientAccountRow from '../types/rows/ClientAccountRow';
 import Client from '../stockObjects/Client';
+import QueryOptions from '../query/QueryOptions';
 export default class ClientAccountsTable extends Table {
     select(accountId: number): Promise<ClientAccountRow>;
+    selectEmail(id: number): Promise<string>;
+    count(queryOptions: QueryOptions): Promise<number>;
+    selectAll(queryOptions: QueryOptions): Promise<ClientAccountRow[]>;
     selectForEmail(email: string): Promise<ClientAccountRow>;
-    selectIdForEmail(email: string): Promise<number>;
     update(clientData: Client): Promise<void>;
     delete(accountId: number): Promise<number>;
     private bindParameters;
     insert(clientAccount: Client): Promise<void>;
-    private getIdForEmail;
+    getIdForEmail(email: string): Promise<number>;
     private selectNextId;
 }

package/dist/tables/ClientAccountsTable.js

@@ -7,14 +7,26 @@ export default class ClientAccountsTable extends Table {
         const result = await query.execute();
         return result.getRow();
     }
+    async selectEmail(id) {
+        const query = this.createQuery(SQL.accounts.selectEmail);
+        query.bindParameter('id', id);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async count(queryOptions) {
+        const query = this.createQuery(SQL.accounts.count, queryOptions);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.accounts.selectAll, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
     async selectForEmail(email) {
         const id = await this.getIdForEmail(email);
         return await this.select(id);
     }
-    async selectIdForEmail(email) {
-        const id = await this.getIdForEmail(email);
-        return id;
-    }
     async update(clientData) {
         const query = this.createQuery(SQL.accounts.update);
         query.bindParameter('id', clientData.getId());

package/dist/tables/ProductsTable.d.ts

@@ -1,9 +1,19 @@
 import Table from '../Table';
 import QueryOptionsI from '../types/QueryOptionsI';
 import ProductRow from '../types/rows/ProductRow';
+import Product from '../stockObjects/Product';
 export default class ProductsTable extends Table {
     select(productId: number): Promise<ProductRow>;
+    selectForSku(sku: string): Promise<ProductRow>;
+    selectIdForSku(sku: string): Promise<number>;
+    selectListForOrder(): Promise<ProductRow[]>;
     selectAll(queryOption: QueryOptionsI): Promise<ProductRow[]>;
     selectForUrl(url: string): Promise<ProductRow>;
+    insert(productData: Product): Promise<number>;
     count(queryOption: QueryOptionsI): Promise<number>;
+    update(product: Product): Promise<boolean>;
+    delete(productId: number): Promise<number>;
+    restore(product: Product): Promise<number>;
+    private bindParameters;
+    private selectNextId;
 }

package/dist/tables/ProductsTable.js

@@ -7,6 +7,23 @@ export default class ProductsTable extends Table {
         const result = await query.execute();
         return result.getRow();
     }
+    async selectForSku(sku) {
+        const query = this.createQuery(SQL.products.selectForSku);
+        query.bindParameter('sku', String(sku).toUpperCase());
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectIdForSku(sku) {
+        const query = this.createQuery(SQL.products.selectIdForSku);
+        query.bindParameter('sku', String(sku).toUpperCase());
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async selectListForOrder() {
+        const query = this.createQuery(SQL.products.selectListForOrder);
+        const result = await query.execute();
+        return result.getRows();
+    }
     async selectAll(queryOption) {
         const query = this.createQuery(SQL.products.selectAll, queryOption);
         const result = await query.execute();
@@ -18,9 +35,64 @@ export default class ProductsTable extends Table {
         const result = await query.execute();
         return result.getRow();
     }
+    async insert(productData) {
+        const sku = productData.getSku();
+        let productId = await this.selectIdForSku(sku);
+        if (productId)
+            throw new Error(`Product with SKU: ${sku} already exist!`);
+        else
+            productId = await this.selectNextId();
+        const query = this.createQuery(SQL.products.insert);
+        query.bindParameter('id', productId);
+        this.bindParameters(query, productData);
+        productData.setId(productId);
+        await query.execute();
+        return productId;
+    }
     async count(queryOption) {
         const query = this.createQuery(SQL.products.count, queryOption);
         const result = await query.execute();
         return result.getValue();
     }
+    async update(product) {
+        const query = this.createQuery(SQL.products.update);
+        query.bindParameter('id', product.getId());
+        this.bindParameters(query, product);
+        await query.execute();
+        return true;
+    }
+    async delete(productId) {
+        const query = this.createQuery(SQL.products.delete);
+        query.bindParameter('id', productId);
+        const result = await query.execute();
+        return result.getRowCount();
+    }
+    async restore(product) {
+        const productId = await this.selectIdForSku(product.getSku());
+        if (productId)
+            throw Error(`This product cannot be restored because it has been edited. There is a newer version of this product (id: ${productId})`);
+        const query = this.createQuery(SQL.products.restore);
+        query.bindParameter('id', product.getId());
+        const result = await query.execute();
+        return result.getRowCount();
+    }
+    bindParameters(query, productData) {
+        query.bindParameter('sku', productData.getSku());
+        query.bindParameter('url', productData.getUrl());
+        query.bindParameter('title', productData.getTitle());
+        query.bindParameter('description', productData.getDescription());
+        query.bindParameter('net_price', productData.getNetPrice());
+        query.bindParameter('vat', productData.getVat());
+        query.bindParameter('color', productData.getColor());
+        query.bindParameter('quantity', productData.getQuantity());
+        query.bindParameter('width', productData.getWidth());
+        query.bindParameter('length', productData.getLength());
+        query.bindParameter('height', productData.getHeight());
+        query.bindParameter('file_id', productData.getFileId());
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.products.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
 }

package/dist/tables/personalInformation/ContactDetailsTable.d.ts

@@ -5,6 +5,6 @@ export default class ContactDetailsTable extends Table {
     select(contactDetailsId: number): Promise<ContactDetailsRow>;
     insert(contactDetails: ContactDetails): Promise<void>;
     update(contactDetails: ContactDetails): Promise<void>;
-    private selectNextId;
+    selectNextId(): Promise<number>;
     private bindParameters;
 }

package/dist/tables/store-settings/DeliveryMethodsTable.d.ts

@@ -1,6 +1,12 @@
 import Table from '../../Table';
 import DeliveryMethodI from '../../types/DeliveryMethodI';
+import DeliveryMethodRow from '../../types/rows/DeliveryMethodRow';
+import DeliveryMethods from '../../stockObjects/DeliveryMethods';
 export default class DeliveryMethodsTable extends Table {
     select(id: number): Promise<DeliveryMethodI>;
     selectAll(): Promise<DeliveryMethodI[]>;
+    selectAllActive(): Promise<DeliveryMethodRow[]>;
+    insert(deliveryMethods: DeliveryMethods): Promise<boolean>;
+    update(deliveryMethods: DeliveryMethods): Promise<boolean>;
+    private selectNextId;
 }

package/dist/tables/store-settings/DeliveryMethodsTable.js

@@ -12,4 +12,32 @@ export default class DeliveryMethodsTable extends Table {
         const result = await query.execute();
         return result.getRows();
     }
+    async selectAllActive() {
+        const query = this.createQuery(SQL.deliveryMethods.selectAllActive);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async insert(deliveryMethods) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.deliveryMethods.insert);
+        query.bindParameter('id', id);
+        query.bindParameter('key', deliveryMethods.getKey());
+        query.bindParameter('active', deliveryMethods.getActive());
+        await query.execute();
+        deliveryMethods.setId(id);
+        return true;
+    }
+    async update(deliveryMethods) {
+        const query = this.createQuery(SQL.deliveryMethods.update);
+        query.bindParameter('id', deliveryMethods.getId());
+        query.bindParameter('key', deliveryMethods.getKey());
+        query.bindParameter('active', deliveryMethods.getActive());
+        await query.execute();
+        return true;
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.deliveryMethods.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
 }

package/dist/types/parameters/ParameterType.d.ts

@@ -1,13 +1,16 @@
 declare enum ParameterType {
     arrayNumber = 0,
-    arrayString = 1,
-    arrayBoolean = 2,
-    arrayValue = 3,
-    bigint = 4,
-    smallint = 5,
-    number = 6,
-    string = 7,
-    boolean = 8,
-    column = 9
+    arrayBigint = 1,
+    arrayString = 2,
+    arrayBoolean = 3,
+    arrayValue = 4,
+    arrayObject = 5,
+    bigint = 6,
+    smallint = 7,
+    number = 8,
+    string = 9,
+    boolean = 10,
+    object = 11,
+    column = 12
 }
 export default ParameterType;

package/dist/types/parameters/ParameterType.js

@@ -1,14 +1,17 @@
 var ParameterType;
 (function (ParameterType) {
     ParameterType[ParameterType["arrayNumber"] = 0] = "arrayNumber";
-    ParameterType[ParameterType["arrayString"] = 1] = "arrayString";
-    ParameterType[ParameterType["arrayBoolean"] = 2] = "arrayBoolean";
-    ParameterType[ParameterType["arrayValue"] = 3] = "arrayValue";
-    ParameterType[ParameterType["bigint"] = 4] = "bigint";
-    ParameterType[ParameterType["smallint"] = 5] = "smallint";
-    ParameterType[ParameterType["number"] = 6] = "number";
-    ParameterType[ParameterType["string"] = 7] = "string";
-    ParameterType[ParameterType["boolean"] = 8] = "boolean";
-    ParameterType[ParameterType["column"] = 9] = "column";
+    ParameterType[ParameterType["arrayBigint"] = 1] = "arrayBigint";
+    ParameterType[ParameterType["arrayString"] = 2] = "arrayString";
+    ParameterType[ParameterType["arrayBoolean"] = 3] = "arrayBoolean";
+    ParameterType[ParameterType["arrayValue"] = 4] = "arrayValue";
+    ParameterType[ParameterType["arrayObject"] = 5] = "arrayObject";
+    ParameterType[ParameterType["bigint"] = 6] = "bigint";
+    ParameterType[ParameterType["smallint"] = 7] = "smallint";
+    ParameterType[ParameterType["number"] = 8] = "number";
+    ParameterType[ParameterType["string"] = 9] = "string";
+    ParameterType[ParameterType["boolean"] = 10] = "boolean";
+    ParameterType[ParameterType["object"] = 11] = "object";
+    ParameterType[ParameterType["column"] = 12] = "column";
 })(ParameterType || (ParameterType = {}));
 export default ParameterType;

package/dist/types/rows/DeliveryMethodRow.d.ts

@@ -0,0 +1,5 @@
+export default interface DeliveryMethodRow {
+    id: number;
+    key: string;
+    active: boolean;
+}

package/dist/types/rows/DeliveryMethodRow.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/Filters.d.ts

@@ -0,0 +1,6 @@
+export default class Filters {
+    static email(value: string): string;
+    static phoneNumber(value: string): string;
+    static sanitizeString(value: string): string;
+    static databaseColumn(value: string): string;
+}

package/dist/utils/Filters.js

@@ -0,0 +1,31 @@
+export default class Filters {
+    static email(value) {
+        value = value.trimStart();
+        value = value.trimEnd();
+        value = value.replace(/[^\w\.-@]/g, "");
+        value = value.substring(0, 99);
+        return value;
+    }
+    static phoneNumber(value) {
+        value = value.trimStart();
+        value = value.trimEnd();
+        value = value.replace(/[^\d\+48]/g, "");
+        value = value.substring(0, 99);
+        return value;
+    }
+    static sanitizeString(value) {
+        value = value.trimStart();
+        value = value.trimEnd();
+        value = value.replaceAll(/<[^>]*>/g, '');
+        value = value.replace(/[^a-zA-Z0-9-żźćńółęąśŻŹĆĄŚĘŁÓŃ\ ]/g, "");
+        value = value.substring(0, 99);
+        return value;
+    }
+    static databaseColumn(value) {
+        value = value.trimStart();
+        value = value.trimEnd();
+        value = value.replace(/[^a-zA-Z\_]/g, "");
+        value = value.substring(0, 99);
+        return value;
+    }
+}

package/dist/utils/OrderByI.d.ts

@@ -0,0 +1,4 @@
+export default interface OrderByI {
+    key: string;
+    order: string;
+}

package/dist/utils/OrderByI.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/Parameters.d.ts

@@ -0,0 +1,5 @@
+import ParameterFilter from "../types/parameters/ParameterFilter";
+export default class Parameters {
+    static correct(parameter: any, parameterFilter: ParameterFilter): any;
+    private static isParameterValueString;
+}

package/dist/utils/Parameters.js

@@ -0,0 +1,23 @@
+import ParameterType from "../types/parameters/ParameterType";
+import Filters from "./Filters";
+import ParameterConversionSystem from "./parameters/ParameterConversionSystem";
+import ParameterFilterSystem from "./parameters/ParameterFilterSystem";
+import ParameterRulesSystem from "./parameters/ParameterRulesSystem";
+export default class Parameters {
+    static correct(parameter, parameterFilter) {
+        let correctedParameter = ParameterConversionSystem.convert(parameter, parameterFilter.type);
+        if (!parameterFilter.filter && this.isParameterValueString(parameterFilter.type))
+            parameterFilter.filter = Filters.sanitizeString;
+        if (parameterFilter.filter)
+            correctedParameter = ParameterFilterSystem.filter(correctedParameter, parameterFilter);
+        if (parameterFilter.rules)
+            correctedParameter = ParameterRulesSystem.validate(correctedParameter, parameterFilter.rules);
+        return correctedParameter;
+    }
+    static isParameterValueString(type) {
+        if (type == ParameterType.string || type == ParameterType.arrayString)
+            return true;
+        else
+            return false;
+    }
+}

package/dist/utils/parameters/ParameterConversionSystem.d.ts

@@ -0,0 +1,5 @@
+import ParameterType from "../../types/parameters/ParameterType";
+export default class ParameterConversionSystem {
+    static convert(parameter: any, type: ParameterType): any;
+    private static convertArray;
+}

package/dist/utils/parameters/ParameterConversionSystem.js

@@ -0,0 +1,28 @@
+import ParameterType from "../../types/parameters/ParameterType";
+export default class ParameterConversionSystem {
+    static convert(parameter, type) {
+        switch (type) {
+            case ParameterType.number: return Number(parameter);
+            case ParameterType.string: return String(parameter);
+            case ParameterType.boolean: return Boolean(parameter);
+            case ParameterType.object: return JSON.parse(parameter);
+            case ParameterType.bigint: return BigInt(parameter);
+            case ParameterType.arrayNumber: return this.convertArray(parameter, ParameterType.number);
+            case ParameterType.arrayString: return this.convertArray(parameter, ParameterType.string);
+            case ParameterType.arrayBoolean: return this.convertArray(parameter, ParameterType.boolean);
+            case ParameterType.arrayObject: return this.convertArray(parameter, ParameterType.object);
+            case ParameterType.arrayBigint: return this.convertArray(parameter, ParameterType.bigint);
+            case ParameterType.column: return String(parameter);
+        }
+    }
+    static convertArray(parameterArray, type) {
+        if (!Array.isArray(parameterArray)) {
+            if (parameterArray)
+                parameterArray = [parameterArray];
+            else
+                parameterArray = [];
+        }
+        const convertedParameterArray = parameterArray.map(parameter => this.convert(parameter, type));
+        return convertedParameterArray;
+    }
+}

package/dist/utils/parameters/ParameterFilterSystem.d.ts

@@ -0,0 +1,4 @@
+import ParameterFilter from "../../types/parameters/ParameterFilter";
+export default class ParameterFilterSystem {
+    static filter(parameter: any, parameterFilter: ParameterFilter): any;
+}

package/dist/utils/parameters/ParameterFilterSystem.js

@@ -0,0 +1,11 @@
+import ParameterType from "../../types/parameters/ParameterType";
+export default class ParameterFilterSystem {
+    static filter(parameter, parameterFilter) {
+        switch (parameterFilter.type) {
+            case ParameterType.string: return parameterFilter.filter(parameter);
+            case ParameterType.arrayString:
+                return parameter.map((stringParameter) => parameterFilter.filter(stringParameter));
+            default: return parameter;
+        }
+    }
+}

package/dist/utils/parameters/ParameterRulesSystem.d.ts

@@ -0,0 +1,3 @@
+export default class ParameterRulesSystem {
+    static validate(parameter: any, rules: ((value: any) => boolean)[]): any;
+}

package/dist/utils/parameters/ParameterRulesSystem.js

@@ -0,0 +1,8 @@
+export default class ParameterRulesSystem {
+    static validate(parameter, rules) {
+        rules.forEach((rule) => {
+            rule(parameter);
+        });
+        return parameter;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dascompany/database",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "main": "dist/index.js",
   "scripts": {
     "test": "vitest",
@@ -14,7 +14,7 @@
   "keywords": [],
   "author": "",
   "license": "ISC",
-  "description": "",
+  "description": "@Dascompany/repo",
   "devDependencies": {
     "types": "^0.1.1",
     "typescript": "^5.7.3",