feat(medusa, core-flows, types): Allow to update the rules from a shipping options (#7175)

**What**
Add support for the following operations
- update rules from the update shipping options end point
- update rules from the batch update end point

Also added some improvements, that can be revisited later
- Add a rule value normalizer, jsonb will transform the input value to a [primitive](https://www.postgresql.org/docs/current/datatype-json.html#JSON-TYPE-MAPPING-TABLE) when possible meaning that passing `"true"` will result in storing `true` and not the string. The normalizer takes care of that

packages/core-flows/src/fulfillment/steps/create-shipping-option-rules.ts

@@ -3,7 +3,7 @@ import {
   AddFulfillmentShippingOptionRulesWorkflowDTO,
   IFulfillmentModuleService,
 } from "@medusajs/types"
-import { StepResponse, createStep } from "@medusajs/workflows-sdk"
+import { createStep, StepResponse } from "@medusajs/workflows-sdk"
 
 export const createShippingOptionRulesStepId = "create-shipping-option-rules"
 export const createShippingOptionRulesStep = createStep(
@@ -18,12 +18,12 @@ export const createShippingOptionRulesStep = createStep(
       ModuleRegistrationName.FULFILLMENT
     )
 
-    const createdPromotionRules =
+    const createdShippingOptionRules =
       await fulfillmentModule.createShippingOptionRules(data)
 
     return new StepResponse(
-      createdPromotionRules,
-      createdPromotionRules.map((pr) => pr.id)
+      createdShippingOptionRules,
+      createdShippingOptionRules.map((pr) => pr.id)
     )
   },
   async (ruleIds, { container }) => {

packages/core-flows/src/fulfillment/steps/delete-shipping-option-rules.ts

@@ -4,7 +4,7 @@ import {
   RemoveFulfillmentShippingOptionRulesWorkflowDTO,
   RuleOperatorType,
 } from "@medusajs/types"
-import { StepResponse, createStep } from "@medusajs/workflows-sdk"
+import { createStep, StepResponse } from "@medusajs/workflows-sdk"
 
 export const deleteShippingOptionRulesStepId = "delete-shipping-option-rules"
 export const deleteShippingOptionRulesStep = createStep(
@@ -13,6 +13,10 @@ export const deleteShippingOptionRulesStep = createStep(
     input: RemoveFulfillmentShippingOptionRulesWorkflowDTO,
     { container }
   ) => {
+    if (!input.ids?.length) {
+      return
+    }
+
     const { ids } = input
 
     const fulfillmentModule = container.resolve<IFulfillmentModuleService>(
@@ -39,6 +43,7 @@ export const deleteShippingOptionRulesStep = createStep(
 
     await fulfillmentModule.createShippingOptionRules(
       shippingOptionRules.map((rule) => ({
+        id: rule.id,
         attribute: rule.attribute,
         operator: rule.operator as RuleOperatorType,
         value: rule.value as unknown as string | string[],

packages/core-flows/src/fulfillment/steps/update-shipping-option-rules.ts

@@ -0,0 +1,51 @@
+import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+import {
+  IFulfillmentModuleService,
+  UpdateFulfillmentShippingOptionRulesWorkflowDTO,
+  UpdateShippingOptionRuleDTO,
+} from "@medusajs/types"
+import { createStep, StepResponse } from "@medusajs/workflows-sdk"
+
+export const updateShippingOptionRulesStepId = "update-shipping-option-rules"
+export const updateShippingOptionRulesStep = createStep(
+  updateShippingOptionRulesStepId,
+  async (
+    input: UpdateFulfillmentShippingOptionRulesWorkflowDTO,
+    { container }
+  ) => {
+    if (!input.data?.length) {
+      return
+    }
+
+    const { data } = input
+
+    const fulfillmentModule = container.resolve<IFulfillmentModuleService>(
+      ModuleRegistrationName.FULFILLMENT
+    )
+
+    const ids = data.map((d) => d.id)
+    const shippingOptionRules = await fulfillmentModule.listShippingOptionRules(
+      { id: ids },
+      { select: ["id", "attribute", "operator", "value", "shipping_option_id"] }
+    )
+
+    const updatedPromotionRules =
+      await fulfillmentModule.updateShippingOptionRules(data)
+
+    return new StepResponse(
+      updatedPromotionRules,
+      shippingOptionRules as unknown as UpdateShippingOptionRuleDTO[]
+    )
+  },
+  async (previousRulesData, { container }) => {
+    if (!previousRulesData?.length) {
+      return
+    }
+
+    const fulfillmentModule = container.resolve<IFulfillmentModuleService>(
+      ModuleRegistrationName.FULFILLMENT
+    )
+
+    await fulfillmentModule.updateShippingOptionRules(previousRulesData)
+  }
+)

packages/core-flows/src/fulfillment/workflows/batch-shipping-option-rules.ts

@@ -6,15 +6,16 @@ import {
   UpdateShippingOptionRuleDTO,
 } from "@medusajs/types"
 import {
-  WorkflowData,
   createWorkflow,
   parallelize,
   transform,
+  WorkflowData,
 } from "@medusajs/workflows-sdk"
 import {
   createShippingOptionRulesStep,
   deleteShippingOptionRulesStep,
 } from "../steps"
+import { updateShippingOptionRulesStep } from "../steps/update-shipping-option-rules"
 
 export const batchShippingOptionRulesWorkflowId = "batch-shipping-option-rules"
 export const batchShippingOptionRulesWorkflow = createWorkflow(
@@ -27,25 +28,21 @@ export const batchShippingOptionRulesWorkflow = createWorkflow(
       >
     >
   ): WorkflowData<BatchWorkflowOutput<ShippingOptionRuleDTO>> => {
-    const createInput = transform({ input }, (data) => ({
-      data: data.input.create ?? [],
-    }))
+    const actionInputs = transform({ input }, (data) => {
+      const { create, update, delete: del } = data.input
+      return {
+        createInput: { data: create ?? [] },
+        updateInput: { data: update ?? [] },
+        deleteInput: { ids: del ?? [] },
+      }
+    })
 
-    const updateInput = transform({ input }, (data) => ({
-      data: data.input.update ?? [],
-    }))
-
-    const deleteInput = transform({ input }, (data) => ({
-      ids: data.input.delete ?? [],
-    }))
-
-    // TODO: Currently we don't support edits, add support for this.
-    // We just call the steps directly here since there are no independent workflows, switch to CRUD workflows if they get added.
-    const [created, deleted] = parallelize(
-      createShippingOptionRulesStep(createInput),
-      deleteShippingOptionRulesStep(deleteInput)
+    const [created, updated, deleted] = parallelize(
+      createShippingOptionRulesStep(actionInputs.createInput),
+      updateShippingOptionRulesStep(actionInputs.updateInput),
+      deleteShippingOptionRulesStep(actionInputs.deleteInput)
     )
 
-    return transform({ created, deleted }, (data) => ({ ...data, updated: [] }))
+    return transform({ created, deleted, updated }, (data) => data)
   }
 )

packages/fulfillment/src/services/fulfillment-module-service.ts

@@ -14,17 +14,17 @@ import {
   UpdateServiceZoneDTO,
 } from "@medusajs/types"
 import {
+  arrayDifference,
   EmitEvents,
   FulfillmentUtils,
+  getSetDifference,
   InjectManager,
   InjectTransactionManager,
+  isString,
   MedusaContext,
   MedusaError,
   Modules,
   ModulesSdkUtils,
-  arrayDifference,
-  getSetDifference,
-  isString,
   promiseAll,
 } from "@medusajs/utils"
 import {
@@ -38,9 +38,9 @@ import {
   ShippingOptionType,
   ShippingProfile,
 } from "@models"
-import { isContextValid, validateRules } from "@utils"
-import { entityNameToLinkableKeysMap, joinerConfig } from "../joiner-config"
-import { UpdateShippingOptionsInput } from "../types/service"
+import {isContextValid, validateAndNormalizeRules} from "@utils"
+import {entityNameToLinkableKeysMap, joinerConfig} from "../joiner-config"
+import {UpdateShippingOptionsInput} from "../types/service"
 import FulfillmentProviderService from "./fulfillment-provider"
 
 const generateMethodForModels = [
@@ -343,7 +343,7 @@ export default class FulfillmentModuleService<
       | FulfillmentTypes.CreateServiceZoneDTO,
     @MedusaContext() sharedContext: Context = {}
   ): Promise<TServiceZoneEntity | TServiceZoneEntity[]> {
-    let data_ = Array.isArray(data) ? data : [data]
+    const data_ = Array.isArray(data) ? data : [data]
 
     if (!data_.length) {
       return []
@@ -402,7 +402,7 @@ export default class FulfillmentModuleService<
       | FulfillmentTypes.CreateShippingOptionDTO,
     @MedusaContext() sharedContext: Context = {}
   ): Promise<TShippingOptionEntity | TShippingOptionEntity[]> {
-    let data_ = Array.isArray(data) ? data : [data]
+    const data_ = Array.isArray(data) ? data : [data]
 
     if (!data_.length) {
       return []
@@ -410,7 +410,7 @@ export default class FulfillmentModuleService<
 
     const rules = data_.flatMap((d) => d.rules).filter(Boolean)
     if (rules.length) {
-      validateRules(rules as Record<string, unknown>[])
+      validateAndNormalizeRules(rules as Record<string, unknown>[])
     }
 
     const createdShippingOptions = await this.shippingOptionService_.create(
@@ -555,7 +555,7 @@ export default class FulfillmentModuleService<
       return []
     }
 
-    validateRules(data_ as unknown as Record<string, unknown>[])
+    validateAndNormalizeRules(data_ as unknown as Record<string, unknown>[])
 
     const createdShippingOptionRules =
       await this.shippingOptionRuleService_.create(data_, sharedContext)
@@ -1175,7 +1175,7 @@ export default class FulfillmentModuleService<
         })
         .filter(Boolean)
 
-      validateRules(newRules as Record<string, unknown>[])
+      validateAndNormalizeRules(newRules as Record<string, unknown>[])
 
       shippingOption.rules = shippingOption.rules.map((rule) => {
         if (!("id" in rule)) {
@@ -1382,7 +1382,7 @@ export default class FulfillmentModuleService<
       return []
     }
 
-    validateRules(data_ as unknown as Record<string, unknown>[])
+    validateAndNormalizeRules(data_ as unknown as Record<string, unknown>[])
 
     const updatedShippingOptionRules =
       await this.shippingOptionRuleService_.update(data_, sharedContext)

packages/fulfillment/src/utils/utils.ts

@@ -1,4 +1,5 @@
 import {
+  isObject,
   isString,
   MedusaError,
   pickValueFromObject,
@@ -97,21 +98,21 @@ export function validateRule(rule: Record<string, unknown>): boolean {
   if (!rule.attribute || !rule.operator || !rule.value) {
     throw new MedusaError(
       MedusaError.Types.INVALID_DATA,
-      "Rule must have an attribute, an operator and contextValue value"
+      "Rule must have an attribute, an operator and a value"
     )
   }
 
   if (!isString(rule.attribute)) {
     throw new MedusaError(
       MedusaError.Types.INVALID_DATA,
-      "Rule attribute must be contextValue string"
+      "Rule attribute must be a string"
     )
   }
 
   if (!isString(rule.operator)) {
     throw new MedusaError(
       MedusaError.Types.INVALID_DATA,
-      "Rule operator must be contextValue string"
+      "Rule operator must be a string"
     )
   }
 
@@ -132,10 +133,10 @@ export function validateRule(rule: Record<string, unknown>): boolean {
       )
     }
   } else {
-    if (!isString(rule.value)) {
+    if (Array.isArray(rule.value) || isObject(rule.value)) {
       throw new MedusaError(
         MedusaError.Types.INVALID_DATA,
-        `Rule value must be a string for the selected operator ${rule.operator}`
+        `Rule value must be a string, bool, number value for the selected operator ${rule.operator}`
       )
     }
   }
@@ -143,6 +144,24 @@ export function validateRule(rule: Record<string, unknown>): boolean {
   return true
 }
 
+export function normalizeRulesValue<T extends Partial<Rule>>(rules: T[]): void {
+  rules.forEach((rule) => {
+    /**
+     * If a string is provided, then we don't want jsonb to convert to the primitive value based on the RFC
+     */
+    if (rule.value === "true" || rule.value === "false") {
+      rule.value = rule.value === "true" ? '"true"' : '"false"'
+    }
+
+    return rule
+  })
+}
+
+export function validateAndNormalizeRules<T extends Partial<Rule>>(rules: T[]) {
+  rules.forEach(validateRule)
+  normalizeRulesValue(rules)
+}
+
 /**
  * Validate contextValue set of rules
  * @param rules

packages/medusa/src/api-v2/admin/shipping-options/validators.ts

@@ -126,5 +126,6 @@ export const AdminUpdateShippingOption = z
     )
       .array()
       .optional(),
+    rules: AdminUpdateShippingOptionRule.or(AdminCreateShippingOptionRule).array().optional(),
   })
   .strict()

packages/types/src/fulfillment/workflows.ts

@@ -1,4 +1,7 @@
-import { CreateShippingOptionRuleDTO } from "./mutations"
+import {
+  CreateShippingOptionRuleDTO,
+  UpdateShippingOptionRuleDTO,
+} from "./mutations"
 
 export type AddFulfillmentShippingOptionRulesWorkflowDTO = {
   data: CreateShippingOptionRuleDTO[]
@@ -7,3 +10,7 @@ export type AddFulfillmentShippingOptionRulesWorkflowDTO = {
 export type RemoveFulfillmentShippingOptionRulesWorkflowDTO = {
   ids: string[]
 }
+
+export type UpdateFulfillmentShippingOptionRulesWorkflowDTO = {
+  data: UpdateShippingOptionRuleDTO[]
+}