@shopfront/bridge 2.0.0 → 2.0.2

package/lib/Events/UIPipeline.d.ts

@@ -1,7 +1,8 @@
-import { BaseEvent } from "./BaseEvent";
-import { FromShopfrontCallbacks, FromShopfrontReturns, UIPipelineBaseContext, UIPipelineContext, UIPipelineResponse } from "../ApplicationEvents";
-import { Bridge } from "../Bridge";
-import { MaybePromise } from "../Utilities/MiscTypes";
+import { FromShopfrontCallbacks, FromShopfrontReturns, UIPipelineBaseContext, UIPipelineContext, UIPipelineResponse } from "../ApplicationEvents.js";
+import { BaseBridge } from "../BaseBridge.js";
+import { Bridge } from "../Bridge.js";
+import { MaybePromise } from "../Utilities/MiscTypes.js";
+import { BaseEvent } from "./BaseEvent.js";
 interface UIPPipelineIncomingData {
     data: Array<UIPipelineResponse>;
     context: UIPipelineBaseContext;
@@ -9,7 +10,18 @@ interface UIPPipelineIncomingData {
 }
 export declare class UIPipeline extends BaseEvent<UIPPipelineIncomingData, MaybePromise<FromShopfrontReturns["UI_PIPELINE"]>, FromShopfrontReturns["UI_PIPELINE"], Array<UIPipelineResponse>, UIPipelineContext> {
     constructor(callback: FromShopfrontCallbacks["UI_PIPELINE"]);
+    /**
+     * @inheritDoc
+     * @param data
+     * @param bridge
+     */
     emit(data: UIPPipelineIncomingData, bridge: Bridge): Promise<FromShopfrontReturns["UI_PIPELINE"]>;
-    static respond(bridge: Bridge, data: FromShopfrontReturns["UI_PIPELINE"], id: string): Promise<void>;
+    /**
+     * Sends the response data to Shopfront
+     * @param bridge
+     * @param data
+     * @param id
+     */
+    static respond(bridge: BaseBridge, data: FromShopfrontReturns["UI_PIPELINE"], id: string): Promise<void>;
 }
 export {};

package/lib/Events/UIPipeline.js

@@ -1,19 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UIPipeline = void 0;
-const BaseEvent_1 = require("./BaseEvent");
-const ApplicationEvents_1 = require("../ApplicationEvents");
-class UIPipeline extends BaseEvent_1.BaseEvent {
+import { ToShopfront, } from "../ApplicationEvents.js";
+import { BaseEvent } from "./BaseEvent.js";
+export class UIPipeline extends BaseEvent {
     constructor(callback) {
         super(callback);
     }
+    /**
+     * @inheritDoc
+     * @param data
+     * @param bridge
+     */
     async emit(data, bridge) {
         const context = {
-            ...data.context
+            ...data.context,
         };
         if (typeof data.pipelineId === "string") {
             context.trigger = () => {
-                bridge.sendMessage(ApplicationEvents_1.ToShopfront.PIPELINE_TRIGGER, {
+                bridge.sendMessage(ToShopfront.PIPELINE_TRIGGER, {
                     id: data.pipelineId,
                 });
             };
@@ -24,8 +26,13 @@ class UIPipeline extends BaseEvent_1.BaseEvent {
         }
         return result;
     }
+    /**
+     * Sends the response data to Shopfront
+     * @param bridge
+     * @param data
+     * @param id
+     */
     static async respond(bridge, data, id) {
-        bridge.sendMessage(ApplicationEvents_1.ToShopfront.RESPONSE_UI_PIPELINE, data, id);
+        bridge.sendMessage(ToShopfront.RESPONSE_UI_PIPELINE, data, id);
     }
 }
-exports.UIPipeline = UIPipeline;

package/lib/Mocks/APIs/Sale/MockCurrentSale.d.ts

@@ -0,0 +1,99 @@
+import { BaseCurrentSale } from "../../../APIs/Sale/BaseCurrentSale.js";
+import { SaleCustomer, SalePayment, SaleProduct, ShopfrontSaleState } from "../../../APIs/Sale/index.js";
+import { DirectShopfrontEvent } from "../../../ApplicationEvents.js";
+import { MockApplication } from "../../MockApplication.js";
+export declare class MockCurrentSale extends BaseCurrentSale {
+    constructor(application: MockApplication, saleState?: ShopfrontSaleState);
+    /**
+     * Fires the event trigger
+     */
+    protected triggerEvent(event: DirectShopfrontEvent): Promise<void>;
+    /**
+     * Check if the sale has already been cancelled, if it has, throw a SaleCancelledError.
+     */
+    protected checkIfCancelled(): void;
+    /**
+     * @inheritDoc
+     */
+    refreshSale(): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    cancelSale(): Promise<void>;
+    /**
+     * Round the price to the specified decimal place
+     */
+    protected roundNumber(price: number, precision?: number): number;
+    /**
+     * Updates the sale total by adding the specified `amount`
+     */
+    protected updateSaleTotal(amount: number): void;
+    /**
+     * Updates the paid total by adding the specified `amount`
+     */
+    protected updatePaidTotal(amount: number): void;
+    /**
+     * Updates the sale total when a product's price is changed
+     */
+    protected handleSaleProductPriceChange(index: number, currentPrice: number, newPrice: number): void;
+    /**
+     * @inheritDoc
+     */
+    addProduct(product: SaleProduct): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    removeProduct(product: SaleProduct): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    addPayment(payment: SalePayment): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    reversePayment(payment: SalePayment): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    addCustomer(customer: SaleCustomer): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    removeCustomer(): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    setExternalNote(note: string, append?: boolean): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    setInternalNote(note: string, append?: boolean): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    setOrderReference(reference: string): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    setMetaData(metaData: Record<string, unknown>): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    updateProduct(product: SaleProduct): Promise<void>;
+    /**
+     * Retrieves the index of a product in the sale
+     */
+    protected getIndexOfProduct(product: SaleProduct): number;
+    /**
+     * Clones a sale product so it can be added to the sale
+     */
+    protected cloneProduct(product: SaleProduct): SaleProduct;
+    /**
+     * Clones a sale payment so it can be added to the sale
+     */
+    protected clonePayment(payment: SalePayment, reverse?: boolean): SalePayment;
+    /**
+     * Clear the sale data
+     */
+    clearSale(): void;
+}

package/lib/Mocks/APIs/Sale/MockCurrentSale.js

@@ -0,0 +1,326 @@
+import { BaseCurrentSale } from "../../../APIs/Sale/BaseCurrentSale.js";
+import { ProductNotExistsError, SaleCancelledError } from "../../../APIs/Sale/Exceptions.js";
+import { SalePayment, SaleProduct, } from "../../../APIs/Sale/index.js";
+import { MockApplication } from "../../MockApplication.js";
+const emptySaleState = {
+    clientId: undefined,
+    register: undefined,
+    products: [],
+    customer: false,
+    payments: [],
+    notes: {
+        sale: "",
+        internal: "",
+    },
+    totals: {
+        sale: 0,
+        paid: 0,
+        savings: 0,
+        discount: 0,
+    },
+    linkedTo: "",
+    orderReference: "",
+    refundReason: "",
+    priceSet: null,
+    metaData: {},
+};
+export class MockCurrentSale extends BaseCurrentSale {
+    constructor(application, saleState) {
+        super(application, saleState ?? emptySaleState);
+    }
+    /**
+     * Fires the event trigger
+     */
+    async triggerEvent(event) {
+        if (this.application instanceof MockApplication) {
+            await this.application.fireEvent(event);
+        }
+        else {
+            throw new Error("Manually firing events is only supported in the `MockApplication`");
+        }
+    }
+    /**
+     * Check if the sale has already been cancelled, if it has, throw a SaleCancelledError.
+     */
+    checkIfCancelled() {
+        if (this.cancelled) {
+            throw new SaleCancelledError();
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    async refreshSale() {
+        /* Do nothing */
+    }
+    /**
+     * @inheritDoc
+     */
+    async cancelSale() {
+        this.clearSale();
+        this.cancelled = true;
+    }
+    /**
+     * Round the price to the specified decimal place
+     */
+    roundNumber(price, precision = 2) {
+        const multiplier = Math.pow(10, precision);
+        return Math.round(price * multiplier) / multiplier;
+    }
+    /**
+     * Updates the sale total by adding the specified `amount`
+     */
+    updateSaleTotal(amount) {
+        this.sale.totals.sale += amount;
+        this.sale.totals.sale = this.roundNumber(this.sale.totals.sale);
+    }
+    ;
+    /**
+     * Updates the paid total by adding the specified `amount`
+     */
+    updatePaidTotal(amount) {
+        this.sale.totals.paid += amount;
+        this.sale.totals.paid = this.roundNumber(this.sale.totals.paid);
+    }
+    ;
+    /**
+     * Updates the sale total when a product's price is changed
+     */
+    handleSaleProductPriceChange(index, currentPrice, newPrice) {
+        // Editing the property directly to avoid triggering the `wasPriceModified` flag
+        this.products[index]["price"] = newPrice;
+        const difference = newPrice - currentPrice;
+        this.updateSaleTotal(difference);
+    }
+    ;
+    /**
+     * @inheritDoc
+     */
+    async addProduct(product) {
+        this.checkIfCancelled();
+        // Check if product already exists in the sale
+        try {
+            // If it does, update it
+            const index = this.getIndexOfProduct(product);
+            // TODO: Does not currently support not consolidating
+            // If a product is added again with a different price, the new price is ignored
+            // This behaviour was taken from the `addProductToSale` function in the POS
+            const currentPrice = this.products[index].getPrice() || 0;
+            const currentRate = currentPrice / this.products[index].getQuantity();
+            // Editing the property directly to avoid triggering the `wasQuantityModified` flag
+            this.products[index]["quantity"] += product.getQuantity();
+            const newPrice = this.roundNumber(currentRate * this.products[index].getQuantity());
+            this.handleSaleProductPriceChange(index, currentPrice, newPrice);
+            await this.triggerEvent("SALE_UPDATE_PRODUCTS");
+            return;
+        }
+        catch (e) {
+            // We want to throw the error unless it's because the product isn't in the sale
+            if (!(e instanceof ProductNotExistsError)) {
+                throw e;
+            }
+        }
+        product["indexAddress"] = this.products.length === 0 ? [0] : [this.products.length];
+        product["edited"] = false;
+        this.products.push(this.cloneProduct(product));
+        this.updateSaleTotal(product.getPrice() || 0);
+        await this.triggerEvent("SALE_ADD_PRODUCT");
+        await this.triggerEvent("SALE_UPDATE_PRODUCTS");
+    }
+    /**
+     * @inheritDoc
+     */
+    async removeProduct(product) {
+        this.checkIfCancelled();
+        if (this.products.length === 1 && this.sale.totals.paid !== 0) {
+            throw new Error("Cannot remove the last product from the sale if the sale contains an outstanding balance");
+        }
+        const index = this.getIndexOfProduct(product);
+        this.products.splice(index, 1);
+        this.updateSaleTotal((product.getPrice() || 0) * -1);
+        // Reshuffle the index addresses
+        for (let i = 0, l = this.products.length; i < l; i++) {
+            this.products[i]["indexAddress"] = [i];
+        }
+        await this.triggerEvent("SALE_REMOVE_PRODUCT");
+    }
+    /**
+     * @inheritDoc
+     */
+    async addPayment(payment) {
+        this.checkIfCancelled();
+        this.payments.push(this.clonePayment(payment));
+        if (payment.getStatus() === "cancelled" || payment.getStatus() === "failed") {
+            // No need to update any of the totals
+            return;
+        }
+        this.updatePaidTotal(payment.getAmount() - (payment.getCashout() || 0));
+        const remaining = this.roundNumber(this.sale.totals.sale - this.sale.totals.paid);
+        if (remaining <= 0) {
+            this.clearSale();
+            await this.triggerEvent("SALE_CLEAR");
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    async reversePayment(payment) {
+        this.checkIfCancelled();
+        // Should not be reverse-able past 0
+        if (this.sale.totals.paid - payment.getAmount() < 0) {
+            throw new Error("The paid total cannot be less than 0");
+        }
+        const reversed = this.clonePayment(payment, true);
+        this.payments.push(reversed);
+        if (payment.getStatus() === "cancelled" || payment.getStatus() === "failed") {
+            // No need to update any of the totals
+            return;
+        }
+        this.updatePaidTotal(reversed.getAmount());
+    }
+    /**
+     * @inheritDoc
+     */
+    async addCustomer(customer) {
+        this.checkIfCancelled();
+        this.customer = customer;
+        await this.triggerEvent("SALE_ADD_CUSTOMER");
+    }
+    /**
+     * @inheritDoc
+     */
+    async removeCustomer() {
+        this.checkIfCancelled();
+        this.customer = null;
+        await this.triggerEvent("SALE_REMOVE_CUSTOMER");
+    }
+    /**
+     * @inheritDoc
+     */
+    async setExternalNote(note, append) {
+        this.checkIfCancelled();
+        let toSet;
+        if (append) {
+            toSet = `${this.sale.notes.sale}${note}`;
+        }
+        else {
+            toSet = note;
+        }
+        this.sale.notes.sale = toSet;
+    }
+    /**
+     * @inheritDoc
+     */
+    async setInternalNote(note, append) {
+        this.checkIfCancelled();
+        let toSet;
+        if (append) {
+            toSet = `${this.sale.notes.internal}${note}`;
+        }
+        else {
+            toSet = note;
+        }
+        this.sale.notes.internal = toSet;
+    }
+    /**
+     * @inheritDoc
+     */
+    async setOrderReference(reference) {
+        this.checkIfCancelled();
+        this.sale.orderReference = reference;
+    }
+    /**
+     * @inheritDoc
+     */
+    async setMetaData(metaData) {
+        this.checkIfCancelled();
+        this.sale.metaData = metaData;
+    }
+    /**
+     * @inheritDoc
+     */
+    async updateProduct(product) {
+        this.checkIfCancelled();
+        const index = this.getIndexOfProduct(product);
+        if (product.wasQuantityModified()) {
+            const currentPrice = this.products[index].getPrice() || 0;
+            const currentRate = this.roundNumber(currentPrice / this.products[index].getQuantity());
+            this.products[index]["quantity"] = product.getQuantity();
+            const newPrice = this.roundNumber(currentRate * product.getQuantity());
+            this.handleSaleProductPriceChange(index, currentPrice, newPrice);
+        }
+        if (product.wasPriceModified()) {
+            const currentPrice = this.products[index].getPrice() || 0;
+            const newPrice = product.getPrice() || 0;
+            this.handleSaleProductPriceChange(index, currentPrice, newPrice);
+        }
+        if (product.wasMetaDataModified()) {
+            this.products[index]["metaData"] = product.getMetaData();
+        }
+        product.clearModificationFlags();
+        await this.triggerEvent("SALE_UPDATE_PRODUCTS");
+    }
+    /**
+     * Retrieves the index of a product in the sale
+     */
+    getIndexOfProduct(product) {
+        const index = this.products.findIndex((p) => p.getId() === product.getId());
+        if (index === -1) {
+            throw new ProductNotExistsError();
+        }
+        return index;
+    }
+    /**
+     * Clones a sale product so it can be added to the sale
+     */
+    cloneProduct(product) {
+        const clone = new SaleProduct(product.getId(), product.getQuantity(), product.getPrice(), product.getIndexAddress());
+        clone["note"] = product["note"];
+        clone["contains"] = product["contains"];
+        clone["edited"] = product["edited"];
+        clone["promotions"] = product["promotions"];
+        clone["metaData"] = product["metaData"];
+        clone["quantityModified"] = product["quantityModified"];
+        clone["priceModified"] = product["priceModified"];
+        clone["metaDataModified"] = product["metaDataModified"];
+        return clone;
+    }
+    /**
+     * Clones a sale payment so it can be added to the sale
+     */
+    clonePayment(payment, reverse = false) {
+        const updatedAmount = reverse ? payment.getAmount() * -1 : payment.getAmount();
+        const clone = new SalePayment(payment.getId(), updatedAmount, payment.getCashout(), payment.getStatus());
+        clone["metaData"] = payment["metaData"];
+        return clone;
+    }
+    /**
+     * Clear the sale data
+     */
+    clearSale() {
+        this.products.length = 0;
+        this.products.push(...[]);
+        this.payments.length = 0;
+        this.payments.push(...[]);
+        this.customer = null;
+        this.sale = {
+            register: undefined,
+            clientId: undefined,
+            notes: {
+                sale: "",
+                internal: "",
+            },
+            totals: {
+                sale: 0,
+                paid: 0,
+                savings: 0,
+                discount: 0,
+            },
+            linkedTo: "",
+            orderReference: "",
+            refundReason: "",
+            priceSet: null,
+            metaData: {},
+        };
+    }
+}

package/lib/Mocks/Database/MockDatabase.d.ts

@@ -0,0 +1,96 @@
+import { BaseDatabase, DatabaseCallReturn, DatabaseMethodName, DatabaseTable } from "../../APIs/Database/BaseDatabase.js";
+import { LocalDatabaseBarcodeTemplate } from "../../APIs/Database/types/BaseBarcodeTemplateRepository.js";
+import { LocalDatabaseClassification } from "../../APIs/Database/types/BaseClassificationRepository.js";
+import { LocalDatabaseCustomerDisplay } from "../../APIs/Database/types/BaseCustomerDisplayRepository.js";
+import { LocalDatabaseCustomerGroup } from "../../APIs/Database/types/BaseCustomerGroupRepository.js";
+import { LocalDatabaseCustomer } from "../../APIs/Database/types/BaseCustomerRepository.js";
+import { LocalDatabaseEnterprise } from "../../APIs/Database/types/BaseEnterpriseRepository.js";
+import { LocalDatabaseGiftCard } from "../../APIs/Database/types/BaseGiftCardRepository.js";
+import { LocalDatabaseLoyalty } from "../../APIs/Database/types/BaseLoyaltyRepository.js";
+import { LocalDatabaseMovement } from "../../APIs/Database/types/BaseMovementRepository.js";
+import { LocalDatabaseOutlet } from "../../APIs/Database/types/BaseOutletRepository.js";
+import { LocalDatabasePaymentMethod } from "../../APIs/Database/types/BasePaymentMethodRepository.js";
+import { LocalDatabasePriceList } from "../../APIs/Database/types/BasePriceListRepository.js";
+import { LocalDatabasePriceSet } from "../../APIs/Database/types/BasePriceSetRepository.js";
+import { LocalDatabaseProduct } from "../../APIs/Database/types/BaseProductRepository.js";
+import { LocalDatabasePromotionCategory } from "../../APIs/Database/types/BasePromotionCategoryRepository.js";
+import { LocalDatabasePromotion } from "../../APIs/Database/types/BasePromotionRepository.js";
+import { LocalDatabaseReceipt } from "../../APIs/Database/types/BaseReceiptRepository.js";
+import { LocalDatabaseRegister } from "../../APIs/Database/types/BaseRegisterRepository.js";
+import { LocalDatabaseSaleKeys } from "../../APIs/Database/types/BaseSalesKeyRepository.js";
+import { LocalDatabaseSale } from "../../APIs/Database/types/BaseSalesRepository.js";
+import { LocalDatabaseStocktakeAccumulated } from "../../APIs/Database/types/BaseStocktakeAccumulatedRepository.js";
+import { LocalDatabaseStocktake } from "../../APIs/Database/types/BaseStocktakeRepository.js";
+import { LocalDatabaseStocktakeScanned } from "../../APIs/Database/types/BaseStocktakeScannedRepository.js";
+import { LocalDatabaseSupplier } from "../../APIs/Database/types/BaseSupplierRepository.js";
+import { LocalDatabaseTakings } from "../../APIs/Database/types/BaseTakingsRepository.js";
+import { LocalDatabaseTaxRate } from "../../APIs/Database/types/BaseTaxRateRepository.js";
+import { LocalDatabaseTransferee } from "../../APIs/Database/types/BaseTransfereeRepository.js";
+import { LocalDatabaseVendorConnection } from "../../APIs/Database/types/BaseVendorConnectionRepository.js";
+import { MockBridge } from "../MockBridge.js";
+interface MockedDatabase {
+    products: Array<LocalDatabaseProduct>;
+    customers: Array<LocalDatabaseCustomer>;
+    customerGroups: Array<LocalDatabaseCustomerGroup>;
+    promotions: Array<LocalDatabasePromotion>;
+    promotionCategories: Array<LocalDatabasePromotionCategory>;
+    priceLists: Array<LocalDatabasePriceList>;
+    paymentMethods: Array<LocalDatabasePaymentMethod>;
+    salesKeys: Array<LocalDatabaseSaleKeys>;
+    receipts: Array<LocalDatabaseReceipt>;
+    giftCards: Array<LocalDatabaseGiftCard>;
+    loyalty: Array<LocalDatabaseLoyalty>;
+    customerDisplays: Array<LocalDatabaseCustomerDisplay>;
+    sales: Array<LocalDatabaseSale>;
+    brands: Array<LocalDatabaseClassification>;
+    categories: Array<LocalDatabaseClassification>;
+    families: Array<LocalDatabaseClassification>;
+    tags: Array<LocalDatabaseClassification>;
+    outlets: Array<LocalDatabaseOutlet>;
+    registers: Array<LocalDatabaseRegister>;
+    taxRates: Array<LocalDatabaseTaxRate>;
+    takings: Array<LocalDatabaseTakings>;
+    suppliers: Array<LocalDatabaseSupplier>;
+    priceSets: Array<LocalDatabasePriceSet>;
+    transferees: Array<LocalDatabaseTransferee>;
+    movements: Array<LocalDatabaseMovement>;
+    stocktakes: Array<LocalDatabaseStocktake>;
+    stocktakeScanned: Array<LocalDatabaseStocktakeScanned>;
+    stocktakeAccumulated: Array<LocalDatabaseStocktakeAccumulated>;
+    barcodeTemplates: Array<LocalDatabaseBarcodeTemplate>;
+    vendorConnections: Array<LocalDatabaseVendorConnection>;
+    enterprises: Array<LocalDatabaseEnterprise>;
+}
+export declare class MockDatabase extends BaseDatabase<MockBridge> {
+    protected mockedDatabase: MockedDatabase;
+    constructor(bridge: MockBridge);
+    /**
+     * @inheritDoc
+     */
+    callMethod<Table extends DatabaseTable, Method extends keyof DatabaseMethodName<Table>, ExpectedResult extends DatabaseCallReturn<Table, Method>>(table: Table, method: Method, args: Array<unknown>): Promise<ExpectedResult>;
+    /**
+     * @inheritDoc
+     */
+    all<Table extends DatabaseTable>(table: Table): Promise<DatabaseCallReturn<Table, "all">>;
+    /**
+     * @inheritDoc
+     */
+    get<Table extends DatabaseTable>(table: Table, id: string | number): Promise<DatabaseCallReturn<Table, "get">>;
+    /**
+     * @inheritDoc
+     */
+    count(table: DatabaseTable): Promise<number>;
+    /**
+     * Insert data into the mocked Database
+     */
+    insertData<Table extends keyof MockedDatabase>(table: Table, rows: Array<MockedDatabase[Table]>): void;
+    /**
+     * Clears all data from the mocked database
+     */
+    clearDatabase(): void;
+    /**
+     * Clears the data from a specified table
+     */
+    clearTable<Table extends keyof MockedDatabase>(table: Table): void;
+}
+export {};

package/lib/Mocks/Database/MockDatabase.js

@@ -0,0 +1,89 @@
+import { BaseDatabase, } from "../../APIs/Database/BaseDatabase.js";
+const emptyDatabase = {
+    products: [],
+    customers: [],
+    customerGroups: [],
+    promotions: [],
+    promotionCategories: [],
+    priceLists: [],
+    paymentMethods: [],
+    salesKeys: [],
+    receipts: [],
+    giftCards: [],
+    loyalty: [],
+    customerDisplays: [],
+    sales: [],
+    brands: [],
+    categories: [],
+    families: [],
+    tags: [],
+    outlets: [],
+    registers: [],
+    taxRates: [],
+    takings: [],
+    suppliers: [],
+    priceSets: [],
+    transferees: [],
+    movements: [],
+    stocktakes: [],
+    stocktakeScanned: [],
+    stocktakeAccumulated: [],
+    barcodeTemplates: [],
+    vendorConnections: [],
+    enterprises: [],
+};
+export class MockDatabase extends BaseDatabase {
+    constructor(bridge) {
+        super(bridge);
+        this.mockedDatabase = emptyDatabase;
+    }
+    /**
+     * @inheritDoc
+     */
+    async callMethod(table, method, args) {
+        return {};
+    }
+    /**
+     * @inheritDoc
+     */
+    async all(table) {
+        return [];
+    }
+    /**
+     * @inheritDoc
+     */
+    async get(table, id) {
+        return {};
+    }
+    /**
+     * @inheritDoc
+     */
+    async count(table) {
+        return 0;
+    }
+    /**
+     * Insert data into the mocked Database
+     */
+    insertData(table, rows) {
+        if (typeof this.mockedDatabase[table] === "undefined") {
+            throw new Error(`The table ${table} does not exist`);
+        }
+        // @ts-expect-error TypeScript resolves `MockedDatabase[Table]` as a union of arrays
+        this.mockedDatabase[table].push(...rows);
+    }
+    /**
+     * Clears all data from the mocked database
+     */
+    clearDatabase() {
+        this.mockedDatabase = emptyDatabase;
+    }
+    /**
+     * Clears the data from a specified table
+     */
+    clearTable(table) {
+        if (typeof this.mockedDatabase[table] === "undefined") {
+            throw new Error(`The table ${table} does not exist`);
+        }
+        this.mockedDatabase[table] = [];
+    }
+}