@medusajs/medusa 1.3.2 → 1.3.3

package/dist/services/product.js

@@ -110,78 +110,46 @@ var __values = (this && this.__values) || function(o) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var medusa_core_utils_1 = require("medusa-core-utils");
-var medusa_interfaces_1 = require("medusa-interfaces");
-var typeorm_1 = require("typeorm");
+var interfaces_1 = require("../interfaces");
+var utils_1 = require("../utils");
 var exception_formatter_1 = require("../utils/exception-formatter");
-var products_1 = require("../api/routes/admin/products");
-/**
- * Provides layer to manipulate products.
- * @extends BaseService
- */
 var ProductService = /** @class */ (function (_super) {
     __extends(ProductService, _super);
     function ProductService(_a) {
-        var manager = _a.manager, productRepository = _a.productRepository, productVariantRepository = _a.productVariantRepository, productOptionRepository = _a.productOptionRepository, eventBusService = _a.eventBusService, productVariantService = _a.productVariantService, productCollectionService = _a.productCollectionService, productTypeRepository = _a.productTypeRepository, productTagRepository = _a.productTagRepository, imageRepository = _a.imageRepository, searchService = _a.searchService, cartRepository = _a.cartRepository, priceSelectionStrategy = _a.priceSelectionStrategy;
-        var _this = _super.call(this) || this;
-        /** @private @const {EntityManager} */
+        var manager = _a.manager, productRepository = _a.productRepository, productVariantRepository = _a.productVariantRepository, productOptionRepository = _a.productOptionRepository, eventBusService = _a.eventBusService, productVariantService = _a.productVariantService, productTypeRepository = _a.productTypeRepository, productTagRepository = _a.productTagRepository, imageRepository = _a.imageRepository, searchService = _a.searchService;
+        var _this = _super.call(this, {
+            manager: manager,
+            productRepository: productRepository,
+            productVariantRepository: productVariantRepository,
+            productOptionRepository: productOptionRepository,
+            eventBusService: eventBusService,
+            productVariantService: productVariantService,
+            productTypeRepository: productTypeRepository,
+            productTagRepository: productTagRepository,
+            imageRepository: imageRepository,
+            searchService: searchService,
+        }) || this;
         _this.manager_ = manager;
-        /** @private @const {ProductOption} */
         _this.productOptionRepository_ = productOptionRepository;
-        /** @private @const {Product} */
         _this.productRepository_ = productRepository;
-        /** @private @const {ProductVariant} */
         _this.productVariantRepository_ = productVariantRepository;
-        /** @private @const {EventBus} */
         _this.eventBus_ = eventBusService;
-        /** @private @const {ProductVariantService} */
         _this.productVariantService_ = productVariantService;
-        /** @private @const {ProductCollectionService} */
-        _this.productCollectionService_ = productCollectionService;
-        /** @private @const {ProductCollectionService} */
         _this.productTypeRepository_ = productTypeRepository;
-        /** @private @const {ProductCollectionService} */
         _this.productTagRepository_ = productTagRepository;
-        /** @private @const {ImageRepository} */
         _this.imageRepository_ = imageRepository;
-        /** @private @const {SearchService} */
         _this.searchService_ = searchService;
-        /** @private @const {CartRepository} */
-        _this.cartRepository_ = cartRepository;
-        /** @private @const {IPriceSelectionStrategy} */
-        _this.priceSelectionStrategy_ = priceSelectionStrategy;
         return _this;
     }
-    ProductService.prototype.withTransaction = function (transactionManager) {
-        if (!transactionManager) {
-            return this;
-        }
-        var cloned = new ProductService({
-            manager: transactionManager,
-            productRepository: this.productRepository_,
-            productVariantRepository: this.productVariantRepository_,
-            productOptionRepository: this.productOptionRepository_,
-            eventBusService: this.eventBus_,
-            productVariantService: this.productVariantService_,
-            productCollectionService: this.productCollectionService_,
-            productTagRepository: this.productTagRepository_,
-            productTypeRepository: this.productTypeRepository_,
-            imageRepository: this.imageRepository_,
-            cartRepository: this.cartRepository_,
-            priceSelectionStrategy: this.priceSelectionStrategy_,
-        });
-        cloned.transactionManager_ = transactionManager;
-        return cloned;
-    };
     /**
      * Lists products based on the provided parameters.
-     * @param {object} selector - an object that defines rules to filter products
+     * @param selector - an object that defines rules to filter products
      *   by
-     * @param {object} config - object that defines the scope for what should be
+     * @param config - object that defines the scope for what should be
      *   returned
-     * @return {Promise<Product[]>} the result of the find operation
+     * @return the result of the find operation
      */
     ProductService.prototype.list = function (selector, config) {
-        var _a, _b, _c;
         if (selector === void 0) { selector = {}; }
         if (config === void 0) { config = {
             relations: [],
@@ -190,34 +158,27 @@ var ProductService = /** @class */ (function (_super) {
             include_discount_prices: false,
         }; }
         return __awaiter(this, void 0, void 0, function () {
-            var productRepo, priceIndex, _d, q, query, relations, qb, raw, products, _e;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        productRepo = this.manager_.getCustomRepository(this.productRepository_);
-                        priceIndex = (_b = (_a = config.relations) === null || _a === void 0 ? void 0 : _a.indexOf("variants.prices")) !== null && _b !== void 0 ? _b : -1;
-                        if (priceIndex >= 0 && config.relations) {
-                            config.relations = __spreadArray([], __read(config.relations), false);
-                            config.relations.splice(priceIndex, 1);
-                        }
-                        _d = this.prepareListQuery_(selector, config), q = _d.q, query = _d.query, relations = _d.relations;
-                        if (!q) return [3 /*break*/, 2];
-                        qb = this.getFreeTextQueryBuilder_(productRepo, query, q);
-                        return [4 /*yield*/, qb.getMany()];
-                    case 1:
-                        raw = _f.sent();
-                        return [2 /*return*/, productRepo.findWithRelations(relations, raw.map(function (i) { return i.id; }), (_c = query.withDeleted) !== null && _c !== void 0 ? _c : false)];
-                    case 2:
-                        products = productRepo.findWithRelations(relations, query);
-                        if (!(priceIndex > -1)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.setAdditionalPrices(products, config.currency_code, config.region_id, config.cart_id, config.customer_id, config.include_discount_prices)];
-                    case 3:
-                        _e = _f.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        _e = products;
-                        _f.label = 5;
-                    case 5: return [2 /*return*/, _e];
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productRepo, _a, q, query, relations, _b, products;
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        productRepo = manager.getCustomRepository(this.productRepository_);
+                                        _a = this.prepareListQuery_(selector, config), q = _a.q, query = _a.query, relations = _a.relations;
+                                        if (!q) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, productRepo.getFreeTextSearchResultsAndCount(q, query, relations)];
+                                    case 1:
+                                        _b = __read.apply(void 0, [_c.sent(), 1]), products = _b[0];
+                                        return [2 /*return*/, products];
+                                    case 2: return [4 /*yield*/, productRepo.findWithRelations(relations, query)];
+                                    case 3: return [2 /*return*/, _c.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
@@ -225,17 +186,15 @@ var ProductService = /** @class */ (function (_super) {
     /**
      * Lists products based on the provided parameters and includes the count of
      * products that match the query.
-     * @param {object} selector - an object that defines rules to filter products
+     * @param selector - an object that defines rules to filter products
      *   by
-     * @param {object} config - object that defines the scope for what should be
+     * @param config - object that defines the scope for what should be
      *   returned
-     * @return {Promise<[Product[], number]>} an array containing the products as
+     * @return an array containing the products as
      *   the first element and the total count of products that matches the query
      *   as the second element.
      */
     ProductService.prototype.listAndCount = function (selector, config) {
-        var _a, _b, _c;
-        if (selector === void 0) { selector = {}; }
         if (config === void 0) { config = {
             relations: [],
             skip: 0,
@@ -243,35 +202,25 @@ var ProductService = /** @class */ (function (_super) {
             include_discount_prices: false,
         }; }
         return __awaiter(this, void 0, void 0, function () {
-            var productRepo, priceIndex, _d, q, query, relations, qb, _e, raw, count_1, products_2, _f, products, count, productsWithAdditionalPrices;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
-                    case 0:
-                        productRepo = this.manager_.getCustomRepository(this.productRepository_);
-                        priceIndex = (_b = (_a = config.relations) === null || _a === void 0 ? void 0 : _a.indexOf("variants.prices")) !== null && _b !== void 0 ? _b : -1;
-                        if (priceIndex >= 0 && config.relations) {
-                            config.relations = __spreadArray([], __read(config.relations), false);
-                            config.relations.splice(priceIndex, 1);
-                        }
-                        _d = this.prepareListQuery_(selector, config), q = _d.q, query = _d.query, relations = _d.relations;
-                        if (!q) return [3 /*break*/, 3];
-                        qb = this.getFreeTextQueryBuilder_(productRepo, query, q);
-                        return [4 /*yield*/, qb.getManyAndCount()];
-                    case 1:
-                        _e = __read.apply(void 0, [_g.sent(), 2]), raw = _e[0], count_1 = _e[1];
-                        return [4 /*yield*/, productRepo.findWithRelations(relations, raw.map(function (i) { return i.id; }), (_c = query.withDeleted) !== null && _c !== void 0 ? _c : false)];
-                    case 2:
-                        products_2 = _g.sent();
-                        return [2 /*return*/, [products_2, count_1]];
-                    case 3: return [4 /*yield*/, productRepo.findWithRelationsAndCount(relations, query)];
-                    case 4:
-                        _f = __read.apply(void 0, [_g.sent(), 2]), products = _f[0], count = _f[1];
-                        if (!(priceIndex > -1)) return [3 /*break*/, 6];
-                        return [4 /*yield*/, this.setAdditionalPrices(products, config.currency_code, config.region_id, config.cart_id, config.customer_id, config.include_discount_prices)];
-                    case 5:
-                        productsWithAdditionalPrices = _g.sent();
-                        return [2 /*return*/, [productsWithAdditionalPrices, count]];
-                    case 6: return [2 /*return*/, [products, count]];
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productRepo, _a, q, query, relations;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        productRepo = manager.getCustomRepository(this.productRepository_);
+                                        _a = this.prepareListQuery_(selector, config), q = _a.q, query = _a.query, relations = _a.relations;
+                                        if (!q) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, productRepo.getFreeTextSearchResultsAndCount(q, query, relations)];
+                                    case 1: return [2 /*return*/, _b.sent()];
+                                    case 2: return [4 /*yield*/, productRepo.findWithRelationsAndCount(relations, query)];
+                                    case 3: return [2 /*return*/, _b.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
@@ -283,57 +232,52 @@ var ProductService = /** @class */ (function (_super) {
      */
     ProductService.prototype.count = function (selector) {
         if (selector === void 0) { selector = {}; }
-        var productRepo = this.manager_.getCustomRepository(this.productRepository_);
-        var query = this.buildQuery_(selector);
-        return productRepo.count(query);
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productRepo, query;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        productRepo = manager.getCustomRepository(this.productRepository_);
+                                        query = (0, utils_1.buildQuery)(selector);
+                                        return [4 /*yield*/, productRepo.count(query)];
+                                    case 1: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
     };
     /**
      * Gets a product by id.
      * Throws in case of DB Error and if product was not found.
-     * @param {string} productId - id of the product to get.
-     * @param {object} config - object that defines what should be included in the
+     * @param productId - id of the product to get.
+     * @param config - object that defines what should be included in the
      *   query response
-     * @return {Promise<Product>} the result of the find one operation.
+     * @return the result of the find one operation.
      */
     ProductService.prototype.retrieve = function (productId, config) {
-        var _a, _b;
-        if (config === void 0) { config = { include_discount_prices: false }; }
+        if (config === void 0) { config = {
+            include_discount_prices: false,
+        }; }
         return __awaiter(this, void 0, void 0, function () {
-            var productRepo, validatedId, priceIndex, query, rels, product, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        productRepo = this.manager_.getCustomRepository(this.productRepository_);
-                        validatedId = this.validateId_(productId);
-                        priceIndex = (_b = (_a = config.relations) === null || _a === void 0 ? void 0 : _a.indexOf("variants.prices")) !== null && _b !== void 0 ? _b : -1;
-                        if (priceIndex >= 0 && config.relations) {
-                            config.relations = __spreadArray([], __read(config.relations), false);
-                            config.relations.splice(priceIndex, 1);
-                        }
-                        query = { where: { id: validatedId } };
-                        if (config.relations && config.relations.length > 0) {
-                            query.relations = config.relations;
-                        }
-                        if (config.select && config.select.length > 0) {
-                            query.select = config.select;
-                        }
-                        rels = query.relations;
-                        delete query.relations;
-                        return [4 /*yield*/, productRepo.findOneWithRelations(rels, query)];
-                    case 1:
-                        product = _d.sent();
-                        if (!product) {
-                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Product with id: ".concat(productId, " was not found"));
-                        }
-                        if (!(priceIndex > -1)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.setAdditionalPrices(product, config.currency_code, config.region_id, config.cart_id, config.customer_id, config.include_discount_prices)];
-                    case 2:
-                        _c = _d.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _c = product;
-                        _d.label = 4;
-                    case 4: return [2 /*return*/, _c];
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.retrieve_({ id: productId }, config)];
+                                    case 1: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
@@ -341,48 +285,25 @@ var ProductService = /** @class */ (function (_super) {
     /**
      * Gets a product by handle.
      * Throws in case of DB Error and if product was not found.
-     * @param {string} productHandle - handle of the product to get.
-     * @param {object} config - details about what to get from the product
-     * @return {Promise<Product>} the result of the find one operation.
+     * @param productHandle - handle of the product to get.
+     * @param config - details about what to get from the product
+     * @return the result of the find one operation.
      */
     ProductService.prototype.retrieveByHandle = function (productHandle, config) {
-        var _a, _b;
         if (config === void 0) { config = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var productRepo, priceIndex, query, rels, product, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        productRepo = this.manager_.getCustomRepository(this.productRepository_);
-                        priceIndex = (_b = (_a = config.relations) === null || _a === void 0 ? void 0 : _a.indexOf("variants.prices")) !== null && _b !== void 0 ? _b : -1;
-                        if (priceIndex >= 0 && config.relations) {
-                            config.relations = __spreadArray([], __read(config.relations), false);
-                            config.relations.splice(priceIndex, 1);
-                        }
-                        query = { where: { handle: productHandle } };
-                        if (config.relations && config.relations.length > 0) {
-                            query.relations = config.relations;
-                        }
-                        if (config.select && config.select.length > 0) {
-                            query.select = config.select;
-                        }
-                        rels = query.relations;
-                        delete query.relations;
-                        return [4 /*yield*/, productRepo.findOneWithRelations(rels, query)];
-                    case 1:
-                        product = _d.sent();
-                        if (!product) {
-                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Product with handle: ".concat(productHandle, " was not found"));
-                        }
-                        if (!(priceIndex > -1)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.setAdditionalPrices(product, config.currency_code, config.region_id, config.cart_id, config.customer_id, config.include_discount_prices)];
-                    case 2:
-                        _c = _d.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _c = product;
-                        _d.label = 4;
-                    case 4: return [2 /*return*/, _c];
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.retrieve_({ handle: productHandle }, config)];
+                                    case 1: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
@@ -390,319 +311,246 @@ var ProductService = /** @class */ (function (_super) {
     /**
      * Gets a product by external id.
      * Throws in case of DB Error and if product was not found.
-     * @param {string} externalId - handle of the product to get.
-     * @param {object} config - details about what to get from the product
-     * @return {Promise<Product>} the result of the find one operation.
+     * @param externalId - handle of the product to get.
+     * @param config - details about what to get from the product
+     * @return the result of the find one operation.
      */
     ProductService.prototype.retrieveByExternalId = function (externalId, config) {
-        var _a, _b;
         if (config === void 0) { config = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var productRepo, priceIndex, query, rels, product, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        productRepo = this.manager_.getCustomRepository(this.productRepository_);
-                        priceIndex = (_b = (_a = config.relations) === null || _a === void 0 ? void 0 : _a.indexOf("variants.prices")) !== null && _b !== void 0 ? _b : -1;
-                        if (priceIndex >= 0 && config.relations) {
-                            config.relations = __spreadArray([], __read(config.relations), false);
-                            config.relations.splice(priceIndex, 1);
-                        }
-                        query = { where: { external_id: externalId } };
-                        if (config.relations && config.relations.length > 0) {
-                            query.relations = config.relations;
-                        }
-                        if (config.select && config.select.length > 0) {
-                            query.select = config.select;
-                        }
-                        rels = query.relations;
-                        delete query.relations;
-                        return [4 /*yield*/, productRepo.findOneWithRelations(rels, query)];
-                    case 1:
-                        product = _d.sent();
-                        if (!product) {
-                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Product with exteral_id: ".concat(externalId, " was not found"));
-                        }
-                        if (!(priceIndex > -1)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.setAdditionalPrices(product, config.currency_code, config.region_id, config.cart_id, config.customer_id, config.include_discount_prices)];
-                    case 2:
-                        _c = _d.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _c = product;
-                        _d.label = 4;
-                    case 4: return [2 /*return*/, _c];
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.retrieve_({ external_id: externalId }, config)];
+                                    case 1: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
     /**
-     * Gets all variants belonging to a product.
-     * @param {string} productId - the id of the product to get variants from.
-     * @param {FindConfig<Product>} config - The config to select and configure relations etc...
-     * @return {Promise} an array of variants
+     * Gets a product by selector.
+     * Throws in case of DB Error and if product was not found.
+     * @param selector - selector object
+     * @param config - object that defines what should be included in the
+     *   query response
+     * @return the result of the find one operation.
      */
-    ProductService.prototype.retrieveVariants = function (productId, config) {
+    ProductService.prototype.retrieve_ = function (selector, config) {
         if (config === void 0) { config = {
-            skip: 0,
-            take: 50,
-            relations: products_1.defaultAdminProductsVariantsRelations,
+            include_discount_prices: false,
         }; }
         return __awaiter(this, void 0, void 0, function () {
-            var product;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.retrieve(productId, config)];
-                    case 1:
-                        product = _a.sent();
-                        return [2 /*return*/, product.variants];
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productRepo, _a, relations, query, product, selectorConstraints;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        productRepo = manager.getCustomRepository(this.productRepository_);
+                                        _a = (0, utils_1.buildQuery)(selector, config), relations = _a.relations, query = __rest(_a, ["relations"]);
+                                        return [4 /*yield*/, productRepo.findOneWithRelations(relations, query)];
+                                    case 1:
+                                        product = _b.sent();
+                                        if (!product) {
+                                            selectorConstraints = Object.entries(selector)
+                                                .map(function (_a) {
+                                                var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                                                return "".concat(key, ": ").concat(value);
+                                            })
+                                                .join(", ");
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Product with ".concat(selectorConstraints, " was not found"));
+                                        }
+                                        return [2 /*return*/, product];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    ProductService.prototype.listTypes = function () {
+    /**
+     * Gets all variants belonging to a product.
+     * @param productId - the id of the product to get variants from.
+     * @param config - The config to select and configure relations etc...
+     * @return an array of variants
+     */
+    ProductService.prototype.retrieveVariants = function (productId, config) {
+        if (config === void 0) { config = {
+            skip: 0,
+            take: 50,
+        }; }
         return __awaiter(this, void 0, void 0, function () {
-            var productTypeRepository;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        productTypeRepository = this.manager_.getCustomRepository(this.productTypeRepository_);
-                        return [4 /*yield*/, productTypeRepository.find({})];
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function () { return __awaiter(_this, void 0, void 0, function () {
+                            var givenRelations, requiredRelations, relationsSet, product;
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        givenRelations = (_a = config.relations) !== null && _a !== void 0 ? _a : [];
+                                        requiredRelations = ["variants"];
+                                        relationsSet = new Set(__spreadArray(__spreadArray([], __read(givenRelations), false), __read(requiredRelations), false));
+                                        return [4 /*yield*/, this.retrieve(productId, __assign(__assign({}, config), { relations: __spreadArray([], __read(relationsSet), false) }))];
+                                    case 1:
+                                        product = _b.sent();
+                                        return [2 /*return*/, product.variants];
+                                }
+                            });
+                        }); })];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    ProductService.prototype.listTagsByUsage = function (count) {
-        if (count === void 0) { count = 10; }
+    ProductService.prototype.listTypes = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var tags;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.manager_.query("\n      SELECT ID, O.USAGE_COUNT, PT.VALUE\n      FROM PRODUCT_TAG PT\n      LEFT JOIN\n        (SELECT COUNT(*) AS USAGE_COUNT,\n          PRODUCT_TAG_ID\n          FROM PRODUCT_TAGS\n          GROUP BY PRODUCT_TAG_ID) O ON O.PRODUCT_TAG_ID = PT.ID\n      ORDER BY O.USAGE_COUNT DESC\n      LIMIT $1", [count])];
-                    case 1:
-                        tags = _a.sent();
-                        return [2 /*return*/, tags];
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productTypeRepository;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        productTypeRepository = manager.getCustomRepository(this.productTypeRepository_);
+                                        return [4 /*yield*/, productTypeRepository.find({})];
+                                    case 1: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    ProductService.prototype.upsertProductType_ = function (type) {
+    ProductService.prototype.listTagsByUsage = function (count) {
+        if (count === void 0) { count = 10; }
         return __awaiter(this, void 0, void 0, function () {
-            var productTypeRepository, existing, created, result;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        productTypeRepository = this.manager_.getCustomRepository(this.productTypeRepository_);
-                        if (type === null) {
-                            return [2 /*return*/, null];
-                        }
-                        return [4 /*yield*/, productTypeRepository.findOne({
-                                where: { value: type.value },
-                            })];
-                    case 1:
-                        existing = _a.sent();
-                        if (existing) {
-                            return [2 /*return*/, existing.id];
-                        }
-                        created = productTypeRepository.create({
-                            value: type.value,
-                        });
-                        return [4 /*yield*/, productTypeRepository.save(created)];
-                    case 2:
-                        result = _a.sent();
-                        return [2 /*return*/, result.id];
-                }
-            });
-        });
-    };
-    ProductService.prototype.upsertProductTags_ = function (tags) {
-        return __awaiter(this, void 0, void 0, function () {
-            var productTagRepository, newTags, tags_1, tags_1_1, tag, existing, created, result, e_1_1;
-            var e_1, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        productTagRepository = this.manager_.getCustomRepository(this.productTagRepository_);
-                        newTags = [];
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 8, 9, 10]);
-                        tags_1 = __values(tags), tags_1_1 = tags_1.next();
-                        _b.label = 2;
-                    case 2:
-                        if (!!tags_1_1.done) return [3 /*break*/, 7];
-                        tag = tags_1_1.value;
-                        return [4 /*yield*/, productTagRepository.findOne({
-                                where: { value: tag.value },
-                            })];
-                    case 3:
-                        existing = _b.sent();
-                        if (!existing) return [3 /*break*/, 4];
-                        newTags.push(existing);
-                        return [3 /*break*/, 6];
-                    case 4:
-                        created = productTagRepository.create(tag);
-                        return [4 /*yield*/, productTagRepository.save(created)];
-                    case 5:
-                        result = _b.sent();
-                        newTags.push(result);
-                        _b.label = 6;
-                    case 6:
-                        tags_1_1 = tags_1.next();
-                        return [3 /*break*/, 2];
-                    case 7: return [3 /*break*/, 10];
-                    case 8:
-                        e_1_1 = _b.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 10];
-                    case 9:
-                        try {
-                            if (tags_1_1 && !tags_1_1.done && (_a = tags_1.return)) _a.call(tags_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 10: return [2 /*return*/, newTags];
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productTagRepo;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        productTagRepo = manager.getCustomRepository(this.productTagRepository_);
+                                        return [4 /*yield*/, productTagRepo.listTagsByUsage(count)];
+                                    case 1: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
     /**
      * Creates a product.
-     * @param {object} productObject - the product to create
-     * @return {Promise} resolves to the creation result.
+     * @param productObject - the product to create
+     * @return resolves to the creation result.
      */
     ProductService.prototype.create = function (productObject) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var productRepo, optionRepo, options, tags, type, images, rest, product_1, _a, _b, _c, _d, result, error_1;
-                        var _this = this;
-                        return __generator(this, function (_e) {
-                            switch (_e.label) {
-                                case 0:
-                                    productRepo = manager.getCustomRepository(this.productRepository_);
-                                    optionRepo = manager.getCustomRepository(this.productOptionRepository_);
-                                    options = productObject.options, tags = productObject.tags, type = productObject.type, images = productObject.images, rest = __rest(productObject, ["options", "tags", "type", "images"]);
-                                    if (!rest.thumbnail && images && images.length) {
-                                        rest.thumbnail = images[0];
-                                    }
-                                    // if product is a giftcard, we should disallow discounts
-                                    if (rest.is_giftcard) {
-                                        rest.discountable = false;
-                                    }
-                                    _e.label = 1;
-                                case 1:
-                                    _e.trys.push([1, 12, , 13]);
-                                    product_1 = productRepo.create(rest);
-                                    if (!images) return [3 /*break*/, 3];
-                                    _a = product_1;
-                                    return [4 /*yield*/, this.upsertImages_(images)];
-                                case 2:
-                                    _a.images = _e.sent();
-                                    _e.label = 3;
-                                case 3:
-                                    if (!tags) return [3 /*break*/, 5];
-                                    _b = product_1;
-                                    return [4 /*yield*/, this.upsertProductTags_(tags)];
-                                case 4:
-                                    _b.tags = _e.sent();
-                                    _e.label = 5;
-                                case 5:
-                                    if (!(typeof type !== "undefined")) return [3 /*break*/, 7];
-                                    _c = product_1;
-                                    return [4 /*yield*/, this.upsertProductType_(type)];
-                                case 6:
-                                    _c.type_id = _e.sent();
-                                    _e.label = 7;
-                                case 7: return [4 /*yield*/, productRepo.save(product_1)];
-                                case 8:
-                                    product_1 = _e.sent();
-                                    _d = product_1;
-                                    return [4 /*yield*/, Promise.all(options.map(function (o) { return __awaiter(_this, void 0, void 0, function () {
-                                            var res;
-                                            return __generator(this, function (_a) {
-                                                switch (_a.label) {
-                                                    case 0:
-                                                        res = optionRepo.create(__assign(__assign({}, o), { product_id: product_1.id }));
-                                                        return [4 /*yield*/, optionRepo.save(res)];
-                                                    case 1:
-                                                        _a.sent();
-                                                        return [2 /*return*/, res];
-                                                }
-                                            });
-                                        }); }))];
-                                case 9:
-                                    _d.options = _e.sent();
-                                    return [4 /*yield*/, this.retrieve(product_1.id, {
-                                            relations: ["options"],
-                                        })];
-                                case 10:
-                                    result = _e.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(ProductService.Events.CREATED, {
-                                            id: result.id,
-                                        })];
-                                case 11:
-                                    _e.sent();
-                                    return [2 /*return*/, result];
-                                case 12:
-                                    error_1 = _e.sent();
-                                    throw (0, exception_formatter_1.formatException)(error_1);
-                                case 13: return [2 /*return*/];
-                            }
-                        });
-                    }); })];
-            });
-        });
-    };
-    ProductService.prototype.upsertImages_ = function (images) {
-        return __awaiter(this, void 0, void 0, function () {
-            var imageRepository, productImages, images_1, images_1_1, img, existing, created, e_2_1;
-            var e_2, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        imageRepository = this.manager_.getCustomRepository(this.imageRepository_);
-                        productImages = [];
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 6, 7, 8]);
-                        images_1 = __values(images), images_1_1 = images_1.next();
-                        _b.label = 2;
-                    case 2:
-                        if (!!images_1_1.done) return [3 /*break*/, 5];
-                        img = images_1_1.value;
-                        return [4 /*yield*/, imageRepository.findOne({
-                                where: { url: img },
-                            })];
-                    case 3:
-                        existing = _b.sent();
-                        if (existing) {
-                            productImages.push(existing);
-                        }
-                        else {
-                            created = imageRepository.create({ url: img });
-                            productImages.push(created);
-                        }
-                        _b.label = 4;
-                    case 4:
-                        images_1_1 = images_1.next();
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 8];
-                    case 6:
-                        e_2_1 = _b.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 8];
-                    case 7:
-                        try {
-                            if (images_1_1 && !images_1_1.done && (_a = images_1.return)) _a.call(images_1);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                        return [7 /*endfinally*/];
-                    case 8: return [2 /*return*/, productImages];
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productRepo, productTagRepo, productTypeRepo, imageRepo, optionRepo, options, tags, type, images, rest, product_1, _a, _b, _c, _d, result, error_1;
+                            var _this = this;
+                            var _e;
+                            return __generator(this, function (_f) {
+                                switch (_f.label) {
+                                    case 0:
+                                        productRepo = manager.getCustomRepository(this.productRepository_);
+                                        productTagRepo = manager.getCustomRepository(this.productTagRepository_);
+                                        productTypeRepo = manager.getCustomRepository(this.productTypeRepository_);
+                                        imageRepo = manager.getCustomRepository(this.imageRepository_);
+                                        optionRepo = manager.getCustomRepository(this.productOptionRepository_);
+                                        options = productObject.options, tags = productObject.tags, type = productObject.type, images = productObject.images, rest = __rest(productObject, ["options", "tags", "type", "images"]);
+                                        if (!rest.thumbnail && (images === null || images === void 0 ? void 0 : images.length)) {
+                                            rest.thumbnail = images[0];
+                                        }
+                                        // if product is a giftcard, we should disallow discounts
+                                        if (rest.is_giftcard) {
+                                            rest.discountable = false;
+                                        }
+                                        _f.label = 1;
+                                    case 1:
+                                        _f.trys.push([1, 12, , 13]);
+                                        product_1 = productRepo.create(rest);
+                                        if (!(images === null || images === void 0 ? void 0 : images.length)) return [3 /*break*/, 3];
+                                        _a = product_1;
+                                        return [4 /*yield*/, imageRepo.upsertImages(images)];
+                                    case 2:
+                                        _a.images = _f.sent();
+                                        _f.label = 3;
+                                    case 3:
+                                        if (!(tags === null || tags === void 0 ? void 0 : tags.length)) return [3 /*break*/, 5];
+                                        _b = product_1;
+                                        return [4 /*yield*/, productTagRepo.upsertTags(tags)];
+                                    case 4:
+                                        _b.tags = _f.sent();
+                                        _f.label = 5;
+                                    case 5:
+                                        if (!(typeof type !== "undefined")) return [3 /*break*/, 7];
+                                        _c = product_1;
+                                        return [4 /*yield*/, productTypeRepo.upsertType(type)];
+                                    case 6:
+                                        _c.type_id = ((_e = (_f.sent())) === null || _e === void 0 ? void 0 : _e.id) || null;
+                                        _f.label = 7;
+                                    case 7: return [4 /*yield*/, productRepo.save(product_1)];
+                                    case 8:
+                                        product_1 = _f.sent();
+                                        _d = product_1;
+                                        return [4 /*yield*/, Promise.all((options !== null && options !== void 0 ? options : []).map(function (option) { return __awaiter(_this, void 0, void 0, function () {
+                                                var res;
+                                                return __generator(this, function (_a) {
+                                                    switch (_a.label) {
+                                                        case 0:
+                                                            res = optionRepo.create(__assign(__assign({}, option), { product_id: product_1.id }));
+                                                            return [4 /*yield*/, optionRepo.save(res)];
+                                                        case 1:
+                                                            _a.sent();
+                                                            return [2 /*return*/, res];
+                                                    }
+                                                });
+                                            }); }))];
+                                    case 9:
+                                        _d.options = _f.sent();
+                                        return [4 /*yield*/, this.retrieve(product_1.id, {
+                                                relations: ["options"],
+                                            })];
+                                    case 10:
+                                        result = _f.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(ProductService.Events.CREATED, {
+                                                id: result.id,
+                                            })];
+                                    case 11:
+                                        _f.sent();
+                                        return [2 /*return*/, result];
+                                    case 12:
+                                        error_1 = _f.sent();
+                                        throw (0, exception_formatter_1.formatException)(error_1);
+                                    case 13: return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
@@ -720,221 +568,231 @@ var ProductService = /** @class */ (function (_super) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var productRepo, productVariantRepo, product, variants, metadata, images, tags, type, rest, _a, _b, _c, _loop_1, _d, _e, variant, e_3_1, newVariants, _loop_2, this_1, _f, _g, _h, i, newVariant, e_4_1, _j, _k, _l, key, value, result;
-                        var e_3, _m, e_4, _o, e_5, _p;
-                        return __generator(this, function (_q) {
-                            switch (_q.label) {
-                                case 0:
-                                    productRepo = manager.getCustomRepository(this.productRepository_);
-                                    productVariantRepo = manager.getCustomRepository(this.productVariantRepository_);
-                                    return [4 /*yield*/, this.retrieve(productId, {
-                                            relations: ["variants", "tags", "images"],
-                                        })];
-                                case 1:
-                                    product = _q.sent();
-                                    variants = update.variants, metadata = update.metadata, images = update.images, tags = update.tags, type = update.type, rest = __rest(update, ["variants", "metadata", "images", "tags", "type"]);
-                                    if (!product.thumbnail && !update.thumbnail && (images === null || images === void 0 ? void 0 : images.length)) {
-                                        product.thumbnail = images[0];
-                                    }
-                                    if (!images) return [3 /*break*/, 3];
-                                    _a = product;
-                                    return [4 /*yield*/, this.upsertImages_(images)];
-                                case 2:
-                                    _a.images = _q.sent();
-                                    _q.label = 3;
-                                case 3:
-                                    if (metadata) {
-                                        product.metadata = this.setMetadata_(product, metadata);
-                                    }
-                                    if (!(typeof type !== "undefined")) return [3 /*break*/, 5];
-                                    _b = product;
-                                    return [4 /*yield*/, this.upsertProductType_(type)];
-                                case 4:
-                                    _b.type_id = _q.sent();
-                                    _q.label = 5;
-                                case 5:
-                                    if (!tags) return [3 /*break*/, 7];
-                                    _c = product;
-                                    return [4 /*yield*/, this.upsertProductTags_(tags)];
-                                case 6:
-                                    _c.tags = _q.sent();
-                                    _q.label = 7;
-                                case 7:
-                                    if (!variants) return [3 /*break*/, 24];
-                                    _loop_1 = function (variant) {
-                                        var exists;
-                                        return __generator(this, function (_r) {
-                                            switch (_r.label) {
-                                                case 0:
-                                                    exists = variants.find(function (v) { return v.id && variant.id === v.id; });
-                                                    if (!!exists) return [3 /*break*/, 2];
-                                                    return [4 /*yield*/, productVariantRepo.remove(variant)];
-                                                case 1:
-                                                    _r.sent();
-                                                    _r.label = 2;
-                                                case 2: return [2 /*return*/];
-                                            }
-                                        });
-                                    };
-                                    _q.label = 8;
-                                case 8:
-                                    _q.trys.push([8, 13, 14, 15]);
-                                    _d = __values(product.variants), _e = _d.next();
-                                    _q.label = 9;
-                                case 9:
-                                    if (!!_e.done) return [3 /*break*/, 12];
-                                    variant = _e.value;
-                                    return [5 /*yield**/, _loop_1(variant)];
-                                case 10:
-                                    _q.sent();
-                                    _q.label = 11;
-                                case 11:
-                                    _e = _d.next();
-                                    return [3 /*break*/, 9];
-                                case 12: return [3 /*break*/, 15];
-                                case 13:
-                                    e_3_1 = _q.sent();
-                                    e_3 = { error: e_3_1 };
-                                    return [3 /*break*/, 15];
-                                case 14:
-                                    try {
-                                        if (_e && !_e.done && (_m = _d.return)) _m.call(_d);
-                                    }
-                                    finally { if (e_3) throw e_3.error; }
-                                    return [7 /*endfinally*/];
-                                case 15:
-                                    newVariants = [];
-                                    _loop_2 = function (i, newVariant) {
-                                        var variant, saved, created;
-                                        return __generator(this, function (_s) {
-                                            switch (_s.label) {
-                                                case 0:
-                                                    newVariant.variant_rank = i;
-                                                    if (!newVariant.id) return [3 /*break*/, 2];
-                                                    variant = product.variants.find(function (v) { return v.id === newVariant.id; });
-                                                    if (!variant) {
-                                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Variant with id: ".concat(newVariant.id, " is not associated with this product"));
-                                                    }
-                                                    return [4 /*yield*/, this_1.productVariantService_
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productRepo, productVariantRepo, productTagRepo, productTypeRepo, imageRepo, product, variants, metadata, images, tags, type, rest, _a, _b, _c, _loop_1, _d, _e, variant, e_1_1, newVariants, _loop_2, this_1, _f, _g, _h, i, newVariant, e_2_1, _j, _k, _l, key, value, result;
+                            var e_1, _m, e_2, _o, e_3, _p;
+                            var _q;
+                            return __generator(this, function (_r) {
+                                switch (_r.label) {
+                                    case 0:
+                                        productRepo = manager.getCustomRepository(this.productRepository_);
+                                        productVariantRepo = manager.getCustomRepository(this.productVariantRepository_);
+                                        productTagRepo = manager.getCustomRepository(this.productTagRepository_);
+                                        productTypeRepo = manager.getCustomRepository(this.productTypeRepository_);
+                                        imageRepo = manager.getCustomRepository(this.imageRepository_);
+                                        return [4 /*yield*/, this.retrieve(productId, {
+                                                relations: ["variants", "tags", "images"],
+                                            })];
+                                    case 1:
+                                        product = _r.sent();
+                                        variants = update.variants, metadata = update.metadata, images = update.images, tags = update.tags, type = update.type, rest = __rest(update, ["variants", "metadata", "images", "tags", "type"]);
+                                        if (!product.thumbnail && !update.thumbnail && (images === null || images === void 0 ? void 0 : images.length)) {
+                                            product.thumbnail = images[0];
+                                        }
+                                        if (!images) return [3 /*break*/, 3];
+                                        _a = product;
+                                        return [4 /*yield*/, imageRepo.upsertImages(images)];
+                                    case 2:
+                                        _a.images = _r.sent();
+                                        _r.label = 3;
+                                    case 3:
+                                        if (metadata) {
+                                            product.metadata = (0, utils_1.setMetadata)(product, metadata);
+                                        }
+                                        if (!(typeof type !== "undefined")) return [3 /*break*/, 5];
+                                        _b = product;
+                                        return [4 /*yield*/, productTypeRepo.upsertType(type)];
+                                    case 4:
+                                        _b.type_id = ((_q = (_r.sent())) === null || _q === void 0 ? void 0 : _q.id) || null;
+                                        _r.label = 5;
+                                    case 5:
+                                        if (!tags) return [3 /*break*/, 7];
+                                        _c = product;
+                                        return [4 /*yield*/, productTagRepo.upsertTags(tags)];
+                                    case 6:
+                                        _c.tags = _r.sent();
+                                        _r.label = 7;
+                                    case 7:
+                                        if (!variants) return [3 /*break*/, 24];
+                                        _loop_1 = function (variant) {
+                                            var exists;
+                                            return __generator(this, function (_s) {
+                                                switch (_s.label) {
+                                                    case 0:
+                                                        exists = variants.find(function (v) { return v.id && variant.id === v.id; });
+                                                        if (!!exists) return [3 /*break*/, 2];
+                                                        return [4 /*yield*/, productVariantRepo.remove(variant)];
+                                                    case 1:
+                                                        _s.sent();
+                                                        _s.label = 2;
+                                                    case 2: return [2 /*return*/];
+                                                }
+                                            });
+                                        };
+                                        _r.label = 8;
+                                    case 8:
+                                        _r.trys.push([8, 13, 14, 15]);
+                                        _d = __values(product.variants), _e = _d.next();
+                                        _r.label = 9;
+                                    case 9:
+                                        if (!!_e.done) return [3 /*break*/, 12];
+                                        variant = _e.value;
+                                        return [5 /*yield**/, _loop_1(variant)];
+                                    case 10:
+                                        _r.sent();
+                                        _r.label = 11;
+                                    case 11:
+                                        _e = _d.next();
+                                        return [3 /*break*/, 9];
+                                    case 12: return [3 /*break*/, 15];
+                                    case 13:
+                                        e_1_1 = _r.sent();
+                                        e_1 = { error: e_1_1 };
+                                        return [3 /*break*/, 15];
+                                    case 14:
+                                        try {
+                                            if (_e && !_e.done && (_m = _d.return)) _m.call(_d);
+                                        }
+                                        finally { if (e_1) throw e_1.error; }
+                                        return [7 /*endfinally*/];
+                                    case 15:
+                                        newVariants = [];
+                                        _loop_2 = function (i, newVariant) {
+                                            var variant_rank, variant, saved, created;
+                                            return __generator(this, function (_t) {
+                                                switch (_t.label) {
+                                                    case 0:
+                                                        variant_rank = i;
+                                                        if (!newVariant.id) return [3 /*break*/, 2];
+                                                        variant = product.variants.find(function (v) { return v.id === newVariant.id; });
+                                                        if (!variant) {
+                                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Variant with id: ".concat(newVariant.id, " is not associated with this product"));
+                                                        }
+                                                        return [4 /*yield*/, this_1.productVariantService_
+                                                                .withTransaction(manager)
+                                                                .update(variant, __assign(__assign({}, newVariant), { variant_rank: variant_rank, product_id: variant.product_id }))];
+                                                    case 1:
+                                                        saved = _t.sent();
+                                                        newVariants.push(saved);
+                                                        return [3 /*break*/, 4];
+                                                    case 2: return [4 /*yield*/, this_1.productVariantService_
                                                             .withTransaction(manager)
-                                                            .update(variant, newVariant)];
-                                                case 1:
-                                                    saved = _s.sent();
-                                                    newVariants.push(saved);
-                                                    return [3 /*break*/, 4];
-                                                case 2: return [4 /*yield*/, this_1.productVariantService_
-                                                        .withTransaction(manager)
-                                                        .create(product.id, newVariant)];
-                                                case 3:
-                                                    created = _s.sent();
-                                                    newVariants.push(created);
-                                                    _s.label = 4;
-                                                case 4: return [2 /*return*/];
-                                            }
-                                        });
-                                    };
-                                    this_1 = this;
-                                    _q.label = 16;
-                                case 16:
-                                    _q.trys.push([16, 21, 22, 23]);
-                                    _f = __values(variants.entries()), _g = _f.next();
-                                    _q.label = 17;
-                                case 17:
-                                    if (!!_g.done) return [3 /*break*/, 20];
-                                    _h = __read(_g.value, 2), i = _h[0], newVariant = _h[1];
-                                    return [5 /*yield**/, _loop_2(i, newVariant)];
-                                case 18:
-                                    _q.sent();
-                                    _q.label = 19;
-                                case 19:
-                                    _g = _f.next();
-                                    return [3 /*break*/, 17];
-                                case 20: return [3 /*break*/, 23];
-                                case 21:
-                                    e_4_1 = _q.sent();
-                                    e_4 = { error: e_4_1 };
-                                    return [3 /*break*/, 23];
-                                case 22:
-                                    try {
-                                        if (_g && !_g.done && (_o = _f.return)) _o.call(_f);
-                                    }
-                                    finally { if (e_4) throw e_4.error; }
-                                    return [7 /*endfinally*/];
-                                case 23:
-                                    product.variants = newVariants;
-                                    _q.label = 24;
-                                case 24:
-                                    try {
-                                        for (_j = __values(Object.entries(rest)), _k = _j.next(); !_k.done; _k = _j.next()) {
-                                            _l = __read(_k.value, 2), key = _l[0], value = _l[1];
-                                            if (typeof value !== "undefined") {
-                                                product[key] = value;
-                                            }
+                                                            .create(product.id, __assign(__assign({}, newVariant), { variant_rank: variant_rank, options: newVariant.options || [], prices: newVariant.prices || [] }))];
+                                                    case 3:
+                                                        created = _t.sent();
+                                                        newVariants.push(created);
+                                                        _t.label = 4;
+                                                    case 4: return [2 /*return*/];
+                                                }
+                                            });
+                                        };
+                                        this_1 = this;
+                                        _r.label = 16;
+                                    case 16:
+                                        _r.trys.push([16, 21, 22, 23]);
+                                        _f = __values(variants.entries()), _g = _f.next();
+                                        _r.label = 17;
+                                    case 17:
+                                        if (!!_g.done) return [3 /*break*/, 20];
+                                        _h = __read(_g.value, 2), i = _h[0], newVariant = _h[1];
+                                        return [5 /*yield**/, _loop_2(i, newVariant)];
+                                    case 18:
+                                        _r.sent();
+                                        _r.label = 19;
+                                    case 19:
+                                        _g = _f.next();
+                                        return [3 /*break*/, 17];
+                                    case 20: return [3 /*break*/, 23];
+                                    case 21:
+                                        e_2_1 = _r.sent();
+                                        e_2 = { error: e_2_1 };
+                                        return [3 /*break*/, 23];
+                                    case 22:
+                                        try {
+                                            if (_g && !_g.done && (_o = _f.return)) _o.call(_f);
                                         }
-                                    }
-                                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                                    finally {
+                                        finally { if (e_2) throw e_2.error; }
+                                        return [7 /*endfinally*/];
+                                    case 23:
+                                        product.variants = newVariants;
+                                        _r.label = 24;
+                                    case 24:
                                         try {
-                                            if (_k && !_k.done && (_p = _j.return)) _p.call(_j);
+                                            for (_j = __values(Object.entries(rest)), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                                _l = __read(_k.value, 2), key = _l[0], value = _l[1];
+                                                if (typeof value !== "undefined") {
+                                                    product[key] = value;
+                                                }
+                                            }
                                         }
-                                        finally { if (e_5) throw e_5.error; }
-                                    }
-                                    return [4 /*yield*/, productRepo.save(product)];
-                                case 25:
-                                    result = _q.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(ProductService.Events.UPDATED, {
-                                            id: result.id,
-                                            fields: Object.keys(update),
-                                        })];
-                                case 26:
-                                    _q.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                        finally {
+                                            try {
+                                                if (_k && !_k.done && (_p = _j.return)) _p.call(_j);
+                                            }
+                                            finally { if (e_3) throw e_3.error; }
+                                        }
+                                        return [4 /*yield*/, productRepo.save(product)];
+                                    case 25:
+                                        result = _r.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(ProductService.Events.UPDATED, {
+                                                id: result.id,
+                                                fields: Object.keys(update),
+                                            })];
+                                    case 26:
+                                        _r.sent();
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
      * Deletes a product from a given product id. The product's associated
      * variants will also be deleted.
-     * @param {string} productId - the id of the product to delete. Must be
+     * @param productId - the id of the product to delete. Must be
      *   castable as an ObjectId
-     * @return {Promise} empty promise
+     * @return empty promise
      */
     ProductService.prototype.delete = function (productId) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var productRepo, product;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    productRepo = manager.getCustomRepository(this.productRepository_);
-                                    return [4 /*yield*/, productRepo.findOne({ id: productId }, { relations: ["variants", "variants.prices", "variants.options"] })];
-                                case 1:
-                                    product = _a.sent();
-                                    if (!product) {
-                                        return [2 /*return*/];
-                                    }
-                                    return [4 /*yield*/, productRepo.softRemove(product)];
-                                case 2:
-                                    _a.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(ProductService.Events.DELETED, {
-                                            id: productId,
-                                        })];
-                                case 3:
-                                    _a.sent();
-                                    return [2 /*return*/, Promise.resolve()];
-                            }
-                        });
-                    }); })];
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productRepo, product;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        productRepo = manager.getCustomRepository(this.productRepository_);
+                                        return [4 /*yield*/, productRepo.findOne({ id: productId }, { relations: ["variants", "variants.prices", "variants.options"] })];
+                                    case 1:
+                                        product = _a.sent();
+                                        if (!product) {
+                                            return [2 /*return*/];
+                                        }
+                                        return [4 /*yield*/, productRepo.softRemove(product)];
+                                    case 2:
+                                        _a.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(ProductService.Events.DELETED, {
+                                                id: productId,
+                                            })];
+                                    case 3:
+                                        _a.sent();
+                                        return [2 /*return*/, Promise.resolve()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
@@ -942,314 +800,240 @@ var ProductService = /** @class */ (function (_super) {
      * Adds an option to a product. Options can, for example, be "Size", "Color",
      * etc. Will update all the products variants with a dummy value for the newly
      * created option. The same option cannot be added more than once.
-     * @param {string} productId - the product to apply the new option to
-     * @param {string} optionTitle - the display title of the option, e.g. "Size"
-     * @return {Promise} the result of the model update operation
+     * @param productId - the product to apply the new option to
+     * @param optionTitle - the display title of the option, e.g. "Size"
+     * @return the result of the model update operation
      */
     ProductService.prototype.addOption = function (productId, optionTitle) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var productOptionRepo, product, option, _a, _b, variant, result;
-                        var e_6, _c;
-                        return __generator(this, function (_d) {
-                            switch (_d.label) {
-                                case 0:
-                                    productOptionRepo = manager.getCustomRepository(this.productOptionRepository_);
-                                    return [4 /*yield*/, this.retrieve(productId, {
-                                            relations: ["options", "variants"],
-                                        })];
-                                case 1:
-                                    product = _d.sent();
-                                    if (product.options.find(function (o) { return o.title === optionTitle; })) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.DUPLICATE_ERROR, "An option with the title: ".concat(optionTitle, " already exists"));
-                                    }
-                                    return [4 /*yield*/, productOptionRepo.create({
-                                            title: optionTitle,
-                                            product_id: productId,
-                                        })];
-                                case 2:
-                                    option = _d.sent();
-                                    return [4 /*yield*/, productOptionRepo.save(option)];
-                                case 3:
-                                    _d.sent();
-                                    try {
-                                        for (_a = __values(product.variants), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                            variant = _b.value;
-                                            this.productVariantService_
-                                                .withTransaction(manager)
-                                                .addOptionValue(variant.id, option.id, "Default Value");
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productOptionRepo, product, option, _a, _b, variant, result;
+                            var e_4, _c;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        productOptionRepo = manager.getCustomRepository(this.productOptionRepository_);
+                                        return [4 /*yield*/, this.retrieve(productId, {
+                                                relations: ["options", "variants"],
+                                            })];
+                                    case 1:
+                                        product = _d.sent();
+                                        if (product.options.find(function (o) { return o.title === optionTitle; })) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.DUPLICATE_ERROR, "An option with the title: ".concat(optionTitle, " already exists"));
                                         }
-                                    }
-                                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                                    finally {
+                                        return [4 /*yield*/, productOptionRepo.create({
+                                                title: optionTitle,
+                                                product_id: productId,
+                                            })];
+                                    case 2:
+                                        option = _d.sent();
+                                        return [4 /*yield*/, productOptionRepo.save(option)];
+                                    case 3:
+                                        _d.sent();
                                         try {
-                                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                            for (_a = __values(product.variants), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                                variant = _b.value;
+                                                this.productVariantService_
+                                                    .withTransaction(manager)
+                                                    .addOptionValue(variant.id, option.id, "Default Value");
+                                            }
                                         }
-                                        finally { if (e_6) throw e_6.error; }
-                                    }
-                                    return [4 /*yield*/, this.retrieve(productId)];
-                                case 4:
-                                    result = _d.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(ProductService.Events.UPDATED, result)];
-                                case 5:
-                                    _d.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
-            });
-        });
-    };
-    ProductService.prototype.reorderVariants = function (productId, variantOrder) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var productRepo, product, result;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    productRepo = manager.getCustomRepository(this.productRepository_);
-                                    return [4 /*yield*/, this.retrieve(productId, {
-                                            relations: ["variants"],
-                                        })];
-                                case 1:
-                                    product = _a.sent();
-                                    if (product.variants.length !== variantOrder.length) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Product variants and new variant order differ in length.");
-                                    }
-                                    product.variants = variantOrder.map(function (vId) {
-                                        var variant = product.variants.find(function (v) { return v.id === vId; });
-                                        if (!variant) {
-                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Product has no variant with id: ".concat(vId));
+                                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                                        finally {
+                                            try {
+                                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                            }
+                                            finally { if (e_4) throw e_4.error; }
                                         }
-                                        return variant;
-                                    });
-                                    result = productRepo.save(product);
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(ProductService.Events.UPDATED, result)];
-                                case 2:
-                                    _a.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                        return [4 /*yield*/, this.retrieve(productId)];
+                                    case 4:
+                                        result = _d.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(ProductService.Events.UPDATED, result)];
+                                    case 5:
+                                        _d.sent();
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
-    /**
-     * Changes the order of a product's options. Will throw if the length of
-     * optionOrder and the length of the product's options are different. Will
-     * throw optionOrder contains an id not associated with the product.
-     * @param {string} productId - the product whose options we are reordering
-     * @param {string[]} optionOrder - the ids of the product's options in the
-     *    new order
-     * @return {Promise} the result of the update operation
-     */
-    ProductService.prototype.reorderOptions = function (productId, optionOrder) {
+    ProductService.prototype.reorderVariants = function (productId, variantOrder) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var productRepo, product, result;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    productRepo = manager.getCustomRepository(this.productRepository_);
-                                    return [4 /*yield*/, this.retrieve(productId, { relations: ["options"] })];
-                                case 1:
-                                    product = _a.sent();
-                                    if (product.options.length !== optionOrder.length) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Product options and new options order differ in length.");
-                                    }
-                                    product.options = optionOrder.map(function (oId) {
-                                        var option = product.options.find(function (o) { return o.id === oId; });
-                                        if (!option) {
-                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Product has no option with id: ".concat(oId));
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productRepo, product, result;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        productRepo = manager.getCustomRepository(this.productRepository_);
+                                        return [4 /*yield*/, this.retrieve(productId, {
+                                                relations: ["variants"],
+                                            })];
+                                    case 1:
+                                        product = _a.sent();
+                                        if (product.variants.length !== variantOrder.length) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Product variants and new variant order differ in length.");
                                         }
-                                        return option;
-                                    });
-                                    result = productRepo.save(product);
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(ProductService.Events.UPDATED, result)];
-                                case 2:
-                                    _a.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                        product.variants = variantOrder.map(function (vId) {
+                                            var variant = product.variants.find(function (v) { return v.id === vId; });
+                                            if (!variant) {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Product has no variant with id: ".concat(vId));
+                                            }
+                                            return variant;
+                                        });
+                                        result = productRepo.save(product);
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(ProductService.Events.UPDATED, result)];
+                                    case 2:
+                                        _a.sent();
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
      * Updates a product's option. Throws if the call tries to update an option
      * not associated with the product. Throws if the updated title already exists.
-     * @param {string} productId - the product whose option we are updating
-     * @param {string} optionId - the id of the option we are updating
-     * @param {object} data - the data to update the option with
-     * @return {Promise} the updated product
+     * @param productId - the product whose option we are updating
+     * @param optionId - the id of the option we are updating
+     * @param data - the data to update the option with
+     * @return the updated product
      */
     ProductService.prototype.updateOption = function (productId, optionId, data) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var productOptionRepo, product, title, values, optionExists, productOption;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    productOptionRepo = manager.getCustomRepository(this.productOptionRepository_);
-                                    return [4 /*yield*/, this.retrieve(productId, { relations: ["options"] })];
-                                case 1:
-                                    product = _a.sent();
-                                    title = data.title, values = data.values;
-                                    optionExists = product.options.some(function (o) {
-                                        return o.title.toUpperCase() === title.toUpperCase() && o.id !== optionId;
-                                    });
-                                    if (optionExists) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "An option with title ".concat(title, " already exists"));
-                                    }
-                                    return [4 /*yield*/, productOptionRepo.findOne({
-                                            where: { id: optionId },
-                                        })];
-                                case 2:
-                                    productOption = _a.sent();
-                                    if (!productOption) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Option with id: ".concat(optionId, " does not exist"));
-                                    }
-                                    productOption.title = title;
-                                    productOption.values = values;
-                                    return [4 /*yield*/, productOptionRepo.save(productOption)];
-                                case 3:
-                                    _a.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(ProductService.Events.UPDATED, product)];
-                                case 4:
-                                    _a.sent();
-                                    return [2 /*return*/, product];
-                            }
-                        });
-                    }); })];
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productOptionRepo, product, title, values, optionExists, productOption;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        productOptionRepo = manager.getCustomRepository(this.productOptionRepository_);
+                                        return [4 /*yield*/, this.retrieve(productId, { relations: ["options"] })];
+                                    case 1:
+                                        product = _a.sent();
+                                        title = data.title, values = data.values;
+                                        optionExists = product.options.some(function (o) {
+                                            return o.title.toUpperCase() === title.toUpperCase() && o.id !== optionId;
+                                        });
+                                        if (optionExists) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "An option with title ".concat(title, " already exists"));
+                                        }
+                                        return [4 /*yield*/, productOptionRepo.findOne({
+                                                where: { id: optionId },
+                                            })];
+                                    case 2:
+                                        productOption = _a.sent();
+                                        if (!productOption) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Option with id: ".concat(optionId, " does not exist"));
+                                        }
+                                        productOption.title = title;
+                                        if (values) {
+                                            productOption.values = values;
+                                        }
+                                        return [4 /*yield*/, productOptionRepo.save(productOption)];
+                                    case 3:
+                                        _a.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(ProductService.Events.UPDATED, product)];
+                                    case 4:
+                                        _a.sent();
+                                        return [2 /*return*/, product];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
      * Delete an option from a product.
-     * @param {string} productId - the product to delete an option from
-     * @param {string} optionId - the option to delete
-     * @return {Promise} the updated product
+     * @param productId - the product to delete an option from
+     * @param optionId - the option to delete
+     * @return the updated product
      */
     ProductService.prototype.deleteOption = function (productId, optionId) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var productOptionRepo, product, productOption, firstVariant, valueToMatch, equalsFirst;
-                        var _this = this;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    productOptionRepo = manager.getCustomRepository(this.productOptionRepository_);
-                                    return [4 /*yield*/, this.retrieve(productId, {
-                                            relations: ["variants", "variants.options"],
-                                        })];
-                                case 1:
-                                    product = _a.sent();
-                                    return [4 /*yield*/, productOptionRepo.findOne({
-                                            where: { id: optionId, product_id: productId },
-                                        })];
-                                case 2:
-                                    productOption = _a.sent();
-                                    if (!productOption) {
-                                        return [2 /*return*/, Promise.resolve()];
-                                    }
-                                    firstVariant = product.variants[0];
-                                    valueToMatch = firstVariant.options.find(function (o) { return o.option_id === optionId; }).value;
-                                    return [4 /*yield*/, Promise.all(product.variants.map(function (v) { return __awaiter(_this, void 0, void 0, function () {
-                                            var option;
-                                            return __generator(this, function (_a) {
-                                                option = v.options.find(function (o) { return o.option_id === optionId; });
-                                                return [2 /*return*/, option.value === valueToMatch];
-                                            });
-                                        }); }))];
-                                case 3:
-                                    equalsFirst = _a.sent();
-                                    if (!equalsFirst.every(function (v) { return v; })) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "To delete an option, first delete all variants, such that when an option is deleted, no duplicate variants will exist.");
-                                    }
-                                    // If we reach this point, we can safely delete the product option
-                                    return [4 /*yield*/, productOptionRepo.softRemove(productOption)];
-                                case 4:
-                                    // If we reach this point, we can safely delete the product option
-                                    _a.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(ProductService.Events.UPDATED, product)];
-                                case 5:
-                                    _a.sent();
-                                    return [2 /*return*/, product];
-                            }
-                        });
-                    }); })];
-            });
-        });
-    };
-    /**
-     * Decorates a product with product variants.
-     * @param {string} productId - the productId to decorate.
-     * @param {string[]} fields - the fields to include.
-     * @param {string[]} expandFields - fields to expand.
-     * @param {object} config - retrieve config for price calculation.
-     * @return {Product} return the decorated product.
-     */
-    ProductService.prototype.decorate = function (productId, fields, expandFields, config) {
-        var _a;
-        if (fields === void 0) { fields = []; }
-        if (expandFields === void 0) { expandFields = []; }
-        if (config === void 0) { config = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var requiredFields, priceIndex, product, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        requiredFields = ["id", "metadata"];
-                        priceIndex = (_a = expandFields.indexOf("variants.prices")) !== null && _a !== void 0 ? _a : -1;
-                        if (priceIndex >= 0 && expandFields.length) {
-                            expandFields = __spreadArray([], __read(expandFields), false);
-                            expandFields.splice(priceIndex, 1);
-                        }
-                        fields = fields.concat(requiredFields);
-                        return [4 /*yield*/, this.retrieve(productId, {
-                                select: fields,
-                                relations: expandFields,
-                            })];
-                    case 1:
-                        product = _c.sent();
-                        if (!(priceIndex > -1)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.setAdditionalPrices(product, config.currency_code, config.region_id, config.cart_id, config.customer_id, config.include_discount_prices)];
-                    case 2:
-                        _b = _c.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _b = product;
-                        _c.label = 4;
-                    case 4: return [2 /*return*/, _b];
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var productOptionRepo, product, productOption, firstVariant, valueToMatch, equalsFirst;
+                            var _this = this;
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        productOptionRepo = manager.getCustomRepository(this.productOptionRepository_);
+                                        return [4 /*yield*/, this.retrieve(productId, {
+                                                relations: ["variants", "variants.options"],
+                                            })];
+                                    case 1:
+                                        product = _b.sent();
+                                        return [4 /*yield*/, productOptionRepo.findOne({
+                                                where: { id: optionId, product_id: productId },
+                                            })];
+                                    case 2:
+                                        productOption = _b.sent();
+                                        if (!productOption) {
+                                            return [2 /*return*/, Promise.resolve()];
+                                        }
+                                        firstVariant = product.variants[0];
+                                        valueToMatch = (_a = firstVariant.options.find(function (o) { return o.option_id === optionId; })) === null || _a === void 0 ? void 0 : _a.value;
+                                        return [4 /*yield*/, Promise.all(product.variants.map(function (v) { return __awaiter(_this, void 0, void 0, function () {
+                                                var option;
+                                                return __generator(this, function (_a) {
+                                                    option = v.options.find(function (o) { return o.option_id === optionId; });
+                                                    return [2 /*return*/, (option === null || option === void 0 ? void 0 : option.value) === valueToMatch];
+                                                });
+                                            }); }))];
+                                    case 3:
+                                        equalsFirst = _b.sent();
+                                        if (!equalsFirst.every(function (v) { return v; })) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "To delete an option, first delete all variants, such that when an option is deleted, no duplicate variants will exist.");
+                                        }
+                                        // If we reach this point, we can safely delete the product option
+                                        return [4 /*yield*/, productOptionRepo.softRemove(productOption)];
+                                    case 4:
+                                        // If we reach this point, we can safely delete the product option
+                                        _b.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(ProductService.Events.UPDATED, product)];
+                                    case 5:
+                                        _b.sent();
+                                        return [2 /*return*/, product];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
     /**
      * Creates a query object to be used for list queries.
-     * @param {object} selector - the selector to create the query from
-     * @param {object} config - the config to use for the query
-     * @return {object} an object containing the query, relations and free-text
+     * @param selector - the selector to create the query from
+     * @param config - the config to use for the query
+     * @return an object containing the query, relations and free-text
      *   search param.
      */
     ProductService.prototype.prepareListQuery_ = function (selector, config) {
@@ -1258,7 +1042,7 @@ var ProductService = /** @class */ (function (_super) {
             q = selector.q;
             delete selector.q;
         }
-        var query = this.buildQuery_(selector, config);
+        var query = (0, utils_1.buildQuery)(selector, config);
         if (config.relations && config.relations.length > 0) {
             query.relations = config.relations;
         }
@@ -1273,118 +1057,6 @@ var ProductService = /** @class */ (function (_super) {
             q: q,
         };
     };
-    /**
-     * Creates a QueryBuilder that can fetch products based on free text.
-     * @param {ProductRepository} productRepo - an instance of a ProductRepositry
-     * @param {FindOptions<Product>} query - the query to get products by
-     * @param {string} q - the text to perform free text search from
-     * @return {QueryBuilder<Product>} a query builder that can fetch products
-     */
-    ProductService.prototype.getFreeTextQueryBuilder_ = function (productRepo, query, q) {
-        var where = query.where;
-        delete where.description;
-        delete where.title;
-        var qb = productRepo
-            .createQueryBuilder("product")
-            .leftJoinAndSelect("product.variants", "variant")
-            .leftJoinAndSelect("product.collection", "collection")
-            .select(["product.id"])
-            .where(where)
-            .andWhere(new typeorm_1.Brackets(function (qb) {
-            qb.where("product.description ILIKE :q", { q: "%".concat(q, "%") })
-                .orWhere("product.title ILIKE :q", { q: "%".concat(q, "%") })
-                .orWhere("variant.title ILIKE :q", { q: "%".concat(q, "%") })
-                .orWhere("variant.sku ILIKE :q", { q: "%".concat(q, "%") })
-                .orWhere("collection.title ILIKE :q", { q: "%".concat(q, "%") });
-        }))
-            .skip(query.skip)
-            .take(query.take);
-        if (query.withDeleted) {
-            qb = qb.withDeleted();
-        }
-        return qb;
-    };
-    /**
-     * Set additional prices on a list of products.
-     * @param {Product[] | Product} products list of products on which to set additional prices
-     * @param {string} currency_code currency code to fetch prices for
-     * @param {string} region_id region to fetch prices for
-     * @param {string} cart_id string of cart to use as a basis for getting currency and region
-     * @param {string} customer_id id of potentially logged in customer, used to get prices valid for their customer groups
-     * @param {boolean} include_discount_prices indication wether or not to include sales prices in result
-     * @return {Promise<Product[]>} A list of products with variants decorated with "additional_prices"
-     */
-    ProductService.prototype.setAdditionalPrices = function (products, currency_code, region_id, cart_id, customer_id, include_discount_prices) {
-        if (include_discount_prices === void 0) { include_discount_prices = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var cartRepo, regionId, currencyCode, cart, productArray, priceSelectionStrategy, productsWithPrices;
-                        var _this = this;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    cartRepo = this.manager_.getCustomRepository(this.cartRepository_);
-                                    regionId = region_id;
-                                    currencyCode = currency_code;
-                                    if (!cart_id) return [3 /*break*/, 2];
-                                    return [4 /*yield*/, cartRepo.findOne({
-                                            where: { id: cart_id },
-                                            relations: ["region"],
-                                        })];
-                                case 1:
-                                    cart = _a.sent();
-                                    regionId = cart.region.id;
-                                    currencyCode = cart.region.currency_code;
-                                    _a.label = 2;
-                                case 2:
-                                    productArray = Array.isArray(products) ? products : [products];
-                                    priceSelectionStrategy = this.priceSelectionStrategy_.withTransaction(manager);
-                                    return [4 /*yield*/, Promise.all(productArray.map(function (p) { return __awaiter(_this, void 0, void 0, function () {
-                                            var _a;
-                                            var _this = this;
-                                            var _b;
-                                            return __generator(this, function (_c) {
-                                                switch (_c.label) {
-                                                    case 0:
-                                                        if (!((_b = p.variants) === null || _b === void 0 ? void 0 : _b.length)) return [3 /*break*/, 2];
-                                                        _a = p;
-                                                        return [4 /*yield*/, Promise.all(p.variants.map(function (v) { return __awaiter(_this, void 0, void 0, function () {
-                                                                var prices;
-                                                                return __generator(this, function (_a) {
-                                                                    switch (_a.label) {
-                                                                        case 0: return [4 /*yield*/, priceSelectionStrategy.calculateVariantPrice(v.id, {
-                                                                                region_id: regionId,
-                                                                                currency_code: currencyCode,
-                                                                                cart_id: cart_id,
-                                                                                customer_id: customer_id,
-                                                                                include_discount_prices: include_discount_prices,
-                                                                            })];
-                                                                        case 1:
-                                                                            prices = _a.sent();
-                                                                            return [2 /*return*/, __assign(__assign({}, v), { prices: prices.prices, original_price: prices.originalPrice, calculated_price: prices.calculatedPrice, calculated_price_type: prices.calculatedPriceType })];
-                                                                    }
-                                                                });
-                                                            }); }))];
-                                                    case 1:
-                                                        _a.variants = _c.sent();
-                                                        _c.label = 2;
-                                                    case 2: return [2 /*return*/, p];
-                                                }
-                                            });
-                                        }); }))];
-                                case 3:
-                                    productsWithPrices = _a.sent();
-                                    return [2 /*return*/, Array.isArray(products)
-                                            ? productsWithPrices
-                                            : productsWithPrices[0]];
-                            }
-                        });
-                    }); })];
-            });
-        });
-    };
     ProductService.IndexName = "products";
     ProductService.Events = {
         UPDATED: "product.updated",
@@ -1392,6 +1064,6 @@ var ProductService = /** @class */ (function (_super) {
         DELETED: "product.deleted",
     };
     return ProductService;
-}(medusa_interfaces_1.BaseService));
+}(interfaces_1.TransactionBaseService));
 exports.default = ProductService;
 //# sourceMappingURL=product.js.map