@csbeker/medusa-product-attributes 2.2.0

package/src/workflows/attribute/workflows/create-attributes.ts

@@ -0,0 +1,56 @@
+import { createWorkflow, transform, when, WorkflowData, WorkflowResponse } from "@medusajs/framework/workflows-sdk";
+import { CreateAttributesWorkflowInput } from "../../../modules/attribute/types/attribute/common";
+import { createAttributesStep } from "../steps/create-attributes";
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute";
+import { Modules } from "@medusajs/framework/utils";
+import { LinkDefinition } from "@medusajs/framework/types";
+import { createRemoteLinkStep, emitEventStep } from "@medusajs/medusa/core-flows";
+import { AttributeWorkflowsEvents } from "../../../modules/attribute/events";
+
+export const createAttributesWorkflowId = 'create-attributes'
+
+export const createAttributesWorkflow = createWorkflow(
+    createAttributesWorkflowId,
+    (input: WorkflowData<CreateAttributesWorkflowInput>) => {
+        const attributesWithoutExternalRelations = transform(input, ({ attributes }) => {
+            return attributes.map(attribute => {
+                const { product_category_ids, ...result } = attribute
+                return result 
+            })
+        })
+
+        const createdAttributes = createAttributesStep(attributesWithoutExternalRelations)
+
+        const productCategoryLinks: LinkDefinition[] = transform({ input, createdAttributes }, ({ input, createdAttributes }) => {
+            return createdAttributes.map((attribute, idx) => {
+                const inputAttribute = input.attributes[idx]
+                return inputAttribute.product_category_ids?.map(productCategoryId => ({
+                    [ATTRIBUTE_MODULE]: {
+                        attribute_id: attribute.id
+                    },
+                    [Modules.PRODUCT]: {
+                        product_category_id: productCategoryId
+                    }
+                })) || []
+            }).flat()
+        })
+
+        when({ productCategoryLinks }, ({ productCategoryLinks }) => {
+            return productCategoryLinks.length > 0
+        }).then(() => {
+            createRemoteLinkStep(productCategoryLinks)
+        })
+
+
+        const attributeEventData = transform({ createdAttributes }, ({ createdAttributes }) => {
+            return createdAttributes.map(attribute => attribute.id)
+        }) as string[]
+
+        emitEventStep({
+            eventName: AttributeWorkflowsEvents.CREATED,
+            data: attributeEventData
+        })
+
+        return new WorkflowResponse(createdAttributes)
+    } 
+)

package/src/workflows/attribute/workflows/delete-attribute.ts

@@ -0,0 +1,15 @@
+import { createWorkflow, WorkflowResponse } from "@medusajs/framework/workflows-sdk"
+import { deleteAttributeStep } from "../steps"
+
+export const deleteAttributeWorkflowId = 'delete-attribute-worklfow'
+
+type DeleteAttributeWorkflowInput = {
+    id: string
+}
+
+export const deleteAttributeWorkflow = createWorkflow(
+    deleteAttributeWorkflowId,
+    (input: DeleteAttributeWorkflowInput) => {
+        return new WorkflowResponse(deleteAttributeStep(input))
+    }
+)

package/src/workflows/attribute/workflows/index.ts

@@ -0,0 +1,3 @@
+export * from './create-attributes'
+export * from './update-attributes'
+export * from './create-attribute-possible-values'

package/src/workflows/attribute/workflows/update-attributes.ts

