asyavee/medusa-store
1
0 Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

feat(prduct, utils, types): Create soft delete pattern for link module (#4649)

Browse Source 
* feat(prouct, utils, types): Create soft delete pattern for link module

* add comment

* add comment

* finalise

* remove linkable keys

* cleanup and tests

* cleanup

* add some comments and renaming

* re work

* fix tests

---------

Co-authored-by: Riqwan Thamir <rmthamir@gmail.com>
This commit is contained in:
Adrien de PerettiandRiqwan Thamir authored and GitHub committed 2023-08-02 19:29:01 +02:00
1 parent fc6c9df035
commit ce3326c5fb
17 files changed
+448 -166
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

packages/product/integration-tests/__tests__/module.ts
-1
View File
@@ -230,7 +230,6 @@ describe("Product module", function () {
const products = await module.create([data])
await module.softDelete([products[0].id])
const deletedProducts = await module.list(
{ id: products[0].id },
{
packages/product/integration-tests/__tests__/services/product/index.ts
+53 -27
View File
@@ -1,6 +1,7 @@
import { Image, Product, ProductCategory, ProductVariant } from "@models"
import {
assignCategoriesToProduct,
buildProductOnlyData,
createImages,
createProductAndTags,
createProductVariants,
@@ -16,7 +17,6 @@ import { ProductRepository } from "@repositories"
import { ProductService } from "@services"
import { SqlEntityManager } from "@mikro-orm/postgresql"
import { TestDatabase } from "../../../utils"
import { buildProductOnlyData } from "../../../__fixtures__/product/data/create-product"
import { createProductCategories } from "../../../__fixtures__/product-category"
import { kebabCase } from "@medusajs/utils"
@@ -81,15 +81,19 @@ describe("Product Service", () => {
error = e
}
expect(error.message).toEqual('Product with id: does-not-exist was not found')
expect(error.message).toEqual(
"Product with id: does-not-exist was not found"
)
})
it("should return a product when product with an id exists", async () => {
const result = await service.retrieve(productOne.id)
expect(result).toEqual(expect.objectContaining({
id: productOne.id
}))
expect(result).toEqual(
expect.objectContaining({
id: productOne.id,
})
)
})
})
@@ -150,18 +154,22 @@ describe("Product Service", () => {
})
it("should update a product and its allowed relations", async () => {
const updateData = [{
id: productOne.id,
title: "update test 1",
images: images,
thumbnail: images[0].url,
}]
const updateData = [
{
id: productOne.id,
title: "update test 1",
images: images,
thumbnail: images[0].url,
},
]
const products = await service.update(updateData)
expect(products.length).toEqual(1)
let result = await service.retrieve(productOne.id, {relations: ["images", "thumbnail"]})
let result = await service.retrieve(productOne.id, {
relations: ["images", "thumbnail"],
})
let serialized = JSON.parse(JSON.stringify(result))
expect(serialized).toEqual(
@@ -183,13 +191,16 @@ describe("Product Service", () => {
it("should throw an error when id is not present", async () => {
let error
const updateData = [{
id: productOne.id,
title: "update test 1",
}, {
id: undefined as unknown as string,
title: "update test 2",
}]
const updateData = [
{
id: productOne.id,
title: "update test 1",
},
{
id: undefined as unknown as string,
title: "update test 2",
},
]
try {
await service.update(updateData)
@@ -206,10 +217,12 @@ describe("Product Service", () => {
it("should throw an error when product with id does not exist", async () => {
let error
const updateData = [{
id: "does-not-exist",
title: "update test 1",
}]
const updateData = [
{
id: "does-not-exist",
title: "update test 1",
},
]
try {
await service.update(updateData)
@@ -217,13 +230,14 @@ describe("Product Service", () => {
error = e
}
expect(error.message).toEqual(`Product with id "does-not-exist" not found`)
expect(error.message).toEqual(
`Product with id "does-not-exist" not found`
)
})
})
describe("list", () => {
describe("soft deleted", function () {
let deletedProduct
let product
beforeEach(async () => {
@@ -232,7 +246,7 @@ describe("Product Service", () => {
const products = await createProductAndTags(testManager, productsData)
product = products[1]
deletedProduct = await service.softDelete([products[0].id])
await service.softDelete([products[0].id])
})
it("should list all products that are not deleted", async () => {
@@ -462,7 +476,19 @@ describe("Product Service", () => {
})
const products = await service.create([data])
const deleteProducts = await service.softDelete(products.map((p) => p.id))
await service.softDelete(products.map((p) => p.id))
const deleteProducts = await service.list(
{ id: products.map((p) => p.id) },
{
relations: [
"variants",
"variants.options",
"options",
"options.values",
],
withDeleted: true,
}
)
expect(deleteProducts).toHaveLength(1)
expect(deleteProducts[0].deleted_at).not.toBeNull()
packages/product/src/joiner-config.ts
+54
View File
@@ -1,5 +1,59 @@
import { Modules } from "@medusajs/modules-sdk"
import { JoinerServiceConfig } from "@medusajs/types"
import {
Product,
ProductCategory,
ProductCollection,
ProductOption,
ProductTag,
ProductType,
ProductVariant,
} from "@models"
import ProductImage from "./models/product-image"
import { MapToConfig } from "@medusajs/utils"
export enum LinkableKeys {
PRODUCT_ID = "product_id",
PRODUCT_HANDLE = "product_handle",
VARIANT_ID = "variant_id",
VARIANT_SKU = "variant_sku",
PRODUCT_OPTION_ID = "product_option_id",
PRODUCT_TYPE_ID = "product_type_id",
PRODUCT_CATEGORY_ID = "product_category_id",
PRODUCT_COLLECTION_ID = "product_collection_id",
PRODUCT_TAG_ID = "product_tag_id",
PRODUCT_IMAGE_ID = "product_image_id",
}
export const entityNameToLinkableKeysMap: MapToConfig = {
[Product.name]: [
{ mapTo: LinkableKeys.PRODUCT_ID, valueFrom: "id" },
{
mapTo: LinkableKeys.PRODUCT_HANDLE,
valueFrom: "handle",
},
],
[ProductVariant.name]: [
{ mapTo: LinkableKeys.VARIANT_ID, valueFrom: "id" },
{ mapTo: LinkableKeys.VARIANT_SKU, valueFrom: "sku" },
],
[ProductOption.name]: [
{ mapTo: LinkableKeys.PRODUCT_OPTION_ID, valueFrom: "id" },
],
[ProductType.name]: [
{ mapTo: LinkableKeys.PRODUCT_TYPE_ID, valueFrom: "id" },
],
[ProductCategory.name]: [
{ mapTo: LinkableKeys.PRODUCT_CATEGORY_ID, valueFrom: "id" },
],
[ProductCollection.name]: [
{ mapTo: LinkableKeys.PRODUCT_COLLECTION_ID, valueFrom: "id" },
],
[ProductTag.name]: [{ mapTo: LinkableKeys.PRODUCT_TAG_ID, valueFrom: "id" }],
[ProductImage.name]: [
{ mapTo: LinkableKeys.PRODUCT_IMAGE_ID, valueFrom: "id" },
],
}
export const joinerConfig: JoinerServiceConfig = {
serviceName: Modules.PRODUCT,
packages/product/src/services/product-category.ts
+29 -20
View File
@@ -2,12 +2,12 @@ import { ProductCategory } from "@models"
import { ProductCategoryRepository } from "@repositories"
import { Context, DAL, FindConfig, ProductTypes } from "@medusajs/types"
import {
ModulesSdkUtils,
MedusaError,
isDefined,
InjectTransactionManager,
InjectManager,
MedusaContext
InjectTransactionManager,
isDefined,
MedusaContext,
MedusaError,
ModulesSdkUtils,
} from "@medusajs/utils"
import { shouldForceTransaction } from "../utils"
@@ -39,9 +39,12 @@ export default class ProductCategoryService<
)
}
const queryOptions = ModulesSdkUtils.buildQuery<ProductCategory>({
id: productCategoryId,
}, config)
const queryOptions = ModulesSdkUtils.buildQuery<ProductCategory>(
{
id: productCategoryId,
},
config
)
const transformOptions = {
includeDescendantsTree: true,
@@ -111,31 +114,37 @@ export default class ProductCategoryService<
)) as [TEntity[], number]
}
@InjectTransactionManager(shouldForceTransaction, "productCategoryRepository_")
@InjectTransactionManager(
shouldForceTransaction,
"productCategoryRepository_"
)
async create(
data: ProductCategoryServiceTypes.CreateProductCategoryDTO,
@MedusaContext() sharedContext: Context = {}
): Promise<TEntity> {
return (await (this.productCategoryRepository_ as ProductCategoryRepository).create(
data,
sharedContext
)) as TEntity
return (await (
this.productCategoryRepository_ as unknown as ProductCategoryRepository
).create(data, sharedContext)) as TEntity
}
@InjectTransactionManager(shouldForceTransaction, "productCategoryRepository_")
@InjectTransactionManager(
shouldForceTransaction,
"productCategoryRepository_"
)
async update(
id: string,
data: ProductCategoryServiceTypes.UpdateProductCategoryDTO,
@MedusaContext() sharedContext: Context = {}
): Promise<TEntity> {
return (await (this.productCategoryRepository_ as ProductCategoryRepository).update(
id,
data,
sharedContext
)) as TEntity
return (await (
this.productCategoryRepository_ as unknown as ProductCategoryRepository
).update(id, data, sharedContext)) as TEntity
}
@InjectTransactionManager(shouldForceTransaction, "productCategoryRepository_")
@InjectTransactionManager(
shouldForceTransaction,
"productCategoryRepository_"
)
async delete(
id: string,
@MedusaContext() sharedContext: Context = {}
packages/product/src/services/product-collection.ts
+21 -14
View File
@@ -1,10 +1,10 @@
import { Context, DAL, FindConfig, ProductTypes } from "@medusajs/types"
import {
ModulesSdkUtils,
retrieveEntity,
InjectManager,
InjectTransactionManager,
MedusaContext,
InjectManager,
ModulesSdkUtils,
retrieveEntity,
} from "@medusajs/utils"
import { shouldForceTransaction } from "../utils"
@@ -85,29 +85,36 @@ export default class ProductCollectionService<
return queryOptions
}
@InjectTransactionManager(shouldForceTransaction, "productCollectionRepository_")
@InjectTransactionManager(
shouldForceTransaction,
"productCollectionRepository_"
)
async create(
data: ProductTypes.CreateProductCollectionDTO[],
@MedusaContext() sharedContext: Context = {}
): Promise<TEntity[]> {
return (await (this.productCollectionRepository_ as ProductCollectionRepository).create(
data,
sharedContext
)) as TEntity[]
return (await (
this.productCollectionRepository_ as ProductCollectionRepository
).create(data, sharedContext)) as TEntity[]
}
@InjectTransactionManager(shouldForceTransaction, "productCollectionRepository_")
@InjectTransactionManager(
shouldForceTransaction,
"productCollectionRepository_"
)
async update(
data: ProductTypes.UpdateProductCollectionDTO[],
@MedusaContext() sharedContext: Context = {}
): Promise<TEntity[]> {
return (await (this.productCollectionRepository_ as ProductCollectionRepository).update(
data,
sharedContext
)) as TEntity[]
return (await (
this.productCollectionRepository_ as ProductCollectionRepository
).update(data, sharedContext)) as TEntity[]
}
@InjectTransactionManager(shouldForceTransaction, "productCollectionRepository_")
@InjectTransactionManager(
shouldForceTransaction,
"productCollectionRepository_"
)
async delete(
ids: string[],
@MedusaContext() sharedContext: Context = {}
packages/product/src/services/product-module-service.ts
+33 -9
View File
@@ -38,12 +38,17 @@ import {
isDefined,
isString,
kebabCase,
mapObjectTo,
MedusaContext,
MedusaError,
} from "@medusajs/utils"
import { shouldForceTransaction } from "../utils"
import { joinerConfig } from "./../joiner-config"
import {
entityNameToLinkableKeysMap,
joinerConfig,
LinkableKeys,
} from "./../joiner-config"
import { ProductCategoryServiceTypes } from "../types"
type InjectedDependencies = {
@@ -958,7 +963,7 @@ export default class ProductModuleService<
) {
if (isDefined(productData.type)) {
const productType = await this.productTypeService_.upsert(
[productData.type],
[productData.type!],
sharedContext
)
@@ -974,22 +979,41 @@ export default class ProductModuleService<
await this.productService_.delete(productIds, sharedContext)
}
async softDelete(
async softDelete<
TReturnableLinkableKeys extends string = Lowercase<
keyof typeof LinkableKeys
>
>(
productIds: string[],
{
returnLinkableKeys,
}: { returnLinkableKeys?: TReturnableLinkableKeys[] } = {
returnLinkableKeys: [],
},
sharedContext: Context = {}
): Promise<ProductTypes.ProductDTO[]> {
const products = await this.softDelete_(productIds, sharedContext)
): Promise<Record<Lowercase<keyof typeof LinkableKeys>, string[]> | void> {
let [, cascadedEntitiesMap] = await this.softDelete_(
productIds,
sharedContext
)
return this.baseRepository_.serialize<ProductTypes.ProductDTO[]>(products, {
populate: true,
})
let mappedCascadedEntitiesMap
if (returnLinkableKeys) {
mappedCascadedEntitiesMap = mapObjectTo<
Record<Lowercase<keyof typeof LinkableKeys>, string[]>
>(cascadedEntitiesMap, entityNameToLinkableKeysMap, {
pick: returnLinkableKeys as string[],
})
}
return mappedCascadedEntitiesMap ? mappedCascadedEntitiesMap : void 0
}
@InjectTransactionManager(shouldForceTransaction, "baseRepository_")
protected async softDelete_(
productIds: string[],
@MedusaContext() sharedContext: Context = {}
): Promise<TProduct[]> {
): Promise<[TProduct[], Record<string, unknown[]>]> {
return await this.productService_.softDelete(productIds, sharedContext)
}
packages/product/src/services/product.ts
+10 -7
View File
@@ -10,10 +10,10 @@ import {
import {
InjectManager,
InjectTransactionManager,
isDefined,
MedusaContext,
MedusaError,
ModulesSdkUtils,
isDefined,
} from "@medusajs/utils"
import { ProductRepository } from "@repositories"
@@ -44,9 +44,12 @@ export default class ProductService<TEntity extends Product = Product> {
)
}
const queryOptions = ModulesSdkUtils.buildQuery<Product>({
id: productId,
}, config)
const queryOptions = ModulesSdkUtils.buildQuery<Product>(
{
id: productId,
},
config
)
const product = await this.productRepository_.find(
queryOptions,
@@ -140,7 +143,7 @@ export default class ProductService<TEntity extends Product = Product> {
data: ProductServiceTypes.UpdateProductDTO[],
@MedusaContext() sharedContext: Context = {}
): Promise<TEntity[]> {
return await (this.productRepository_ as ProductRepository).update(
return (await (this.productRepository_ as ProductRepository).update(
data as WithRequiredProperty<
ProductServiceTypes.UpdateProductDTO,
"id"
@@ -148,7 +151,7 @@ export default class ProductService<TEntity extends Product = Product> {
{
transactionManager: sharedContext.transactionManager,
}
) as TEntity[]
)) as TEntity[]
}
@InjectTransactionManager(doNotForceTransaction, "productRepository_")
@@ -165,7 +168,7 @@ export default class ProductService<TEntity extends Product = Product> {
async softDelete(
productIds: string[],
@MedusaContext() sharedContext: Context = {}
): Promise<TEntity[]> {
): Promise<[TEntity[], Record<string, unknown[]>]> {
return await this.productRepository_.softDelete(productIds, {
transactionManager: sharedContext.transactionManager,
})