@medusajs/product 0.4.0-snapshot-20240322174858 → 0.4.0-snapshot-20240329212017

package/dist/migrations/{InitialSetup20240315083440.d.ts → InitialSetup20240325200756.d.ts}

@@ -1,4 +1,4 @@
-import { Migration } from "@mikro-orm/migrations";
+import { Migration } from '@mikro-orm/migrations';
 export declare class InitialSetup20240315083440 extends Migration {
     up(): Promise<void>;
 }

package/dist/migrations/{InitialSetup20240315083440.js → InitialSetup20240325200756.js}

@@ -9,9 +9,12 @@ class InitialSetup20240315083440 extends migrations_1.Migration {
         if (productTables.length > 0) {
             // This is so we can still run the api tests, remove completely once that is not needed
             this.addSql(`alter table "product_option_value" alter column "variant_id" drop not null;`);
+            this.addSql(`alter table "product_variant" alter column "inventory_quantity" drop not null;`);
         }
         this.addSql('create table if not exists "product_category" ("id" text not null, "name" text not null, "description" text not null default \'\', "handle" text not null, "mpath" text not null, "is_active" boolean not null default false, "is_internal" boolean not null default false, "rank" numeric not null default 0, "parent_category_id" text null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), constraint "product_category_pkey" primary key ("id"));');
         this.addSql('create index if not exists "IDX_product_category_path" on "product_category" ("mpath");');
+        // TODO: Re-enable when we run the migration from v1
+        // this.addSql('alter table if exists "product_category" add constraint "IDX_product_category_handle" unique ("handle");');
         this.addSql('create table if not exists "product_collection" ("id" text not null, "title" text not null, "handle" text not null, "metadata" jsonb null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "product_collection_pkey" primary key ("id"));');
         this.addSql('create index if not exists "IDX_product_collection_deleted_at" on "product_collection" ("deleted_at");');
         this.addSql('alter table if exists "product_collection" add constraint "IDX_product_collection_handle_unique" unique ("handle");');
@@ -46,8 +49,8 @@ class InitialSetup20240315083440 extends migrations_1.Migration {
         this.addSql('alter table if exists "product_category" add constraint "product_category_parent_category_id_foreign" foreign key ("parent_category_id") references "product_category" ("id") on update cascade on delete set null;');
         this.addSql('alter table if exists "product" add constraint "product_collection_id_foreign" foreign key ("collection_id") references "product_collection" ("id") on update cascade on delete set null;');
         this.addSql('alter table if exists "product" add constraint "product_type_id_foreign" foreign key ("type_id") references "product_type" ("id") on update cascade on delete set null;');
-        this.addSql('alter table if exists "product_option" add constraint "product_option_product_id_foreign" foreign key ("product_id") references "product" ("id") on update cascade on delete set null;');
-        this.addSql('alter table if exists "product_option_value" add constraint "product_option_value_option_id_foreign" foreign key ("option_id") references "product_option" ("id") on update cascade;');
+        this.addSql('alter table if exists "product_option" add constraint "product_option_product_id_foreign" foreign key ("product_id") references "product" ("id") on update cascade on delete cascade;');
+        this.addSql('alter table if exists "product_option_value" add constraint "product_option_value_option_id_foreign" foreign key ("option_id") references "product_option" ("id") on update cascade on delete cascade;');
         this.addSql('alter table if exists "product_tags" add constraint "product_tags_product_id_foreign" foreign key ("product_id") references "product" ("id") on update cascade on delete cascade;');
         this.addSql('alter table if exists "product_tags" add constraint "product_tags_product_tag_id_foreign" foreign key ("product_tag_id") references "product_tag" ("id") on update cascade on delete cascade;');
         this.addSql('alter table if exists "product_images" add constraint "product_images_product_id_foreign" foreign key ("product_id") references "product" ("id") on update cascade on delete cascade;');

package/dist/models/product-category.js

@@ -23,9 +23,11 @@ let ProductCategory = ProductCategory_1 = class ProductCategory {
     }
     async onInit() {
         this.id = (0, utils_1.generateEntityId)(this.id, "pcat");
+        this.parent_category_id ?? (this.parent_category_id = this.parent_category?.id ?? null);
     }
     async onCreate(args) {
         this.id = (0, utils_1.generateEntityId)(this.id, "pcat");
+        this.parent_category_id ?? (this.parent_category_id = this.parent_category?.id ?? null);
         if (!this.handle && this.name) {
             this.handle = (0, utils_1.kebabCase)(this.name);
         }
@@ -84,11 +86,16 @@ __decorate([
     __metadata("design:type", Number)
 ], ProductCategory.prototype, "rank", void 0);
 __decorate([
-    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    (0, core_1.ManyToOne)(() => ProductCategory, {
+        columnType: "text",
+        fieldName: "parent_category_id",
+        nullable: true,
+        mapToPk: true,
+    }),
     __metadata("design:type", Object)
 ], ProductCategory.prototype, "parent_category_id", void 0);
 __decorate([
-    (0, core_1.ManyToOne)(() => ProductCategory, { nullable: true }),
+    (0, core_1.ManyToOne)(() => ProductCategory, { nullable: true, persist: false }),
     __metadata("design:type", ProductCategory)
 ], ProductCategory.prototype, "parent_category", void 0);
 __decorate([

package/dist/models/product-collection.js

@@ -21,10 +21,13 @@ let ProductCollection = class ProductCollection {
     }
     onInit() {
         this.id = (0, utils_1.generateEntityId)(this.id, "pcol");
+        if (!this.handle && this.title) {
+            this.handle = (0, utils_1.kebabCase)(this.title);
+        }
     }
     onCreate() {
         this.id = (0, utils_1.generateEntityId)(this.id, "pcol");
-        if (!this.handle) {
+        if (!this.handle && this.title) {
             this.handle = (0, utils_1.kebabCase)(this.title);
         }
     }

package/dist/models/product-option-value.d.ts

@@ -7,8 +7,8 @@ declare class ProductOptionValue {
     [OptionalProps]?: OptionalFields | OptionalRelations;
     id: string;
     value: string;
-    option_id: string;
-    option: ProductOption;
+    option_id: string | null;
+    option: ProductOption | null;
     variant_options: Collection<ProductVariantOption, object>;
     metadata?: Record<string, unknown> | null;
     created_at: Date;

package/dist/models/product-option-value.js

@@ -27,9 +27,11 @@ let ProductOptionValue = class ProductOptionValue {
     }
     onInit() {
         this.id = (0, utils_1.generateEntityId)(this.id, "optval");
+        this.option_id ?? (this.option_id = this.option?.id ?? null);
     }
     beforeCreate() {
         this.id = (0, utils_1.generateEntityId)(this.id, "optval");
+        this.option_id ?? (this.option_id = this.option?.id ?? null);
     }
 };
 __decorate([
@@ -41,15 +43,22 @@ __decorate([
     __metadata("design:type", String)
 ], ProductOptionValue.prototype, "value", void 0);
 __decorate([
-    (0, core_1.Property)({ columnType: "text", nullable: true }),
-    __metadata("design:type", String)
+    (0, core_1.ManyToOne)(() => index_1.ProductOption, {
+        columnType: "text",
+        fieldName: "option_id",
+        mapToPk: true,
+        nullable: true,
+        index: "IDX_product_option_value_option_id",
+        onDelete: "cascade",
+    }),
+    __metadata("design:type", Object)
 ], ProductOptionValue.prototype, "option_id", void 0);
 __decorate([
     (0, core_1.ManyToOne)(() => index_1.ProductOption, {
-        index: "IDX_product_option_value_option_id",
-        fieldName: "option_id",
+        nullable: true,
+        persist: false,
     }),
-    __metadata("design:type", index_1.ProductOption)
+    __metadata("design:type", Object)
 ], ProductOptionValue.prototype, "option", void 0);
 __decorate([
     (0, core_1.OneToMany)(() => index_1.ProductVariantOption, (value) => value.option_value, {}),

package/dist/models/product-option.d.ts

@@ -8,8 +8,8 @@ declare class ProductOption {
     [OptionalProps]?: OptionalRelations | OptionalFields;
     id: string;
     title: string;
-    product_id: string;
-    product: Product;
+    product_id: string | null;
+    product: Product | null;
     values: Collection<ProductOptionValue, object>;
     metadata?: Record<string, unknown> | null;
     created_at: Date;

package/dist/models/product-option.js

@@ -31,9 +31,11 @@ let ProductOption = class ProductOption {
     }
     onInit() {
         this.id = (0, utils_1.generateEntityId)(this.id, "opt");
+        this.product_id ?? (this.product_id = this.product?.id ?? null);
     }
     beforeCreate() {
         this.id = (0, utils_1.generateEntityId)(this.id, "opt");
+        this.product_id ?? (this.product_id = this.product?.id ?? null);
     }
 };
 __decorate([
@@ -45,15 +47,21 @@ __decorate([
     __metadata("design:type", String)
 ], ProductOption.prototype, "title", void 0);
 __decorate([
-    (0, core_1.Property)({ columnType: "text", nullable: true }),
-    __metadata("design:type", String)
+    (0, core_1.ManyToOne)(() => index_1.Product, {
+        columnType: "text",
+        fieldName: "product_id",
+        mapToPk: true,
+        nullable: true,
+        onDelete: "cascade",
+    }),
+    __metadata("design:type", Object)
 ], ProductOption.prototype, "product_id", void 0);
 __decorate([
     (0, core_1.ManyToOne)(() => index_1.Product, {
-        fieldName: "product_id",
+        persist: false,
         nullable: true,
     }),
-    __metadata("design:type", index_1.Product)
+    __metadata("design:type", Object)
 ], ProductOption.prototype, "product", void 0);
 __decorate([
     (0, core_1.OneToMany)(() => product_option_value_1.default, (value) => value.option, {

package/dist/models/product-variant-option.d.ts

@@ -3,7 +3,7 @@ declare class ProductVariantOption {
     id: string;
     option_value_id: string;
     option_value: ProductOptionValue;
-    variant_id: string;
+    variant_id: string | null;
     variant: ProductVariant;
     created_at: Date;
     updated_at: Date;

package/dist/models/product-variant-option.js

@@ -24,9 +24,13 @@ variantOptionValueIndexStatement.MikroORMIndex();
 let ProductVariantOption = class ProductVariantOption {
     onInit() {
         this.id = (0, utils_1.generateEntityId)(this.id, "varopt");
+        this.variant_id ?? (this.variant_id = this.variant?.id ?? null);
+        this.option_value_id ?? (this.option_value_id = this.option_value?.id ?? null);
     }
     beforeCreate() {
         this.id = (0, utils_1.generateEntityId)(this.id, "varopt");
+        this.variant_id ?? (this.variant_id = this.variant?.id ?? null);
+        this.option_value_id ?? (this.option_value_id = this.option_value?.id ?? null);
     }
 };
 __decorate([
@@ -34,23 +38,33 @@ __decorate([
     __metadata("design:type", String)
 ], ProductVariantOption.prototype, "id", void 0);
 __decorate([
-    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    (0, core_1.ManyToOne)(() => index_1.ProductOptionValue, {
+        columnType: "text",
+        nullable: true,
+        fieldName: "option_value_id",
+        mapToPk: true,
+    }),
     __metadata("design:type", String)
 ], ProductVariantOption.prototype, "option_value_id", void 0);
 __decorate([
     (0, core_1.ManyToOne)(() => index_1.ProductOptionValue, {
-        fieldName: "option_value_id",
+        persist: false,
         nullable: true,
     }),
     __metadata("design:type", index_1.ProductOptionValue)
 ], ProductVariantOption.prototype, "option_value", void 0);
 __decorate([
-    (0, core_1.Property)({ columnType: "text", nullable: true }),
-    __metadata("design:type", String)
+    (0, core_1.ManyToOne)(() => index_1.ProductVariant, {
+        columnType: "text",
+        nullable: true,
+        fieldName: "variant_id",
+        mapToPk: true,
+    }),
+    __metadata("design:type", Object)
 ], ProductVariantOption.prototype, "variant_id", void 0);
 __decorate([
     (0, core_1.ManyToOne)(() => index_1.ProductVariant, {
-        fieldName: "variant_id",
+        persist: false,
         nullable: true,
     }),
     __metadata("design:type", index_1.ProductVariant)

package/dist/models/product-variant.d.ts

@@ -24,8 +24,8 @@ declare class ProductVariant {
     width?: number | null;
     metadata?: Record<string, unknown> | null;
     variant_rank?: number | null;
-    product_id: string;
-    product: Product;
+    product_id: string | null;
+    product: Product | null;
     created_at: Date;
     updated_at: Date;
     deleted_at?: Date;

package/dist/models/product-variant.js

@@ -28,9 +28,11 @@ let ProductVariant = class ProductVariant {
     }
     onInit() {
         this.id = (0, utils_1.generateEntityId)(this.id, "variant");
+        this.product_id ?? (this.product_id = this.product?.id ?? null);
     }
     onCreate() {
         this.id = (0, utils_1.generateEntityId)(this.id, "variant");
+        this.product_id ?? (this.product_id = this.product?.id ?? null);
     }
 };
 __decorate([
@@ -134,18 +136,23 @@ __decorate([
     }),
     __metadata("design:type", Object)
 ], ProductVariant.prototype, "variant_rank", void 0);
-__decorate([
-    (0, core_1.Property)({ columnType: "text", nullable: true }),
-    __metadata("design:type", String)
-], ProductVariant.prototype, "product_id", void 0);
 __decorate([
     (0, core_1.ManyToOne)(() => _models_1.Product, {
+        columnType: "text",
+        nullable: true,
         onDelete: "cascade",
-        index: "IDX_product_variant_product_id",
         fieldName: "product_id",
+        index: "IDX_product_variant_product_id",
+        mapToPk: true,
+    }),
+    __metadata("design:type", Object)
+], ProductVariant.prototype, "product_id", void 0);
+__decorate([
+    (0, core_1.ManyToOne)(() => _models_1.Product, {
+        persist: false,
         nullable: true,
     }),
-    __metadata("design:type", _models_1.Product)
+    __metadata("design:type", Object)
 ], ProductVariant.prototype, "product", void 0);
 __decorate([
     (0, core_1.Property)({

package/dist/models/product.d.ts

@@ -30,10 +30,10 @@ declare class Product {
     hs_code?: string | null;
     mid_code?: string | null;
     material?: string | null;
-    collection_id: string;
+    collection_id: string | null;
     collection: ProductCollection | null;
-    type_id: string;
-    type: ProductType;
+    type_id: string | null;
+    type: ProductType | null;
     tags: Collection<ProductTag, object>;
     images: Collection<ProductImage, object>;
     categories: Collection<ProductCategory, object>;

package/dist/models/product.js

@@ -31,10 +31,17 @@ let Product = class Product {
     }
     onInit() {
         this.id = (0, utils_1.generateEntityId)(this.id, "prod");
+        this.type_id ?? (this.type_id = this.type?.id ?? null);
+        this.collection_id ?? (this.collection_id = this.collection?.id ?? null);
+        if (!this.handle && this.title) {
+            this.handle = (0, utils_1.kebabCase)(this.title);
+        }
     }
     beforeCreate() {
         this.id = (0, utils_1.generateEntityId)(this.id, "prod");
-        if (!this.handle) {
+        this.type_id ?? (this.type_id = this.type?.id ?? null);
+        this.collection_id ?? (this.collection_id = this.collection?.id ?? null);
+        if (!this.handle && this.title) {
             this.handle = (0, utils_1.kebabCase)(this.title);
         }
     }
@@ -121,35 +128,43 @@ __decorate([
     __metadata("design:type", Object)
 ], Product.prototype, "material", void 0);
 __decorate([
-    (0, core_1.Property)({ columnType: "text", nullable: true }),
-    __metadata("design:type", String)
+    (0, core_1.ManyToOne)(() => product_collection_1.default, {
+        columnType: "text",
+        nullable: true,
+        fieldName: "collection_id",
+        mapToPk: true,
+    }),
+    __metadata("design:type", Object)
 ], Product.prototype, "collection_id", void 0);
 __decorate([
     (0, core_1.ManyToOne)(() => product_collection_1.default, {
         nullable: true,
-        fieldName: "collection_id",
+        persist: false,
     }),
     __metadata("design:type", Object)
 ], Product.prototype, "collection", void 0);
 __decorate([
-    (0, core_1.Property)({ columnType: "text", nullable: true }),
-    __metadata("design:type", String)
+    (0, core_1.ManyToOne)(() => product_type_1.default, {
+        columnType: "text",
+        nullable: true,
+        fieldName: "type_id",
+        index: "IDX_product_type_id",
+        mapToPk: true,
+    }),
+    __metadata("design:type", Object)
 ], Product.prototype, "type_id", void 0);
 __decorate([
     (0, core_1.ManyToOne)(() => product_type_1.default, {
         nullable: true,
-        index: "IDX_product_type_id",
-        fieldName: "type_id",
+        persist: false,
     }),
-    __metadata("design:type", product_type_1.default)
+    __metadata("design:type", Object)
 ], Product.prototype, "type", void 0);
 __decorate([
     (0, core_1.ManyToMany)(() => product_tag_1.default, "products", {
         owner: true,
         pivotTable: "product_tags",
         index: "IDX_product_tag_id",
-        cascade: ["soft-remove"],
-        // TODO: Do we really want to remove tags if the product is deleted?
     }),
     __metadata("design:type", Object)
 ], Product.prototype, "tags", void 0);
@@ -158,7 +173,6 @@ __decorate([
         owner: true,
         pivotTable: "product_images",
         index: "IDX_product_image_id",
-        cascade: ["soft-remove"],
         joinColumn: "product_id",
         inverseJoinColumn: "image_id",
     }),
@@ -168,7 +182,6 @@ __decorate([
     (0, core_1.ManyToMany)(() => product_category_1.default, "products", {
         owner: true,
         pivotTable: "product_category_product",
-        // TODO: rm cascade: ["soft-remove"] as any,
     }),
     __metadata("design:type", Object)
 ], Product.prototype, "categories", void 0);

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, UpdateProductOptionInput } from "../types";
+import { UpdateCollectionInput, UpdateProductInput, UpdateProductOptionInput, UpdateProductVariantInput } from "../types";
 type InjectedDependencies = {
     baseRepository: DAL.RepositoryService;
     productService: ProductService<any>;
@@ -78,11 +78,14 @@ export default class ProductModuleService<TProduct extends Product = Product, TP
     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[]>;
+    createTypes(data: ProductTypes.CreateProductTypeDTO, sharedContext?: Context): Promise<ProductTypes.ProductTypeDTO>;
+    upsertTypes(data: ProductTypes.UpsertProductTypeDTO[], sharedContext?: Context): Promise<ProductTypes.ProductTypeDTO[]>;
+    upsertTypes(data: ProductTypes.UpsertProductTypeDTO, sharedContext?: Context): Promise<ProductTypes.ProductTypeDTO>;
+    updateTypes(id: string, data: ProductTypes.UpdateProductTypeDTO, sharedContext?: Context): Promise<ProductTypes.ProductTypeDTO>;
+    updateTypes(selector: ProductTypes.FilterableProductTypeProps, data: ProductTypes.UpdateProductTypeDTO, sharedContext?: Context): Promise<ProductTypes.ProductTypeDTO[]>;
     createOptions(data: ProductTypes.CreateProductOptionDTO[], sharedContext?: Context): Promise<ProductTypes.ProductOptionDTO[]>;
     createOptions(data: ProductTypes.CreateProductOptionDTO, sharedContext?: Context): Promise<ProductTypes.ProductOptionDTO>;
     protected createOptions_(data: ProductTypes.CreateProductOptionDTO[], sharedContext?: Context): Promise<ProductOption[]>;
@@ -91,7 +94,6 @@ export default class ProductModuleService<TProduct extends Product = Product, TP
     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[]>;
@@ -112,8 +114,9 @@ export default class ProductModuleService<TProduct extends Product = Product, TP
     protected create_(data: ProductTypes.CreateProductDTO[], sharedContext?: Context): Promise<TProduct[]>;
     protected update_(data: UpdateProductInput[], sharedContext?: Context): Promise<TProduct[]>;
     protected static normalizeCreateProductInput(product: ProductTypes.CreateProductDTO): ProductTypes.CreateProductDTO;
-    protected static normalizeUpdateProductInput(product: ProductTypes.UpdateProductDTO): ProductTypes.UpdateProductDTO;
-    protected static normalizeProductCollectionInput(collection: ProductTypes.CreateProductCollectionDTO | UpdateCollectionInput): ProductTypes.CreateProductCollectionDTO | UpdateCollectionInput;
+    protected static normalizeUpdateProductInput(product: UpdateProductInput): UpdateProductInput;
+    protected static normalizeCreateProductCollectionInput(collection: ProductTypes.CreateProductCollectionDTO): ProductTypes.CreateProductCollectionDTO;
+    protected static normalizeUpdateProductCollectionInput(collection: ProductTypes.CreateProductCollectionDTO | UpdateCollectionInput): ProductTypes.CreateProductCollectionDTO | UpdateCollectionInput;
     protected static assignOptionsToVariants(variants: ProductTypes.CreateProductVariantDTO[] | ProductTypes.UpdateProductVariantDTO[], options: ProductOption[]): ProductTypes.CreateProductVariantDTO[] | ProductTypes.UpdateProductVariantDTO[];
 }
 export {};

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

@@ -17,7 +17,6 @@ const _models_1 = require("../models");
 const utils_1 = require("@medusajs/utils");
 const types_2 = require("../types");
 const joiner_config_1 = require("./../joiner-config");
-const utils_2 = require("@medusajs/utils");
 const generateMethodForModels = [
     { model: _models_1.ProductCategory, singular: "Category", plural: "Categories" },
     { model: _models_1.ProductCollection, singular: "Collection", plural: "Collections" },
@@ -56,7 +55,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     async createVariants(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const variants = await this.createVariants_(input, sharedContext);
-        const createdVariants = await this.baseRepository_.serialize(variants, { populate: true });
+        const createdVariants = await this.baseRepository_.serialize(variants);
         return Array.isArray(data) ? createdVariants : createdVariants[0];
     }
     async createVariants_(data, sharedContext = {}) {
@@ -106,7 +105,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     async updateVariants_(data, sharedContext = {}) {
         // Validation step
         const variantIdsToUpdate = data.map(({ id }) => id);
-        const variants = await this.listVariants({ id: variantIdsToUpdate }, { relations: ["options"], take: null }, sharedContext);
+        const variants = await this.productVariantService_.list({ id: variantIdsToUpdate }, { relations: ["options"], take: null }, sharedContext);
         if (variants.length !== data.length) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Cannot update non-existing variants with ids: ${(0, utils_1.arrayDifference)(variantIdsToUpdate, variants.map(({ id }) => id)).join(", ")}`);
         }
@@ -119,66 +118,62 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         const productOptions = await this.productOptionService_.list({
             product_id: Array.from(new Set(variantsWithProductId.map((v) => v.product_id))),
         }, { take: null }, sharedContext);
-        return await this.diffVariants_(variantsWithProductId, productOptions, sharedContext);
-    }
-    async diffVariants_(data, productOptions, sharedContext = {}) {
-        const toCreate = data.filter((o) => !o.id);
-        const toUpdate = data.filter((o) => o.id);
-        let createdVariants = [];
-        let updatedVariants = [];
-        if (toCreate.length) {
-            createdVariants = await this.productVariantService_.create(ProductModuleService.assignOptionsToVariants(toCreate, productOptions), sharedContext);
-        }
-        if (toUpdate.length) {
-            const existingVariants = await this.productVariantService_.list({ id: toUpdate.map((o) => o.id) }, { take: null }, sharedContext);
-            const updateVariants = await (0, utils_1.promiseAll)(toUpdate.map(async (variantToUpdate) => {
-                const dbVariant = existingVariants.find((o) => o.id === variantToUpdate.id);
-                if (!dbVariant) {
-                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Variant with id "${variantToUpdate.id}" does not exist, but was referenced in the update request`);
-                }
-                if (!variantToUpdate.options) {
-                    return variantToUpdate;
-                }
-                const dbVariantOptions = await this.productVariantOptionService_.list({ variant_id: dbVariant.id }, { relations: ["option_value", "option_value.option"], take: null }, sharedContext);
-                const variantOptionsToDelete = dbVariantOptions
-                    .filter((variantOption) => {
-                    return !Object.entries(variantToUpdate.options ?? {}).some(([optionTitle, optionValue]) => variantOption.option_value.value === optionValue &&
-                        variantOption.option_value.option.title === optionTitle);
-                })
-                    .map((v) => v.id);
-                await this.productVariantOptionService_.delete({
-                    id: { $in: variantOptionsToDelete },
-                });
-                return variantToUpdate;
-            }));
-            updatedVariants = await this.productVariantService_.update(ProductModuleService.assignOptionsToVariants(updateVariants, productOptions), sharedContext);
-        }
-        return [...createdVariants, ...updatedVariants];
+        return this.productVariantService_.upsertWithReplace(ProductModuleService.assignOptionsToVariants(variantsWithProductId, productOptions), {
+            relations: ["options"],
+        }, sharedContext);
     }
     async createTags(data, sharedContext = {}) {
         const productTags = await this.productTagService_.create(data, sharedContext);
-        return await this.baseRepository_.serialize(productTags, { populate: true });
+        return await this.baseRepository_.serialize(productTags);
     }
     async updateTags(data, sharedContext = {}) {
         const productTags = await this.productTagService_.update(data, sharedContext);
-        return await this.baseRepository_.serialize(productTags, { populate: true });
+        return await this.baseRepository_.serialize(productTags);
     }
     async createTypes(data, sharedContext = {}) {
-        const productTypes = await this.productTypeService_.create(data, sharedContext);
-        return await this.baseRepository_.serialize(productTypes, {
-            populate: true,
-        });
+        const input = Array.isArray(data) ? data : [data];
+        const types = await this.productTypeService_.create(input, sharedContext);
+        const createdTypes = await this.baseRepository_.serialize(types);
+        return Array.isArray(data) ? createdTypes : createdTypes[0];
     }
-    async updateTypes(data, sharedContext = {}) {
-        const productTypes = await this.productTypeService_.update(data, sharedContext);
-        return await this.baseRepository_.serialize(productTypes, {
-            populate: true,
-        });
+    async upsertTypes(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const forUpdate = input.filter((type) => !!type.id);
+        const forCreate = input.filter((type) => !type.id);
+        let created = [];
+        let updated = [];
+        if (forCreate.length) {
+            created = await this.productTypeService_.create(forCreate, sharedContext);
+        }
+        if (forUpdate.length) {
+            updated = await this.productTypeService_.update(forUpdate, sharedContext);
+        }
+        const result = [...created, ...updated];
+        const allTypes = await this.baseRepository_.serialize(result);
+        return Array.isArray(data) ? allTypes : allTypes[0];
+    }
+    async updateTypes(idOrSelector, data, sharedContext = {}) {
+        let normalizedInput = [];
+        if ((0, utils_1.isString)(idOrSelector)) {
+            // Check if the type exists in the first place
+            await this.productTypeService_.retrieve(idOrSelector, {}, sharedContext);
+            normalizedInput = [{ id: idOrSelector, ...data }];
+        }
+        else {
+            const types = await this.productTypeService_.list(idOrSelector, {}, sharedContext);
+            normalizedInput = types.map((type) => ({
+                id: type.id,
+                ...data,
+            }));
+        }
+        const types = await this.productTypeService_.update(normalizedInput, sharedContext);
+        const updatedTypes = await this.baseRepository_.serialize(types);
+        return (0, utils_1.isString)(idOrSelector) ? updatedTypes[0] : updatedTypes;
     }
     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 });
+        const createdOptions = await this.baseRepository_.serialize(options);
         return Array.isArray(data) ? createdOptions : createdOptions[0];
     }
     async createOptions_(data, sharedContext = {}) {
@@ -214,6 +209,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     async updateOptions(idOrSelector, data, sharedContext = {}) {
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
+            await this.productOptionService_.retrieve(idOrSelector, {}, sharedContext);
             normalizedInput = [{ id: idOrSelector, ...data }];
         }
         else {
@@ -244,60 +240,12 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         if (normalizedInput.some((option) => !option.id)) {
             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 productOptions;
-    }
-    // TODO: Do validation
-    async diffOptions_(data, sharedContext = {}) {
-        const toCreate = data.filter((o) => !o.id);
-        const toUpdate = data.filter((o) => o.id);
-        let createdOptions = [];
-        let updatedOptions = [];
-        if (toCreate.length) {
-            createdOptions = await this.productOptionService_.create(toCreate, sharedContext);
-        }
-        if (toUpdate.length) {
-            const existingOptions = await this.productOptionService_.list({ id: toUpdate.map((o) => o.id) }, { take: null }, sharedContext);
-            const updateOptions = await (0, utils_1.promiseAll)(toUpdate.map(async (optionToUpdate) => {
-                const dbOption = existingOptions.find((o) => o.id === optionToUpdate.id);
-                if (!dbOption) {
-                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Option with id "${optionToUpdate.id}" does not exist, but was referenced in the update request`);
-                }
-                if (!optionToUpdate.values) {
-                    return optionToUpdate;
-                }
-                const valuesToDelete = dbOption.values
-                    .filter((dbVal) => {
-                    return !optionToUpdate.values?.some((updateVal) => updateVal.value === dbVal.value);
-                })
-                    .map((v) => v.id);
-                const valuesToUpsert = optionToUpdate.values?.map((val) => {
-                    const dbValue = dbOption.values.find((v) => v.value === val.value);
-                    if (dbValue) {
-                        return {
-                            ...val,
-                            id: dbValue.id,
-                        };
-                    }
-                    return val;
-                });
-                await this.productOptionValueService_.delete({
-                    id: { $in: valuesToDelete },
-                });
-                const updatedValues = await this.productOptionValueService_.upsert(valuesToUpsert, sharedContext);
-                return {
-                    ...optionToUpdate,
-                    values: updatedValues,
-                };
-            }));
-            updatedOptions = await this.productOptionService_.update(updateOptions, sharedContext);
-        }
-        return [...createdOptions, ...updatedOptions];
+        return await this.productOptionService_.upsertWithReplace(normalizedInput, { relations: ["values"] }, sharedContext);
     }
     async createCollections(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const collections = await this.createCollections_(input, sharedContext);
-        const createdCollections = await this.baseRepository_.serialize(collections, { populate: true });
+        const createdCollections = await this.baseRepository_.serialize(collections);
         await this.eventBusModuleService_?.emit(collections.map(({ id }) => ({
             eventName: types_2.ProductCollectionEvents.COLLECTION_CREATED,
             data: { id },
@@ -305,8 +253,8 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         return Array.isArray(data) ? createdCollections : createdCollections[0];
     }
     async createCollections_(data, sharedContext = {}) {
-        const normalizedInput = data.map(ProductModuleService.normalizeProductCollectionInput);
-        return await this.productCollectionService_.create(normalizedInput, sharedContext);
+        const normalizedInput = data.map(ProductModuleService.normalizeCreateProductCollectionInput);
+        return await this.productCollectionService_.upsertWithReplace(normalizedInput, { relations: ["products"] }, sharedContext);
     }
     async upsertCollections(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
@@ -339,6 +287,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     async updateCollections(idOrSelector, data, sharedContext = {}) {
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
+            await this.productCollectionService_.retrieve(idOrSelector, {}, sharedContext);
             normalizedInput = [{ id: idOrSelector, ...data }];
         }
         else {
@@ -357,8 +306,8 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         return (0, utils_1.isString)(idOrSelector) ? updatedCollections[0] : updatedCollections;
     }
     async updateCollections_(data, sharedContext = {}) {
-        const normalizedInput = data.map(ProductModuleService.normalizeProductCollectionInput);
-        return await this.productCollectionService_.update(normalizedInput, sharedContext);
+        const normalizedInput = data.map(ProductModuleService.normalizeUpdateProductCollectionInput);
+        return await this.productCollectionService_.upsertWithReplace(normalizedInput, { relations: ["products"] }, sharedContext);
     }
     async createCategory(data, sharedContext = {}) {
         const productCategory = await this.productCategoryService_.create(data, sharedContext);
@@ -381,7 +330,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     async create(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const products = await this.create_(input, sharedContext);
-        const createdProducts = await this.baseRepository_.serialize(products, { populate: true });
+        const createdProducts = await this.baseRepository_.serialize(products);
         await this.eventBusModuleService_?.emit(createdProducts.map(({ id }) => ({
             eventName: types_2.ProductEvents.PRODUCT_CREATED,
             data: { id },
@@ -401,7 +350,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             updated = await this.update_(forUpdate, sharedContext);
         }
         const result = [...created, ...updated];
-        const allProducts = await this.baseRepository_.serialize(result, { populate: true });
+        const allProducts = await this.baseRepository_.serialize(result);
         if (created.length) {
             await this.eventBusModuleService_?.emit(created.map(({ id }) => ({
                 eventName: types_2.ProductEvents.PRODUCT_CREATED,
@@ -419,6 +368,8 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     async update(idOrSelector, data, sharedContext = {}) {
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
+            // This will throw if the product does not exist
+            await this.productService_.retrieve(idOrSelector, {}, sharedContext);
             normalizedInput = [{ id: idOrSelector, ...data }];
         }
         else {
@@ -429,112 +380,109 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             }));
         }
         const products = await this.update_(normalizedInput, sharedContext);
-        const updatedProducts = await this.baseRepository_.serialize(products, { populate: true });
+        const updatedProducts = await this.baseRepository_.serialize(products);
         await this.eventBusModuleService_?.emit(updatedProducts.map(({ id }) => ({
             eventName: types_2.ProductEvents.PRODUCT_UPDATED,
             data: { id },
         })));
         return (0, utils_1.isString)(idOrSelector) ? updatedProducts[0] : updatedProducts;
     }
-    // Orchestrate product creation (and updates follow a similar logic). For each product:
-    // 1. Create the base product
-    // 2. Upsert images, assign to product
-    // 3. Upsert tags, assign to product
-    // 4. Upsert product type, assign to product
-    // 5. Create options and option values
-    // 6. Assign options to variants
-    // 7. Create variants
     async create_(data, sharedContext = {}) {
         const normalizedInput = data.map(ProductModuleService.normalizeCreateProductInput);
-        const productsData = await (0, utils_1.promiseAll)(normalizedInput.map(async (product) => {
-            const productData = { ...product };
-            if (productData.images?.length) {
-                productData.images = await this.productImageService_.upsert(productData.images, sharedContext);
-            }
-            if (productData.tags?.length) {
-                productData.tags = await this.productTagService_.upsert(productData.tags, sharedContext);
-            }
-            if (productData.type) {
-                productData.type = await this.productTypeService_.upsert(productData.type, sharedContext);
-            }
-            // This is not the cleanest solution, but it's the easiest way to reassign categories for now
-            if (productData.categories) {
-                productData.categories = await this.productCategoryService_.list({ id: productData.categories.map((c) => c.id) }, { take: null }, sharedContext);
-            }
-            if (productData.options?.length) {
-                productData.options = await this.productOptionService_.create(productData.options, sharedContext);
+        const productData = await this.productService_.upsertWithReplace(normalizedInput, {
+            relations: ["type", "collection", "images", "tags", "categories"],
+        }, sharedContext);
+        await (0, utils_1.promiseAll)(
+        // Note: It's safe to rely on the order here as `upsertWithReplace` preserves the order of the input
+        normalizedInput.map(async (product, i) => {
+            const upsertedProduct = productData[i];
+            upsertedProduct.options = [];
+            upsertedProduct.variants = [];
+            if (product.options?.length) {
+                upsertedProduct.options =
+                    await this.productOptionService_.upsertWithReplace(product.options?.map((option) => ({
+                        ...option,
+                        product_id: upsertedProduct.id,
+                    })) ?? [], { relations: ["values"] }, sharedContext);
             }
-            if (productData.variants?.length) {
-                productData.variants = await this.productVariantService_.create(ProductModuleService.assignOptionsToVariants(productData.variants, productData.options), sharedContext);
+            if (product.variants?.length) {
+                upsertedProduct.variants =
+                    await this.productVariantService_.upsertWithReplace(ProductModuleService.assignOptionsToVariants(product.variants?.map((v) => ({
+                        ...v,
+                        product_id: upsertedProduct.id,
+                    })) ?? [], upsertedProduct.options), { relations: ["options"] }, sharedContext);
             }
-            return productData;
         }));
-        return await this.productService_.create(productsData, sharedContext);
+        return productData;
     }
     async update_(data, sharedContext = {}) {
         const normalizedInput = data.map(ProductModuleService.normalizeUpdateProductInput);
-        const productsData = await (0, utils_1.promiseAll)(normalizedInput.map(async (product) => {
-            const productData = { ...product };
-            // TODO: We don't remove images, tags, and types as they can exist independently. However, how do we handle orphaned entities?
-            if (productData.images) {
-                productData.images = await this.productImageService_.upsert(productData.images, sharedContext);
-            }
-            if (productData.tags) {
-                productData.tags = await this.productTagService_.upsert(productData.tags, sharedContext);
-            }
-            if (productData.type) {
-                productData.type = await this.productTypeService_.upsert(productData.type, sharedContext);
-            }
-            // This is not the cleanest solution, but it's the easiest way to reassign categories for now
-            if (productData.categories) {
-                productData.categories = await this.productCategoryService_.list({ id: productData.categories.map((c) => c.id) }, { take: null }, sharedContext);
+        const productData = await this.productService_.upsertWithReplace(normalizedInput, {
+            relations: ["type", "collection", "images", "tags", "categories"],
+        }, sharedContext);
+        // There is more than 1-level depth of relations here, so we need to handle the options and variants manually
+        await (0, utils_1.promiseAll)(
+        // Note: It's safe to rely on the order here as `upsertWithReplace` preserves the order of the input
+        normalizedInput.map(async (product, i) => {
+            const upsertedProduct = productData[i];
+            let allOptions = [];
+            if (product.options?.length) {
+                upsertedProduct.options =
+                    await this.productOptionService_.upsertWithReplace(product.options?.map((option) => ({
+                        ...option,
+                        product_id: upsertedProduct.id,
+                    })) ?? [], { relations: ["values"] }, sharedContext);
+                // Since we handle the options and variants outside of the product upsert, we need to clean up manuallys
+                await this.productOptionService_.delete({
+                    product_id: upsertedProduct.id,
+                    id: {
+                        $nin: upsertedProduct.options.map(({ id }) => id),
+                    },
+                }, sharedContext);
+                allOptions = upsertedProduct.options;
             }
-            // TODO: Maybe we also want to delete the options and variants that are not in the list?
-            if (productData.options) {
-                productData.options = await this.diffOptions_(productData.options, sharedContext);
+            else {
+                // If the options weren't affected, but the user is changing the variants, make sure we have all options available locally
+                if (product.variants?.length) {
+                    allOptions = await this.productOptionService_.list({ product_id: upsertedProduct.id }, { take: null }, sharedContext);
+                }
             }
-            if (productData.variants) {
-                const dbOptionsForProduct = await this.productOptionService_.list({ product_id: productData.id }, { take: null }, sharedContext);
-                // Since the options are not flushed yet, we must do this merge here
-                const allOptionsForProduct = uniqBy([...(productData.options ?? []), ...dbOptionsForProduct], "id");
-                productData.variants = await this.diffVariants_(productData.variants, allOptionsForProduct, sharedContext);
+            if (product.variants?.length) {
+                upsertedProduct.variants =
+                    await this.productVariantService_.upsertWithReplace(ProductModuleService.assignOptionsToVariants(product.variants?.map((v) => ({
+                        ...v,
+                        product_id: upsertedProduct.id,
+                    })) ?? [], allOptions), { relations: ["options"] }, sharedContext);
+                await this.productVariantService_.delete({
+                    product_id: upsertedProduct.id,
+                    id: {
+                        $nin: upsertedProduct.variants.map(({ id }) => id),
+                    },
+                }, sharedContext);
             }
-            return productData;
         }));
-        return await this.productService_.update(productsData, sharedContext);
+        return productData;
     }
     static normalizeCreateProductInput(product) {
-        const productData = { ...product };
+        const productData = ProductModuleService.normalizeUpdateProductInput(product);
         if (!productData.handle && productData.title) {
             productData.handle = (0, utils_1.kebabCase)(productData.title);
         }
-        if (productData.is_giftcard) {
-            productData.discountable = false;
-        }
         if (!productData.status) {
-            productData.status = utils_2.ProductStatus.DRAFT;
+            productData.status = utils_1.ProductStatus.DRAFT;
         }
         if (!productData.thumbnail && productData.images?.length) {
-            productData.thumbnail = (0, utils_1.isString)(productData.images[0])
-                ? productData.images[0]
-                : productData.images[0].url;
+            productData.thumbnail = productData.images[0].url;
         }
-        return ProductModuleService.normalizeUpdateProductInput(productData);
+        return productData;
     }
     static normalizeUpdateProductInput(product) {
         const productData = { ...product };
         if (productData.is_giftcard) {
             productData.discountable = false;
         }
-        if (productData.images?.length) {
-            productData.images = productData.images?.map((image) => {
-                if ((0, utils_1.isString)(image)) {
-                    return { url: image };
-                }
-                return image;
-            });
-        }
         if (productData.options?.length) {
+            ;
             productData.options = productData.options?.map((option) => {
                 return {
                     title: option.title,
@@ -548,20 +496,32 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         }
         return productData;
     }
-    static normalizeProductCollectionInput(collection) {
+    static normalizeCreateProductCollectionInput(collection) {
+        const collectionData = ProductModuleService.normalizeUpdateProductCollectionInput(collection);
+        if (!collectionData.handle && collectionData.title) {
+            collectionData.handle = (0, utils_1.kebabCase)(collectionData.title);
+        }
+        return collectionData;
+    }
+    static normalizeUpdateProductCollectionInput(collection) {
         const collectionData = { ...collection };
         if (collectionData.product_ids?.length) {
             ;
-            collectionData.products = collectionData.product_ids;
+            collectionData.products = collectionData.product_ids.map((pid) => ({
+                id: pid,
+            }));
             delete collectionData.product_ids;
         }
         return collectionData;
     }
     static assignOptionsToVariants(variants, options) {
+        if (!variants.length) {
+            return variants;
+        }
         const variantsWithOptions = variants.map((variant) => {
             const variantOptions = Object.entries(variant.options ?? {}).map(([key, val]) => {
                 const option = options.find((o) => o.title === key);
-                const optionValue = option?.values?.find((v) => (v.value.value ?? v.value) === val);
+                const optionValue = option?.values?.find((v) => (v.value?.value ?? v.value) === val);
                 if (!optionValue) {
                     throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Option value ${val} does not exist for option ${key}`);
                 }
@@ -614,13 +574,6 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "updateVariants_", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Array, Object]),
-    __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "diffVariants_", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
@@ -636,17 +589,24 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "updateTags", 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, "createTypes", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("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, "upsertTypes", 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, "updateTypes", null);
 __decorate([
@@ -684,13 +644,6 @@ __decorate([
     __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)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "diffOptions_", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
@@ -782,10 +735,3 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "update_", null);
-const uniqBy = (arr, key) => {
-    const seen = new Set();
-    return arr.filter((item) => {
-        const k = item[key];
-        return seen.has(k) ? false : seen.add(k);
-    });
-};

package/dist/services/product.d.ts

@@ -3,11 +3,19 @@ import { Product } from "../models";
 type InjectedDependencies = {
     productRepository: DAL.RepositoryService;
 };
+type NormalizedFilterableProductProps = ProductTypes.FilterableProductProps & {
+    categories?: {
+        id: string | {
+            $in: string[];
+        };
+    };
+};
 declare const ProductService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => import("@medusajs/types").InternalModuleService<TEntity_1, InjectedDependencies>;
 export default class ProductService<TEntity extends Product = Product> extends ProductService_base<TEntity> {
     protected readonly productRepository_: DAL.RepositoryService<TEntity>;
     constructor({ productRepository }: InjectedDependencies);
     list(filters?: ProductTypes.FilterableProductProps, config?: FindConfig<TEntity>, sharedContext?: Context): Promise<TEntity[]>;
     listAndCount(filters?: ProductTypes.FilterableProductProps, config?: FindConfig<any>, sharedContext?: Context): Promise<[TEntity[], number]>;
+    protected static normalizeFilters(filters?: NormalizedFilterableProductProps): NormalizedFilterableProductProps;
 }
 export {};

package/dist/services/product.js

@@ -23,22 +23,12 @@ class ProductService extends utils_1.ModulesSdkUtils.internalModuleServiceFactor
         this.productRepository_ = productRepository;
     }
     async list(filters = {}, config = {}, sharedContext = {}) {
-        if (filters.category_id) {
-            if (Array.isArray(filters.category_id)) {
-                filters.categories = {
-                    id: { $in: filters.category_id },
-                };
-            }
-            else {
-                filters.categories = {
-                    id: filters.category_id,
-                };
-            }
-            delete filters.category_id;
-        }
-        return await super.list(filters, config, sharedContext);
+        return await super.list(ProductService.normalizeFilters(filters), config, sharedContext);
     }
     async listAndCount(filters = {}, config = {}, sharedContext = {}) {
+        return await super.listAndCount(ProductService.normalizeFilters(filters), config, sharedContext);
+    }
+    static normalizeFilters(filters = {}) {
         if (filters.category_id) {
             if (Array.isArray(filters.category_id)) {
                 filters.categories = {
@@ -52,7 +42,7 @@ class ProductService extends utils_1.ModulesSdkUtils.internalModuleServiceFactor
             }
             delete filters.category_id;
         }
-        return await super.listAndCount(filters, config, sharedContext);
+        return filters;
     }
 }
 exports.default = ProductService;

package/dist/types/index.d.ts

@@ -19,9 +19,6 @@ export declare enum ProductEvents {
     PRODUCT_CREATED = "product.created",
     PRODUCT_DELETED = "product.deleted"
 }
-export type UpdateProductInput = ProductTypes.UpdateProductDTO & {
-    id: string;
-};
 export type ProductCollectionEventData = {
     id: string;
 };
@@ -30,6 +27,9 @@ export declare enum ProductCollectionEvents {
     COLLECTION_CREATED = "product-collection.created",
     COLLECTION_DELETED = "product-collection.deleted"
 }
+export type UpdateProductInput = ProductTypes.UpdateProductDTO & {
+    id: string;
+};
 export type UpdateProductCollection = ProductTypes.UpdateProductCollectionDTO & {
     products?: string[];
 };
@@ -39,9 +39,12 @@ export type CreateProductCollection = ProductTypes.CreateProductCollectionDTO &
 export type UpdateCollectionInput = ProductTypes.UpdateProductCollectionDTO & {
     id: string;
 };
+export type UpdateTypeInput = ProductTypes.UpdateProductTypeDTO & {
+    id: string;
+};
 export type UpdateProductVariantInput = ProductTypes.UpdateProductVariantDTO & {
     id: string;
-    product_id?: string;
+    product_id?: string | null;
 };
 export type UpdateProductOptionInput = ProductTypes.UpdateProductOptionDTO & {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medusajs/product",
-  "version": "0.4.0-snapshot-20240322174858",
+  "version": "0.4.0-snapshot-20240329212017",
   "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.43-snapshot-20240322174858",
+    "medusa-test-utils": "1.1.44-snapshot-20240329212017",
     "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.10-snapshot-20240322174858",
-    "@medusajs/types": "1.12.0-snapshot-20240322174858",
-    "@medusajs/utils": "1.11.8-snapshot-20240322174858",
+    "@medusajs/modules-sdk": "1.12.11-snapshot-20240329212017",
+    "@medusajs/types": "1.12.0-snapshot-20240329212017",
+    "@medusajs/utils": "1.12.0-snapshot-20240329212017",
     "@mikro-orm/core": "5.9.7",
     "@mikro-orm/migrations": "5.9.7",
     "@mikro-orm/postgresql": "5.9.7",