@@ -0,0 +1,103 @@
+import {
+  createWorkflow,
+  parallelize,
+  transform,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import { UpdateAttributeDTO } from "../../../modules/attribute/types/attribute/common";
+import { updateAttributesStep } from "../steps";
+import { LinkDefinition } from "@medusajs/framework/types";
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute";
+import { arrayDifference, Modules } from "@medusajs/framework/utils";
+import { createRemoteLinkStep, dismissRemoteLinkStep, emitEventStep, useQueryGraphStep, useRemoteQueryStep } from "@medusajs/medusa/core-flows";
+import attributeProductCategory from "../../../links/attribute-product-category";
+import { AttributeWorkflowsEvents } from "../../../modules/attribute/events";
+
+const updateAttributesWorkflowId = "update-attributes";
+
+export type UpdateAttributesWorkflowInput = {
+  attributes: UpdateAttributeDTO[];
+};
+
+export const updateAttributesWorkflow = createWorkflow(
+  updateAttributesWorkflowId,
+  (input: UpdateAttributesWorkflowInput) => {
+    const toUpdateInput = transform({ input }, ({ input: { attributes } }) => {
+      return attributes.map((attribute) => ({
+        ...attribute,
+        product_category_ids: undefined,
+      }));
+    });
+
+    const updatedAttributes = updateAttributesStep(toUpdateInput);
+
+    const attributesIdsWithCategories = transform({ input, updatedAttributes }, ({ input, updatedAttributes }) => {
+        const updatedAttributeIds = updatedAttributes.map(attr => attr.id)
+        const attributeIdsWithoutCategories = input.attributes
+            .filter(attr => !attr.product_category_ids)
+            .map(attr => attr.id)
+        return arrayDifference(updatedAttributeIds, attributeIdsWithoutCategories)
+    })
+
+    const currentCategoriesLinksResult = useQueryGraphStep({
+      entity: attributeProductCategory.entryPoint,
+      fields: ["attribute_id", "product_category_id"],
+        filters: {
+          attribute_id: attributesIdsWithCategories,
+        },
+    });
+
+    const currentCategoriesLinks = transform({ currentCategoriesLinksResult }, ({ currentCategoriesLinksResult }) => {
+        return currentCategoriesLinksResult.data
+    })
+
+    const toDeleteCategoriesLinks = transform({ currentCategoriesLinks }, ({ currentCategoriesLinks }) => {
+        if (!currentCategoriesLinks.length) {
+            return []
+        }
+
+        return currentCategoriesLinks.map(({ attribute_id, product_category_id }) => ({
+            [ATTRIBUTE_MODULE]: {
+                attribute_id
+            },
+            [Modules.PRODUCT]: {
+                product_category_id
+            }
+        }))
+    })
+
+    dismissRemoteLinkStep(toDeleteCategoriesLinks)
+
+    const toCreateCategoryLinks: LinkDefinition[] = transform(
+      { input },
+      ({ input: { attributes }}) => {
+        return attributes
+          .filter((attribute) => attribute.product_category_ids)
+          .flatMap((attribute) =>
+            attribute.product_category_ids!.map((attrCat) => ({
+              [ATTRIBUTE_MODULE]: {
+                attribute_id: attribute.id,
+              },
+              [Modules.PRODUCT]: {
+                product_category_id: attrCat,
+              },
+            }))
+          );
+      }
+    )
+
+    const updatedAttributesEventData = transform({ updatedAttributes }, ({ updatedAttributes }) => 
+        updatedAttributes.map(attr => attr.id)
+    )
+
+    parallelize(
+        createRemoteLinkStep(toCreateCategoryLinks),
+        emitEventStep({
+            eventName: AttributeWorkflowsEvents.UPDATED,
+            data: updatedAttributesEventData
+        })
+    )
+
+    return new WorkflowResponse(updatedAttributes)
+  }
+);

package/src/workflows/attribute-set/steps/batch-link-attribute-set-attributes.ts

@@ -0,0 +1,82 @@
+import { createStep, StepResponse } from "@medusajs/framework/workflows-sdk"
+import { AdminBatchLinkAttributeSetAttributesType } from "../../../api/admin/plugin/attribute-set/validators"
+import AttributeModuleService from "../../../modules/attribute/service"
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute"
+import { LinkWorkflowInput } from "@medusajs/framework/types"
+
+export const batchLinkAttributeSetAttributesStepId = 'batch-link-attribute-set-attributes'
+
+export const batchLinkAttributeSetAttributesStep = createStep(
+    batchLinkAttributeSetAttributesStepId,
+    async (data: LinkWorkflowInput, { container }) => {
+        if (!data.add?.length && !data.remove?.length) {
+            return new StepResponse(void 0, null)
+        }
+
+        const service = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+
+        const toRemoveAttributesSet = new Set(data.remove?.map(id => id))
+        const targetAttributes = await service.listAttributes({
+            id: [...(data?.add ?? []), ...(data?.remove ?? [])] 
+        }, {
+            select: ['id'],
+            relations: ['sets']
+        })
+
+        const attributesWithUpdateSets = targetAttributes.map(attribute => {
+            if (toRemoveAttributesSet.has(attribute.id)) {
+                return {
+                    id: attribute.id,
+                    sets: (attribute.sets ?? [])
+                        .filter(attrSet => attrSet.id !== data.id)
+                        .map(attrSet => attrSet.id)
+                }
+            }
+
+            return {
+                id: attribute.id,
+                sets: [...(attribute.sets ?? []).map(attrSet => attrSet.id), data.id]
+            }
+        }) as { id: string, sets: string[]}[]
+
+        await service.updateAttributes(attributesWithUpdateSets)
+
+        return new StepResponse(void 0, {
+            ...data,
+            attribute_ids: attributesWithUpdateSets.map(attr => attr.id)
+        })
+    },
+    async (data: (LinkWorkflowInput & { attribute_ids: string[] }) | null, { container }) => {
+        if(!data?.add || !data?.remove) {
+            return
+        }
+
+        const service = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+
+        const toRevertAttributeSet = new Set(data?.remove?.map(id => id))
+        const targetAttributes = await service.listAttributes({
+            id: data.attribute_ids,
+        }, {
+            select: ['id'],
+            relations: ['sets']
+        })
+      
+        const attributesWithRevertedSets = targetAttributes.map(attribute => {
+            if (toRevertAttributeSet.has(attribute.id)) {
+                return {
+                    id: attribute.id,
+                    sets: [...(attribute.sets ?? []).map(attrSet => attrSet.id), data.id]
+                }
+            }
+
+            return {
+                id: attribute.id,
+                sets: (attribute.sets ?? [])
+                    .filter(attrSet => attrSet.id !== data.id)
+                    .map(attrSet => attrSet.id)
+            }
+        }) as { id:string, sets: string[]}[]
+
+        await service.updateAttributes(attributesWithRevertedSets)
+    }
+)

package/src/workflows/attribute-set/steps/create-attribute-set.ts

@@ -0,0 +1,34 @@
+import { StepResponse, createStep } from "@medusajs/framework/workflows-sdk"
+
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute"
+import AttributeModuleService from "../../../modules/attribute/service"
+import { CreateAttributeSetDTO } from "../../../modules/attribute/types"
+import { kebabCase, toHandle } from "@medusajs/framework/utils"
+
+export const createAttributeSetStepId = 'create-attribute-set'
+
+export const createAttributeSetStep = createStep(
+    createAttributeSetStepId,
+    async (input: CreateAttributeSetDTO | CreateAttributeSetDTO[], { container }) => {
+        const attributeModuleService = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+
+        const normalizedInput = Array.isArray(input) ? input : [input]
+
+        const toCreate = normalizedInput.map(attributeSet => ({
+            ...attributeSet,
+            handle: attributeSet.handle?.length ? attributeSet.handle : toHandle(attributeSet.name)
+        }))
+
+        const created = await attributeModuleService.createAttributeSets(toCreate)
+
+        return new StepResponse(created, created.map(set => set.id))
+    },
+    async (ids: string[] | undefined, { container }) => {
+        if (!ids?.length) {
+            return
+        }
+
+        const attributeModuleService = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+        await attributeModuleService.deleteAttributeSets(ids)
+    }
+)

package/src/workflows/attribute-set/steps/index.ts

@@ -0,0 +1,3 @@
+export * from './create-attribute-set'
+export * from './batch-link-attribute-set-attributes'
+export * from './update-attribute-set'

package/src/workflows/attribute-set/steps/update-attribute-set.ts

@@ -0,0 +1,32 @@
+import { createStep, StepResponse } from "@medusajs/framework/workflows-sdk"
+import { AdminUpdateAttributeSetType } from "../../../api/admin/plugin/attribute-set/validators"
+import AttributeModuleService from "../../../modules/attribute/service"
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute"
+
+export const updateAttributeStepId = 'update-attribute-set'
+
+type UpdateAttributeStepInput = AdminUpdateAttributeSetType & { id: string }
+
+export const updateAttributeSetStep = createStep(
+    updateAttributeStepId,
+    async (data: UpdateAttributeStepInput, { container }) => {
+        const service = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+
+        const prev = await service.retrieveAttributeSet(data.id)
+        const updated = await service.updateAttributeSets(data)
+
+        return new StepResponse(updated, prev)
+    },
+    async (prev, { container }) => {
+        if (!prev) {
+            return 
+        }
+        
+        const service = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+
+        await service.updateAttributeSets({
+            ...prev,
+            attributes: prev.attributes.map(attr => attr.id)
+        })
+    }
+)

package/src/workflows/attribute-set/workflows/batch-link-attribute-set-attributes.ts

@@ -0,0 +1,12 @@
+import { LinkWorkflowInput } from "@medusajs/framework/types"
+import { createWorkflow, WorkflowResponse } from "@medusajs/framework/workflows-sdk"
+import { batchLinkAttributeSetAttributesStep } from "../steps"
+
+export const batchLinkAttributeSetAttributesWorkflowId = 'batch-link-attribute-set-attributes'
+
+export const batchLinkAttributeSetAttributesWorkflow = createWorkflow(
+    batchLinkAttributeSetAttributesWorkflowId,
+    (input: LinkWorkflowInput) => {
+        return new WorkflowResponse(batchLinkAttributeSetAttributesStep(input))
+    }
+)

package/src/workflows/attribute-set/workflows/create-attribute-set.ts

@@ -0,0 +1,17 @@
+import { WorkflowResponse, createWorkflow, transform } from "@medusajs/framework/workflows-sdk"
+
+import { CreateAttributeSetDTO } from "../../../modules/attribute/types"
+import { createAttributeSetStep } from "../steps"
+
+export const createAttributeSetWorkflowId = 'create-attribute-set'
+
+export type CreateAttributeSetWorkflowInput = CreateAttributeSetDTO[]
+
+export const createAttributeSetWorkflow = createWorkflow(
+    createAttributeSetWorkflowId,
+    (input: CreateAttributeSetWorkflowInput) => {
+        const created = createAttributeSetStep(input)
+
+        return new WorkflowResponse(created)
+    }
+)

package/src/workflows/attribute-set/workflows/index.ts

@@ -0,0 +1,3 @@
+export * from './batch-link-attribute-set-attributes'
+export * from './create-attribute-set'
+export * from './update-attribute-set'

package/src/workflows/attribute-set/workflows/update-attribute-set.ts

@@ -0,0 +1,14 @@
+import { createWorkflow, WorkflowResponse } from "@medusajs/framework/workflows-sdk"
+import { AdminUpdateAttributeSetType } from "../../../api/admin/plugin/attribute-set/validators"
+import { updateAttributeSetStep } from "../steps"
+
+export const updateAttributeWorkflowId = 'update-attribute-set'
+
+type UpdateAttributeSetWorkflowInput = AdminUpdateAttributeSetType & { id: string }
+
+export const updateAttributeSetWorkflow = createWorkflow(
+    updateAttributeWorkflowId,
+    (input: UpdateAttributeSetWorkflowInput) => {
+        return new WorkflowResponse(updateAttributeSetStep(input))
+    }
+)

package/src/workflows/attribute-value/steps/create-attribute-value.ts

@@ -0,0 +1,26 @@
+import { StepResponse, createStep } from "@medusajs/framework/workflows-sdk"
+
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute";
+import AttributeModuleService from "../../../modules/attribute/service";
+import { CreateProductAttributeValueDTO } from "../../../modules/attribute/types"
+
+export const createAttributeValueStepId = 'create-attribute-value'
+
+export const createAttributeValueStep = createStep(
+    createAttributeValueStepId,
+    async (input: Omit<CreateProductAttributeValueDTO, 'product_id'>, { container }) => {
+        const attributeModuleService = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+        
+        const created = await attributeModuleService.createAttributeValues(input)
+
+        return new StepResponse(created, created.id)
+    },
+    async (id: string | undefined, { container }) => {
+        if (!id) {
+            return;
+        }
+        
+        const attributeModuleService = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+        await attributeModuleService.deleteAttributeValues(id)
+    }
+)

package/src/workflows/attribute-value/steps/delete-attribute-value.ts

@@ -0,0 +1,26 @@
+import { StepResponse, createStep } from "@medusajs/framework/workflows-sdk"
+
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute"
+import AttributeModuleService from "../../../modules/attribute/service"
+
+export const deleteAttributeValueStepId = 'delete-attribute-value'
+
+export const deleteAttributeValueStep = createStep(
+    deleteAttributeValueStepId,
+    async (ids: string[], { container }) => {
+        const attributeModuleService = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+
+        await attributeModuleService.softDeleteAttributeValues(ids)
+
+        return new StepResponse(ids, ids)
+    },
+    async (ids: string[] | undefined, { container }) => {
+        if (!ids?.length) {
+            return
+        }
+        
+        const attributeModuleService = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+
+        await attributeModuleService.restoreAttributeValues(ids)
+    },
+)

package/src/workflows/attribute-value/steps/index.ts

@@ -0,0 +1,3 @@
+export * from './create-attribute-value'
+export * from './validate-attribute-value'
+export * from './delete-attribute-value'

package/src/workflows/attribute-value/steps/validate-attribute-value.ts

@@ -0,0 +1,95 @@
+import {
+  ContainerRegistrationKeys,
+  MedusaError,
+  MedusaErrorTypes,
+} from "@medusajs/framework/utils";
+import { StepResponse, createStep } from "@medusajs/framework/workflows-sdk";
+
+import { CreateProductAttributeValueDTO } from "../../../modules/attribute/types";
+import attributeValueProductLink from "../../../links/attribute-value-product";
+
+export const validateAttributeValueStepId = "validate-attribute-value";
+
+export const validateAttributeValueStep = createStep(
+  validateAttributeValueStepId,
+  async (input: CreateProductAttributeValueDTO, { container }) => {
+    const query = container.resolve(ContainerRegistrationKeys.QUERY);
+
+    const {
+      data: [attribute],
+    } = await query.graph({
+      entity: "attribute",
+      fields: ["product_categories.id", "possible_values.value"],
+      filters: {
+        id: input.attribute_id,
+      },
+    });
+
+    const allowedValues = attribute.possible_values?.map(
+      (posVal) => posVal.value
+    );
+
+    if (allowedValues?.length && !allowedValues.includes(input.value)) {
+      throw new MedusaError(
+        MedusaErrorTypes.INVALID_DATA,
+        `Attribute ${input.attribute_id} doesn't define ${input.value} as a possible_value`
+      );
+    }
+
+    const attributeCategoryIds = attribute.product_categories.map(
+      (cat) => cat.id
+    );
+
+    // If all attributes are global, we don't enforce for product.categories to include the attribute.product_categories, since there are none
+    if (attributeCategoryIds.length) {
+      const {
+        data: [product],
+      } = await query.graph({
+        entity: "product",
+        fields: ["categories.id"],
+        filters: {
+          id: input.product_id,
+        },
+      });
+
+      const productCategoryIds = product.categories?.map((cat) => cat.id);
+      if (
+        !productCategoryIds?.some((prodCatId) =>
+          attributeCategoryIds.includes(prodCatId)
+        )
+      ) {
+        throw new MedusaError(
+          MedusaErrorTypes.INVALID_DATA,
+          `Product ${input.product_id} isn't linked to any category from the requested attributes.`
+        );
+      }
+    }
+
+    const { data: attributeValuesProduct } = await query.graph({
+      entity: attributeValueProductLink.entryPoint,
+      fields: ["attribute_value.value", "attribute_value.attribute_id"],
+      filters: {
+        product_id: input.product_id,
+      },
+    });
+
+    const attributeValues = attributeValuesProduct.map(
+      (element) => element.attribute_value
+    );
+
+    if (
+      attributeValues.some(
+        (value) =>
+          value.attribute_id === input.attribute_id &&
+          value.value === input.value
+      )
+    ) {
+      throw new MedusaError(
+        MedusaErrorTypes.DUPLICATE_ERROR,
+        `Attribute value ${input.value} for attribute ${input.attribute_id} already exists for product ${input.product_id}`
+      );
+    }
+
+    return new StepResponse();
+  }
+);

package/src/workflows/attribute-value/workflow/create-attribute-value.ts

@@ -0,0 +1,36 @@
+import { WorkflowResponse, createWorkflow, transform } from "@medusajs/framework/workflows-sdk"
+import { createAttributeValueStep, validateAttributeValueStep } from "../steps"
+
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute"
+import { CreateProductAttributeValueDTO } from "../../../modules/attribute/types"
+import { Modules } from "@medusajs/framework/utils"
+import { createRemoteLinkStep, } from "@medusajs/medusa/core-flows"
+
+export const createAttributeValueWorkflowId = 'create-attribute-value'
+
+export const createAttributeValueWorkflow = createWorkflow(
+    createAttributeValueWorkflowId,
+    (input: CreateProductAttributeValueDTO) => {
+        const attributeValueWithoutExternalRelations = transform({ input }, ({ input }) => {
+            const { product_id, ...attributeValue } = input
+            return attributeValue
+        })
+ 
+        validateAttributeValueStep(input)
+        
+        const attributeValue = createAttributeValueStep(attributeValueWithoutExternalRelations)
+
+        const link = transform({ input, attributeValue }, ({ input, attributeValue }) => ([{
+            [ATTRIBUTE_MODULE]: {
+                attribute_value_id: attributeValue.id,
+            },
+            [Modules.PRODUCT]: {
+                product_id: input.product_id
+            }
+        }]))
+        
+        createRemoteLinkStep(link)
+        
+        return new WorkflowResponse(attributeValue)
+    }
+)

package/src/workflows/attribute-value/workflow/delete-attribute-value.ts

@@ -0,0 +1,46 @@
+import { WorkflowResponse, createWorkflow, transform } from "@medusajs/framework/workflows-sdk"
+import { dismissRemoteLinkStep, useQueryGraphStep } from "@medusajs/medusa/core-flows"
+
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute"
+import { Modules } from "@medusajs/framework/utils"
+import attributeValueProduct from "../../../links/attribute-value-product"
+import { deleteAttributeValueStep } from "../steps"
+
+export const deleteAttributeValueWorkflowId = 'delete-attribute-value'
+
+export type DeleteAttributeValueWorkflowInput = string | string[]
+
+export const deleteAttributeValueWorkflow = createWorkflow(
+    deleteAttributeValueWorkflowId,
+    (input: DeleteAttributeValueWorkflowInput) => {
+        const normalizedInput = transform({ input }, ({ input }) => 
+            Array.isArray(input) ? input : [input]
+        )
+
+        const attributeValueProductQuery = useQueryGraphStep({
+            entity: attributeValueProduct.entryPoint,
+            fields: ['product_id', 'attribute_value_id'],
+            filters: {
+                attribute_value_id: normalizedInput
+            }
+        })
+
+        const deleted = deleteAttributeValueStep(normalizedInput)
+
+        const links = transform({ attributeValueProductQuery }, ({ attributeValueProductQuery }) => {
+            const { data } = attributeValueProductQuery;
+            return data.map(element => ({
+                [ATTRIBUTE_MODULE]: {
+                    attribute_value_id: element.attribute_value_id,
+                },
+                [Modules.PRODUCT]: {
+                    product_id: element.product_id
+                }
+            }))
+        })
+         
+        dismissRemoteLinkStep(links)
+        
+        return new WorkflowResponse(deleted)
+    } 
+)

package/src/workflows/attribute-value/workflow/index.ts

@@ -0,0 +1,2 @@
+export * from './create-attribute-value'
+export * from './delete-attribute-value'

package/src/workflows/attribute_possible_value/index.ts

@@ -0,0 +1,2 @@
+export * from './steps'
+export * from './workflows'

package/src/workflows/attribute_possible_value/steps/index.ts

@@ -0,0 +1 @@
+export * from './update-attribute-possible-value'

package/src/workflows/attribute_possible_value/steps/update-attribute-possible-value.ts

@@ -0,0 +1,25 @@
+import { createStep, StepResponse } from "@medusajs/framework/workflows-sdk"
+import { UpdateAttributeValueDTO } from "../../../modules/attribute/types"
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute"
+import AttributeModuleService from "../../../modules/attribute/service"
+
+export const updateAttributePossibleValueStepId = 'update-attribute-possible-value'
+
+type StepInput = UpdateAttributeValueDTO
+
+export const updateAttributePossibleValueStep = createStep(
+    updateAttributePossibleValueStepId,
+    async (payload: StepInput, { container }) => {
+        const attributeModuleService = container.resolve(ATTRIBUTE_MODULE) as AttributeModuleService
+        const updated = await attributeModuleService.updateAttributePossibleValues(payload)
+        return new StepResponse(updated, payload.id)
+    },
+    async (id: string | undefined, { container }) => {
+        if (!id) {
+            return
+        }
+
+        const attributeModuleService = container.resolve(ATTRIBUTE_MODULE) as AttributeModuleService
+        await attributeModuleService.deleteAttributePossibleValues(id)
+    }
+)

package/src/workflows/attribute_possible_value/workflows/index.ts

@@ -0,0 +1 @@
+export * from './update-attribute-possible-value'