medusa-plugin-veeqo 0.1.3

package/.medusa/server/src/modules/veeqo/service.js

@@ -0,0 +1,566 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeeqoService = void 0;
+const async_sema_1 = require("async-sema");
+const utils_1 = require("@medusajs/framework/utils");
+const utils_2 = require("@medusajs/framework/utils");
+const veeqo_channel_1 = require("./models/veeqo-channel");
+const veeqo_customer_1 = require("./models/veeqo-customer");
+const veeqo_delivery_method_1 = require("./models/veeqo-delivery-method");
+const veeqo_order_1 = require("./models/veeqo-order");
+const veeqo_product_1 = require("./models/veeqo-product");
+const veeqo_sellable_1 = require("./models/veeqo-sellable");
+const veeqo_shipment_1 = require("./models/veeqo-shipment");
+const veeqo_warehouse_1 = require("./models/veeqo-warehouse");
+class VeeqoService extends (0, utils_1.MedusaService)({
+    VeeqoChannel: veeqo_channel_1.VeeqoChannel,
+    VeeqoCustomer: veeqo_customer_1.VeeqoCustomer,
+    VeeqoDeliveryMethod: veeqo_delivery_method_1.VeeqoDeliveryMethod,
+    VeeqoOrder: veeqo_order_1.VeeqoOrder,
+    VeeqoProduct: veeqo_product_1.VeeqoProduct,
+    VeeqoSellable: veeqo_sellable_1.VeeqoSellable,
+    VeeqoShipment: veeqo_shipment_1.VeeqoShipment,
+    VeeqoWarehouse: veeqo_warehouse_1.VeeqoWarehouse
+}) {
+    constructor(container, options) {
+        super(...arguments);
+        // The Veeqo API currently has a rate limit of 5 requests per second with a bucket size of 100.
+        // See https://developers.veeqo.com/getting-started/introduction/#limits
+        // The worker and main threads share the same account/api key, so throttle to 3 requests per second.
+        // This maximizes throughput but may very rarely result in a 429 if the bucket is full. In that case, the request will be retried with exponential backoff up to the number of times specified in options.retry.
+        this.rateLimit = (0, async_sema_1.RateLimit)(3);
+        this.delay = (durationMs) => new Promise(resolve => setTimeout(resolve, durationMs));
+        this.options_ = options;
+        this.logger_ = container.logger;
+        this.headers = {
+            ...(this.options_.headers || {}),
+            'x-api-key': this.options_.apiKey
+        };
+        this.url = this.options_.veeqoUrl || 'https://api.veeqo.com';
+    }
+    async fetch(options, retry = this.options_.retry || 1) {
+        let { path, method = 'GET', body = null, ...rest } = options;
+        let headers = {};
+        if (this.headers) {
+            for (const [key, value] of Object.entries(this.headers)) {
+                headers[key] = value;
+            }
+        }
+        if (body && Object.keys(body).length != 0) {
+            headers['Accept'] = 'application/json';
+            headers['Content-Type'] = 'application/json';
+            body = JSON.stringify(options.body);
+        }
+        try {
+            const controller = new AbortController();
+            const id = setTimeout(() => controller.abort(), this.options_.timeout || 5000);
+            await this.rateLimit();
+            const response = await fetch(`${this.url}${path}`, {
+                method,
+                body,
+                headers,
+                ...rest,
+                signal: controller.signal
+            });
+            clearTimeout(id);
+            return response;
+        }
+        catch (err) {
+            if (retry > 0) {
+                await this.rateLimit();
+                // add exponential backoff with jitter
+                const backoffTime = Math.pow(2, this.options_.retry - retry) * 100 + Math.random() * 100;
+                this.logger_.warn(`[VEEQO]: Veeqo API request failed. Retrying in ${backoffTime}ms... (${retry} retries left)`);
+                await this.delay(backoffTime);
+                return await this.fetch(options, retry - 1);
+            }
+            else {
+                return Promise.reject(err);
+            }
+        }
+    }
+    /**
+     * Fetches a channel from Veeqo by Veeqo Channel ID. Returns the Veeqo channel or null if not found.
+     */
+    async fetchChannel(veeqoChannelId) {
+        return this.fetch({
+            path: `/channels/${veeqoChannelId}`,
+            method: 'GET'
+        })
+            .then(response => response.json())
+            .catch(err => {
+            this.logger_.error(err);
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Veeqo channel with veeqo_channel_id ${veeqoChannelId} not found`);
+        });
+    }
+    /**
+     * Fetches a customer from Veeqo by Veeqo Customer ID. Returns the Veeqo customer or null if not found.
+     */
+    async fetchCustomer(veeqoCustomerId) {
+        return await this.fetch({
+            path: `/customers/${veeqoCustomerId}`,
+            method: 'GET'
+        })
+            .then(response => response.json())
+            .catch(err => {
+            this.logger_.error(err);
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Veeqo customer with veeqo_customer_id ${veeqoCustomerId} not found`);
+        });
+    }
+    /**
+     * Fetches a delivery method from Veeqo by Veeqo Delivery Method ID. Returns the Veeqo delivery method or null if not found.
+     */
+    async fetchDeliveryMethod(veeqoDeliveryMethodId) {
+        return await this.fetch({
+            path: `/delivery_methods/${veeqoDeliveryMethodId}`,
+            method: 'GET'
+        })
+            .then(response => response.json())
+            .catch(err => {
+            this.logger_.error(err);
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Veeqo delivery method with veeqo_delivery_method_id ${veeqoDeliveryMethodId} not found`);
+        });
+    }
+    /**
+     * Fetches an order from Veeqo by Veeqo Order ID. Returns the Veeqo order or null if not found.
+     */
+    async fetchOrder(veeqoOrderId) {
+        return await this.fetch({
+            path: `/orders/${veeqoOrderId}`,
+            method: 'GET'
+        })
+            .then(response => response.json())
+            .catch(err => {
+            this.logger_.error(err);
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Veeqo order with veeqo_order_id ${veeqoOrderId} not found`);
+        });
+    }
+    /**
+     * Fetches a product from Veeqo by Veeqo Product ID. Returns the Veeqo product or null if not found.
+     */
+    async fetchProduct(veeqoProductId) {
+        return await this.fetch({
+            path: `/products/${veeqoProductId}`,
+            method: 'GET'
+        })
+            .then(response => response.json())
+            .catch(err => {
+            this.logger_.error(err);
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Veeqo product with veeqo_product_id ${veeqoProductId} not found`);
+        });
+    }
+    /**
+     * Fetches a shipment from Veeqo by Veeqo Shipment ID. Returns the Veeqo shipment or null if not found.
+     */
+    async fetchShipment(shipmentId) {
+        return await this.fetch({
+            path: `/shipments/${shipmentId}`,
+            method: 'GET'
+        })
+            .then(response => response.json())
+            .catch(err => {
+            this.logger_.error(err);
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Veeqo shipment with veeqo_shipment_id ${shipmentId} not found`);
+        });
+    }
+    /**
+     * Fetches tracking events for a shipment from Veeqo by Veeqo Shipment ID. Returns an array of tracking events.
+     */
+    async fetchTrackingEvents(shipmentId) {
+        return await this.fetch({
+            path: `/shipments/tracking_events/${shipmentId}`,
+            method: 'GET'
+        })
+            .then(response => response.json())
+            .catch(err => {
+            this.logger_.error(err);
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Tracking events for shipment with veeqo_shipment_id ${shipmentId} not found`);
+        });
+    }
+    /**
+     * Fetches a warehouse (Stock Location) from Veeqo by Veeqo Warehouse ID. Returns the Veeqo warehouse or null if not found.
+     */
+    async fetchWarehouse(warehouseId) {
+        return await this.fetch({
+            path: `/warehouses/${warehouseId}`,
+            method: 'GET'
+        })
+            .then(response => response.json())
+            .catch(err => {
+            this.logger_.error(err);
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Veeqo warehouse with veeqo_warehouse_id ${warehouseId} not found`);
+        });
+    }
+    /**
+     * Adds a channel to Veeqo and links it to the corresponding sales channel in Medusa. First argument is the Medusa sales channel ID, second argument is the input data to create the channel in Veeqo. Returns the created Veeqo channel.
+     */
+    async addChannel(salesChannelId, channelInput) {
+        const veeqoChannel = (await this.fetch({
+            path: `/channels`,
+            method: 'POST',
+            body: { channel: channelInput }
+        })
+            .then(response => response.json())
+            .catch(err => this.logger_.error(err)));
+        if (!veeqoChannel?.id) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to create channel in Veeqo for sales channel ${salesChannelId}`);
+        }
+        await this.createVeeqoChannels({
+            sales_channel_id: salesChannelId,
+            veeqo_channel_id: veeqoChannel.id
+        });
+        return veeqoChannel;
+    }
+    /**
+     * Adds a customer to Veeqo and links it to the corresponding customer in Medusa. First argument is the Medusa customer ID, second argument is the input data to create the customer in Veeqo. Returns the created Veeqo customer.
+     */
+    async addCustomer(customerId, customerInput) {
+        const veeqoCustomer = (await this.fetch({
+            path: `/customers`,
+            method: 'POST',
+            body: { customer: customerInput }
+        })
+            .then(response => response.json())
+            .catch(err => this.logger_.error(err)));
+        if (!veeqoCustomer?.id) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to create customer in Veeqo for customer ${customerId}`);
+        }
+        await this.createVeeqoCustomers({
+            customer_id: customerId,
+            veeqo_customer_id: veeqoCustomer.id
+        });
+        return veeqoCustomer;
+    }
+    /**
+     * Adds a delivery method to Veeqo and links it to the corresponding shipping option in Medusa. First argument is the Medusa shipping option ID, second argument is the input data to create the delivery method in Veeqo. Returns the created Veeqo delivery method.
+     */
+    async addDeliveryMethod(shippingOptionId, deliveryMethodInput) {
+        const veeqoDeliveryMethod = (await this.fetch({
+            path: `/delivery_methods`,
+            method: 'POST',
+            body: deliveryMethodInput
+        })
+            .then(response => response.json())
+            .catch(err => this.logger_.error(err)));
+        if (!veeqoDeliveryMethod?.id) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to create delivery method in Veeqo for shipping option ${shippingOptionId}`);
+        }
+        await this.createVeeqoDeliveryMethods({
+            shipping_option_id: shippingOptionId,
+            veeqo_delivery_method_id: veeqoDeliveryMethod.id
+        });
+        return veeqoDeliveryMethod;
+    }
+    /**
+     * Adds an order to Veeqo and links it to the corresponding order in Medusa. First argument is the Medusa order ID, second argument is the input data to create the order in Veeqo. Returns the created Veeqo order.
+     */
+    async addOrder(orderId, orderInput) {
+        const veeqoOrder = (await this.fetch({
+            path: `/orders`,
+            method: 'POST',
+            body: { order: orderInput }
+        })
+            .then(response => response.json())
+            .catch(err => this.logger_.error(err)));
+        if (!veeqoOrder?.id) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to create order in Veeqo for order ${orderId}`);
+        }
+        // Resolve the local VeeqoCustomer DB record so we can set the required FK
+        const dbCustomers = await this.listVeeqoCustomers({ veeqo_customer_id: orderInput.customer_id }, { take: 1 });
+        const dbCustomer = dbCustomers[0];
+        await this.createVeeqoOrders({
+            order_id: orderId,
+            veeqo_order_id: veeqoOrder.id,
+            ...(dbCustomer ? { veeqo_customer_id: dbCustomer.id } : {})
+        });
+        return veeqoOrder;
+    }
+    /**
+     * Adds a product to Veeqo and links it to the corresponding product in Medusa. First argument is the Medusa product ID, second argument is the input data to create the product in Veeqo. Returns the created Veeqo product.
+     */
+    async addProduct(product, productInput) {
+        const veeqoProduct = (await this.fetch({
+            path: `/products`,
+            method: 'POST',
+            body: { product: productInput }
+        })
+            .then(response => response.json())
+            .catch(err => this.logger_.error(err)));
+        if (!veeqoProduct?.id) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to create product in Veeqo for product ${product.id}`);
+        }
+        await this.createVeeqoProducts({
+            product_id: product.id,
+            veeqo_product_id: veeqoProduct.id
+        });
+        for (const sellable of veeqoProduct.sellables) {
+            const matchingVariant = product.variants?.find(variant => variant.sku === sellable.sku_code);
+            if (matchingVariant) {
+                await this.createVeeqoSellables({
+                    product_variant_id: matchingVariant.id,
+                    veeqo_sellable_id: sellable.id
+                });
+            }
+        }
+        await this.addInfiniteStockForSellables(veeqoProduct.sellables);
+        return veeqoProduct;
+    }
+    /**
+     * Adds a warehouse (Stock Location) to Veeqo and links it to the corresponding warehouse in Medusa. First argument is the Medusa stock location ID, second argument is the input data to create the warehouse in Veeqo. Returns the created Veeqo warehouse.
+     */
+    async addWarehouse(stockLocationId, warehouseInput) {
+        const veeqoWarehouse = (await this.fetch({
+            path: `/warehouses`,
+            method: 'POST',
+            body: warehouseInput
+        })
+            .then(response => response.json())
+            .catch(err => this.logger_.error(err)));
+        if (!veeqoWarehouse?.id) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to create warehouse in Veeqo for stock location ${stockLocationId}`);
+        }
+        await this.createVeeqoWarehouses({
+            stock_location_id: stockLocationId,
+            veeqo_warehouse_id: veeqoWarehouse.id
+        });
+        return veeqoWarehouse;
+    }
+    /**
+     * Updates a channel in Veeqo. First argument is the Veeqo channel ID, second argument is the input data to update the channel in Veeqo. Returns the updated Veeqo channel.
+     */
+    async updateChannel(veeqoChannelId, veeqoChannelInput) {
+        const veeqoChannel = (await this.fetch({
+            path: `/channels/${veeqoChannelId}`,
+            method: 'PUT',
+            body: veeqoChannelInput
+        })
+            .then(response => response.json())
+            .catch(err => this.logger_.error(err)));
+        if (!veeqoChannel?.id) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to update channel in Veeqo with Veeqo ID ${veeqoChannelId}`);
+        }
+        return veeqoChannel;
+    }
+    /**
+     * Updates a customer in Veeqo. First argument is the Veeqo customer ID, second argument is the input data to update the customer in Veeqo. Returns the updated Veeqo customer.
+     */
+    async updateCustomer(veeqoCustomerId, veeqoCustomerInput) {
+        const veeqoCustomer = (await this.fetch({
+            path: `/customers/${veeqoCustomerId}`,
+            method: 'PUT',
+            body: { customer: veeqoCustomerInput }
+        })
+            .then(response => response.json())
+            .catch(err => this.logger_.error(err)));
+        if (!veeqoCustomer?.id) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to update customer in Veeqo with Veeqo ID ${veeqoCustomerId}`);
+        }
+        return veeqoCustomer;
+    }
+    /**
+     * Updates a delivery method in Veeqo. First argument is the Veeqo delivery method ID, second argument is the input data to update the delivery method in Veeqo. Returns the updated Veeqo delivery method.
+     */
+    async updateDeliveryMethod(veeqoDeliveryMethodId, veeqoDeliveryMethodInput) {
+        const veeqoDeliveryMethod = (await this.fetch({
+            path: `/delivery_methods/${veeqoDeliveryMethodId}`,
+            method: 'PUT',
+            body: veeqoDeliveryMethodInput
+        })
+            .then(response => response.json())
+            .catch(err => this.logger_.error(err)));
+        if (!veeqoDeliveryMethod?.id) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to update delivery method in Veeqo with Veeqo ID ${veeqoDeliveryMethodId}`);
+        }
+        return veeqoDeliveryMethod;
+    }
+    /**
+     * Updates an order in Veeqo. First argument is the Veeqo order ID, second argument is the input data to update the order in Veeqo. Returns the updated Veeqo order.
+     */
+    async updateOrder(veeqoOrderId, veeqoOrderInput) {
+        const veeqoOrder = (await this.fetch({
+            path: `/orders/${veeqoOrderId}`,
+            method: 'PUT',
+            body: { order: veeqoOrderInput }
+        })
+            .then(response => response.json())
+            .catch(err => this.logger_.error(err)));
+        if (!veeqoOrder?.id) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to update order in Veeqo with Veeqo ID ${veeqoOrderId}`);
+        }
+        return veeqoOrder;
+    }
+    /**
+     * Updates a product in Veeqo. First argument is the Veeqo product ID, second argument is the input data to update the product in Veeqo. Returns the updated Veeqo product.
+     */
+    async updateProduct(veeqoProductId, veeqoProductInput) {
+        const veeqoProduct = (await this.fetch({
+            path: `/products/${veeqoProductId}`,
+            method: 'PUT',
+            body: { product: veeqoProductInput }
+        })
+            .then(response => response.json())
+            .catch(err => this.logger_.error(err)));
+        if (!veeqoProduct?.id) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to update product in Veeqo with Veeqo ID ${veeqoProductId}`);
+        }
+        const needStockEntryUpdate = veeqoProduct.sellables?.filter(sellable => {
+            sellable.inventory.infinite === false;
+        });
+        if (needStockEntryUpdate?.length)
+            await this.addInfiniteStockForSellables(needStockEntryUpdate);
+        return veeqoProduct;
+    }
+    /**
+     * Updates a warehouse (Stock Location) in Veeqo. First argument is the Veeqo warehouse ID, second argument is the input data to update the warehouse in Veeqo. Returns the updated Veeqo warehouse.
+     */
+    async updateWarehouse(veeqoWarehouseId, veeqoWarehouseInput) {
+        const veeqoWarehouse = (await this.fetch({
+            path: `/warehouses/${veeqoWarehouseId}`,
+            method: 'PUT',
+            body: { warehouse: veeqoWarehouseInput }
+        })
+            .then(response => response.json())
+            .catch(err => this.logger_.error(err)));
+        if (!veeqoWarehouse?.id) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to update warehouse in Veeqo with Veeqo ID ${veeqoWarehouseId}`);
+        }
+        return veeqoWarehouse;
+    }
+    /**
+     * Deletes a channel in Veeqo by Medusa sales channel ID and unlinks it in Medusa.
+     */
+    async deleteChannel(salesChannelId) {
+        const [veeqoChannel] = await this.listVeeqoChannels({ sales_channel_id: salesChannelId });
+        if (!veeqoChannel) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Veeqo channel linked to sales channel ${salesChannelId} not found`);
+        }
+        const { id, veeqo_channel_id } = veeqoChannel;
+        const success = await this.fetch({
+            path: `/channels/${veeqo_channel_id}`,
+            method: 'DELETE'
+        })
+            .then(async (response) => { await response.text(); return response.ok; })
+            .catch(err => this.logger_.error(err));
+        if (!success) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to delete channel in Veeqo with Veeqo ID ${veeqo_channel_id}`);
+        }
+        return this.deleteVeeqoChannels(id);
+    }
+    /**
+     * Deletes a customer in Veeqo by Medusa customer ID. Since Veeqo does not allow deleting customers, this only unlinks the customer in Medusa so it is no longer associated with the Veeqo customer.
+     */
+    async deleteCustomer(customerId) {
+        const [veeqoCustomer] = await this.listVeeqoCustomers({ customer_id: customerId });
+        return this.deleteVeeqoCustomers(veeqoCustomer?.id);
+    }
+    /**
+     * Deletes a delivery method in Veeqo by Medusa shipping option ID and unlinks it in Medusa.
+     */
+    async deleteDeliveryMethod(shippingOptionId) {
+        const [veeqoDeliveryMethod] = await this.listVeeqoDeliveryMethods({
+            shipping_option_id: shippingOptionId
+        });
+        if (!veeqoDeliveryMethod) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Veeqo delivery method linked to shipping option ${shippingOptionId} not found`);
+        }
+        const { id, veeqo_delivery_method_id } = veeqoDeliveryMethod;
+        const success = await this.fetch({
+            path: `/delivery_methods/${veeqo_delivery_method_id}`,
+            method: 'DELETE'
+        })
+            .then(response => response.ok)
+            .catch(err => this.logger_.error(err));
+        if (!success) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to delete delivery method in Veeqo with Veeqo ID ${veeqo_delivery_method_id}`);
+        }
+        return this.deleteVeeqoDeliveryMethods(id);
+    }
+    /**
+     * Cancels an order in Veeqo by Medusa order ID and unlinks it in Medusa. Veeqo does not allow deleting orders, but canceling the order will hide it in the Veeqo interface.
+     */
+    async deleteOrder(orderId, cancelReason = '') {
+        const [veeqoOrder] = await this.listVeeqoOrders({ order_id: orderId });
+        if (!veeqoOrder) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Veeqo order linked to order ${orderId} not found`);
+        }
+        const { id, veeqo_order_id } = veeqoOrder;
+        if (!cancelReason)
+            cancelReason = 'Cancelled from Medusa';
+        const success = await this.fetch({
+            path: `/orders/${veeqo_order_id}/cancel`,
+            method: 'PUT',
+            body: {
+                reason: cancelReason,
+                send_veeqo_email: false
+            }
+        })
+            .then(response => response.ok)
+            .catch(err => this.logger_.error(err));
+        if (!success) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to cancel order in Veeqo with Veeqo ID ${veeqo_order_id}`);
+        }
+        return this.deleteVeeqoOrders(id);
+    }
+    /**
+     * Deletes a product in Veeqo by Medusa product ID and unlinks it in Medusa.
+     */
+    async deleteProduct(productId) {
+        const [veeqoProduct] = await this.listVeeqoProducts({ product_id: productId });
+        if (!veeqoProduct) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Veeqo product linked to product ${productId} not found`);
+        }
+        const { id, veeqo_product_id } = veeqoProduct;
+        const success = await this.fetch({
+            path: `/products/${veeqo_product_id}`,
+            method: 'DELETE'
+        })
+            .then(response => response.ok)
+            .catch(err => this.logger_.error(err));
+        if (!success) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to delete product in Veeqo with Veeqo ID ${veeqo_product_id}`);
+        }
+        return this.deleteVeeqoProducts(id);
+    }
+    /**
+     * Deletes a warehouse (Stock Location) in Veeqo by Medusa stock location ID and unlinks it in Medusa.
+     */
+    async deleteWarehouse(stockLocationId) {
+        const [veeqoWarehouse] = await this.listVeeqoWarehouses({
+            stock_location_id: stockLocationId
+        });
+        if (!veeqoWarehouse) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.NOT_FOUND, `Veeqo warehouse linked to stock location ${stockLocationId} not found`);
+        }
+        const { id, veeqo_warehouse_id } = veeqoWarehouse;
+        const success = await this.fetch({
+            path: `/warehouses/${veeqo_warehouse_id}`,
+            method: 'DELETE'
+        })
+            .then(response => response.ok)
+            .catch(err => this.logger_.error(err));
+        if (!success) {
+            throw new utils_2.MedusaError(utils_2.MedusaError.Types.UNEXPECTED_STATE, `Failed to delete warehouse in Veeqo with Veeqo ID ${veeqo_warehouse_id}`);
+        }
+        return this.deleteVeeqoWarehouses(id);
+    }
+    async addInfiniteStockForSellables(sellables) {
+        const warehouses = await this.listVeeqoWarehouses();
+        for (const sellable of sellables) {
+            const stockEntry = {
+                physical_stock_level: 200,
+                infinite: true
+            };
+            for (const warehouse of warehouses) {
+                await this.fetch({
+                    path: `/sellables/${sellable.id}/warehouses/${warehouse.veeqo_warehouse_id}/stock_entry`,
+                    method: 'PUT',
+                    body: { stock_entry: stockEntry }
+                })
+                    .then(response => response?.json())
+                    .catch(err => this.logger_.error(err));
+            }
+        }
+    }
+}
+exports.VeeqoService = VeeqoService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/veeqo/service.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/modules/veeqo/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy92ZWVxby90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/.medusa/server/src/subscribers/veeqo-dispatcher.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = veeqoDispatchHandler;
+const order_1 = require("../workflows/order");
+exports.config = {
+    event: 'order.placed'
+};
+async function veeqoDispatchHandler({ event: { data: { id: orderId } }, container }) {
+    await (0, order_1.syncOrderToVeeqoWorkflow)(container).run({ input: orderId });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVlcW8tZGlzcGF0Y2hlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zdWJzY3JpYmVycy92ZWVxby1kaXNwYXRjaGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQU9BLHVDQU9DO0FBYkQsOENBQTZEO0FBRWhELFFBQUEsTUFBTSxHQUFxQjtJQUN2QyxLQUFLLEVBQUUsY0FBYztDQUNyQixDQUFBO0FBRWMsS0FBSyxVQUFVLG9CQUFvQixDQUFDLEVBQ2xELEtBQUssRUFBRSxFQUNOLElBQUksRUFBRSxFQUFFLEVBQUUsRUFBRSxPQUFPLEVBQUUsRUFDckIsRUFDRCxTQUFTLEVBQ3VCO0lBQ2hDLE1BQU0sSUFBQSxnQ0FBd0IsRUFBQyxTQUFTLENBQUMsQ0FBQyxHQUFHLENBQUMsRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQTtBQUNsRSxDQUFDIn0=