@medusajs/product 0.3.10 → 0.3.11

package/dist/services/product-module-service.d.ts

@@ -2,7 +2,7 @@ import { Context, DAL, IEventBusModuleService, InternalModuleDeclaration, Module
 import { Image, Product, ProductCategory, ProductCollection, ProductOption, ProductOptionValue, ProductTag, ProductType, ProductVariant, ProductVariantOption } from "../models";
 import { ProductCategoryService, ProductCollectionService, ProductOptionService, ProductService, ProductTagService, ProductTypeService } from ".";
 import { ModulesSdkUtils } from "@medusajs/utils";
-import { UpdateCollectionInput, UpdateProductInput, UpdateProductVariantInput } from "../types";
+import { UpdateCollectionInput, UpdateProductInput, UpdateProductVariantInput, UpdateProductOptionInput } from "../types";
 type InjectedDependencies = {
     baseRepository: DAL.RepositoryService;
     productService: ProductService<any>;
@@ -71,16 +71,27 @@ export default class ProductModuleService<TProduct extends Product = Product, TP
     constructor({ baseRepository, productService, productVariantService, productTagService, productCategoryService, productCollectionService, productImageService, productTypeService, productOptionService, productOptionValueService, productVariantOptionService, eventBusModuleService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
     __joinerConfig(): ModuleJoinerConfig;
     createVariants(data: ProductTypes.CreateProductVariantDTO[], sharedContext?: Context): Promise<ProductTypes.ProductVariantDTO[]>;
-    updateVariants(data: ProductTypes.UpdateProductVariantDTO[], sharedContext?: Context): Promise<ProductTypes.ProductVariantDTO[]>;
-    protected updateVariants_(data: ProductTypes.UpdateProductVariantDTO[], sharedContext?: Context): Promise<TProductVariant[]>;
-    diffVariants_(data: UpdateProductVariantInput[], productOptions: ProductOption[], sharedContext?: Context): Promise<TProductVariant[]>;
+    createVariants(data: ProductTypes.CreateProductVariantDTO, sharedContext?: Context): Promise<ProductTypes.ProductVariantDTO>;
+    protected createVariants_(data: ProductTypes.CreateProductVariantDTO[], sharedContext?: Context): Promise<ProductVariant[]>;
+    upsertVariants(data: ProductTypes.UpsertProductVariantDTO[], sharedContext?: Context): Promise<ProductTypes.ProductVariantDTO[]>;
+    upsertVariants(data: ProductTypes.UpsertProductVariantDTO, sharedContext?: Context): Promise<ProductTypes.ProductVariantDTO>;
+    updateVariants(id: string, data: ProductTypes.UpdateProductVariantDTO, sharedContext?: Context): Promise<ProductTypes.ProductVariantDTO>;
+    updateVariants(selector: ProductTypes.FilterableProductVariantProps, data: ProductTypes.UpdateProductVariantDTO, sharedContext?: Context): Promise<ProductTypes.ProductVariantDTO[]>;
+    protected updateVariants_(data: UpdateProductVariantInput[], sharedContext?: Context): Promise<TProductVariant[]>;
+    protected diffVariants_(data: UpdateProductVariantInput[], productOptions: ProductOption[], sharedContext?: Context): Promise<TProductVariant[]>;
     createTags(data: ProductTypes.CreateProductTagDTO[], sharedContext?: Context): Promise<ProductTypes.ProductTagDTO[]>;
     updateTags(data: ProductTypes.UpdateProductTagDTO[], sharedContext?: Context): Promise<ProductTypes.ProductTagDTO[]>;
     createTypes(data: ProductTypes.CreateProductTypeDTO[], sharedContext?: Context): Promise<ProductTypes.ProductTypeDTO[]>;
     updateTypes(data: ProductTypes.UpdateProductTypeDTO[], sharedContext?: Context): Promise<ProductTypes.ProductTypeDTO[]>;
     createOptions(data: ProductTypes.CreateProductOptionDTO[], sharedContext?: Context): Promise<ProductTypes.ProductOptionDTO[]>;
-    updateOptions(data: ProductTypes.UpdateProductOptionDTO[], sharedContext?: Context): Promise<ProductTypes.ProductOptionDTO[]>;
-    diffOptions_(data: ProductTypes.UpdateProductOptionDTO[], sharedContext?: Context): Promise<ProductOption[]>;
+    createOptions(data: ProductTypes.CreateProductOptionDTO, sharedContext?: Context): Promise<ProductTypes.ProductOptionDTO>;
+    protected createOptions_(data: ProductTypes.CreateProductOptionDTO[], sharedContext?: Context): Promise<ProductOption[]>;
+    upsertOptions(data: ProductTypes.UpsertProductOptionDTO[], sharedContext?: Context): Promise<ProductTypes.ProductOptionDTO[]>;
+    upsertOptions(data: ProductTypes.UpsertProductOptionDTO, sharedContext?: Context): Promise<ProductTypes.ProductOptionDTO>;
+    updateOptions(id: string, data: ProductTypes.UpdateProductOptionDTO, sharedContext?: Context): Promise<ProductTypes.ProductOptionDTO>;
+    updateOptions(selector: ProductTypes.FilterableProductOptionProps, data: ProductTypes.UpdateProductOptionDTO, sharedContext?: Context): Promise<ProductTypes.ProductOptionDTO[]>;
+    protected updateOptions_(data: UpdateProductOptionInput[], sharedContext?: Context): Promise<ProductOption[]>;
+    protected diffOptions_(data: UpdateProductOptionInput[], sharedContext?: Context): Promise<ProductOption[]>;
     createCollections(data: ProductTypes.CreateProductCollectionDTO[], sharedContext?: Context): Promise<ProductTypes.ProductCollectionDTO[]>;
     createCollections(data: ProductTypes.CreateProductCollectionDTO, sharedContext?: Context): Promise<ProductTypes.ProductCollectionDTO>;
     createCollections_(data: ProductTypes.CreateProductCollectionDTO[], sharedContext?: Context): Promise<TProductCollection[]>;
@@ -88,7 +99,7 @@ export default class ProductModuleService<TProduct extends Product = Product, TP
     upsertCollections(data: ProductTypes.UpsertProductCollectionDTO, sharedContext?: Context): Promise<ProductTypes.ProductCollectionDTO>;
     updateCollections(id: string, data: ProductTypes.UpdateProductCollectionDTO, sharedContext?: Context): Promise<ProductTypes.ProductCollectionDTO>;
     updateCollections(selector: ProductTypes.FilterableProductCollectionProps, data: ProductTypes.UpdateProductCollectionDTO, sharedContext?: Context): Promise<ProductTypes.ProductCollectionDTO[]>;
-    updateCollections_(data: UpdateCollectionInput[], sharedContext?: Context): Promise<TProductCollection[]>;
+    protected updateCollections_(data: UpdateCollectionInput[], sharedContext?: Context): Promise<TProductCollection[]>;
     createCategory(data: ProductTypes.CreateProductCategoryDTO, sharedContext?: Context): Promise<ProductTypes.ProductCategoryDTO>;
     updateCategory(categoryId: string, data: ProductTypes.UpdateProductCategoryDTO, sharedContext?: Context): Promise<ProductTypes.ProductCategoryDTO>;
     deleteCategory(categoryId: string, sharedContext?: Context): Promise<void>;

package/dist/services/product-module-service.js

@@ -54,22 +54,54 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         return joiner_config_1.joinerConfig;
     }
     async createVariants(data, sharedContext = {}) {
-        const productVariantsWithOptions = await (0, utils_1.promiseAll)(data.map(async (variant) => {
-            if (!(0, utils_1.isPresent)(variant.options)) {
-                return variant;
-            }
-            const productOptions = await this.productOptionService_.list({ product_id: variant.product_id }, {
-                take: null,
-            }, sharedContext);
-            return ProductModuleService.assignOptionsToVariants([variant], productOptions)[0];
-        }));
-        const productVariants = await this.productVariantService_.create(productVariantsWithOptions, sharedContext);
-        return await this.baseRepository_.serialize(productVariants);
+        const input = Array.isArray(data) ? data : [data];
+        const variants = await this.createVariants_(input, sharedContext);
+        const createdVariants = await this.baseRepository_.serialize(variants, { populate: true });
+        return Array.isArray(data) ? createdVariants : createdVariants[0];
+    }
+    async createVariants_(data, sharedContext = {}) {
+        if (data.some((v) => !v.product_id)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Tried to create variants without specifying a product_id");
+        }
+        const productOptions = await this.productOptionService_.list({
+            product_id: [...new Set(data.map((v) => v.product_id))],
+        }, {
+            take: null,
+        }, sharedContext);
+        const productVariantsWithOptions = ProductModuleService.assignOptionsToVariants(data, productOptions);
+        return await this.productVariantService_.create(productVariantsWithOptions, sharedContext);
     }
-    async updateVariants(data, sharedContext = {}) {
-        const productVariants = await this.updateVariants_(data, sharedContext);
-        const updatedVariants = await this.baseRepository_.serialize(productVariants);
-        return updatedVariants;
+    async upsertVariants(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const forUpdate = input.filter((variant) => !!variant.id);
+        const forCreate = input.filter((variant) => !variant.id);
+        let created = [];
+        let updated = [];
+        if (forCreate.length) {
+            created = await this.createVariants_(forCreate, sharedContext);
+        }
+        if (forUpdate.length) {
+            updated = await this.updateVariants_(forUpdate, sharedContext);
+        }
+        const result = [...created, ...updated];
+        const allVariants = await this.baseRepository_.serialize(result);
+        return Array.isArray(data) ? allVariants : allVariants[0];
+    }
+    async updateVariants(idOrSelector, data, sharedContext = {}) {
+        let normalizedInput = [];
+        if ((0, utils_1.isString)(idOrSelector)) {
+            normalizedInput = [{ id: idOrSelector, ...data }];
+        }
+        else {
+            const variants = await this.productVariantService_.list(idOrSelector, {}, sharedContext);
+            normalizedInput = variants.map((variant) => ({
+                id: variant.id,
+                ...data,
+            }));
+        }
+        const variants = await this.updateVariants_(normalizedInput, sharedContext);
+        const updatedVariants = await this.baseRepository_.serialize(variants);
+        return (0, utils_1.isString)(idOrSelector) ? updatedVariants[0] : updatedVariants;
     }
     async updateVariants_(data, sharedContext = {}) {
         // Validation step
@@ -144,6 +176,15 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         });
     }
     async createOptions(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const options = await this.createOptions_(input, sharedContext);
+        const createdOptions = await this.baseRepository_.serialize(options, { populate: true });
+        return Array.isArray(data) ? createdOptions : createdOptions[0];
+    }
+    async createOptions_(data, sharedContext = {}) {
+        if (data.some((v) => !v.product_id)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Tried to create options without specifying a product_id");
+        }
         const normalizedInput = data.map((opt) => {
             return {
                 ...opt,
@@ -152,10 +193,42 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
                 }),
             };
         });
-        const productOptions = await this.productOptionService_.create(normalizedInput, sharedContext);
-        return await this.baseRepository_.serialize(productOptions);
+        return await this.productOptionService_.create(normalizedInput, sharedContext);
+    }
+    async upsertOptions(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const forUpdate = input.filter((option) => !!option.id);
+        const forCreate = input.filter((option) => !option.id);
+        let created = [];
+        let updated = [];
+        if (forCreate.length) {
+            created = await this.createOptions_(forCreate, sharedContext);
+        }
+        if (forUpdate.length) {
+            updated = await this.updateOptions_(forUpdate, sharedContext);
+        }
+        const result = [...created, ...updated];
+        const allOptions = await this.baseRepository_.serialize(result);
+        return Array.isArray(data) ? allOptions : allOptions[0];
+    }
+    async updateOptions(idOrSelector, data, sharedContext = {}) {
+        let normalizedInput = [];
+        if ((0, utils_1.isString)(idOrSelector)) {
+            normalizedInput = [{ id: idOrSelector, ...data }];
+        }
+        else {
+            const options = await this.productOptionService_.list(idOrSelector, {}, sharedContext);
+            normalizedInput = options.map((option) => ({
+                id: option.id,
+                ...data,
+            }));
+        }
+        const options = await this.updateOptions_(normalizedInput, sharedContext);
+        const updatedOptions = await this.baseRepository_.serialize(options);
+        return (0, utils_1.isString)(idOrSelector) ? updatedOptions[0] : updatedOptions;
     }
-    async updateOptions(data, sharedContext = {}) {
+    async updateOptions_(data, sharedContext = {}) {
+        // Validation step
         const normalizedInput = data.map((opt) => {
             return {
                 ...opt,
@@ -172,7 +245,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Tried to update options without specifying an ID");
         }
         const productOptions = await this.diffOptions_(normalizedInput, sharedContext);
-        return await this.baseRepository_.serialize(productOptions);
+        return productOptions;
     }
     // TODO: Do validation
     async diffOptions_(data, sharedContext = {}) {
@@ -507,17 +580,32 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
 }
 exports.default = ProductModuleService;
 __decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "createVariants", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "createVariants_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "upsertVariants", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "updateVariants", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
@@ -527,7 +615,7 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "updateVariants_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Array, Object]),
@@ -562,10 +650,10 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "updateTypes", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "createOptions", null);
 __decorate([
@@ -574,7 +662,28 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "createOptions_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "upsertOptions", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "updateOptions", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "updateOptions_", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),

package/dist/types/index.d.ts

@@ -40,5 +40,9 @@ export type UpdateCollectionInput = ProductTypes.UpdateProductCollectionDTO & {
     id: string;
 };
 export type UpdateProductVariantInput = ProductTypes.UpdateProductVariantDTO & {
-    product_id: string;
+    id: string;
+    product_id?: string;
+};
+export type UpdateProductOptionInput = ProductTypes.UpdateProductOptionDTO & {
+    id: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medusajs/product",
-  "version": "0.3.10",
+  "version": "0.3.11",
   "description": "Medusa Product module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -41,7 +41,7 @@
     "cross-env": "^5.2.1",
     "faker": "^6.6.6",
     "jest": "^29.6.3",
-    "medusa-test-utils": "^1.1.42",
+    "medusa-test-utils": "^1.1.43",
     "pg-god": "^1.0.12",
     "rimraf": "^3.0.2",
     "ts-jest": "^29.1.1",
@@ -50,9 +50,9 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
-    "@medusajs/modules-sdk": "^1.12.9",
-    "@medusajs/types": "^1.11.14",
-    "@medusajs/utils": "^1.11.7",
+    "@medusajs/modules-sdk": "^1.12.10",
+    "@medusajs/types": "^1.11.15",
+    "@medusajs/utils": "^1.11.8",
     "@mikro-orm/core": "5.9.7",
     "@mikro-orm/migrations": "5.9.7",
     "@mikro-orm/postgresql": "5.9.7",