feat(*): shipping options update API (#6987)

**What**
- Update the `updateShippingOptions` module service API to follow the newest convention
- Add upsert support for shipping options
- update shipping options workflow
- update shipping options api end point and validation
- update shipping options all integration tests

FIXES CORE-1926

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

@@ -1,43 +0,0 @@
-import { createStep, StepResponse } from "@medusajs/workflows-sdk"
-import {
-  FulfillmentWorkflow,
-  IFulfillmentModuleService,
-  ShippingOptionDTO,
-} from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/modules-sdk"
-
-type StepInput = Omit<
-  FulfillmentWorkflow.CreateShippingOptionsWorkflowInput,
-  "prices"
->[]
-
-export const createShippingOptionsStepId = "create-shipping-options-step"
-export const createShippingOptionsStep = createStep(
-  createShippingOptionsStepId,
-  async (input: StepInput, { container }) => {
-    if (!input?.length) {
-      return new StepResponse([], [])
-    }
-
-    const fulfillmentService = container.resolve<IFulfillmentModuleService>(
-      ModuleRegistrationName.FULFILLMENT
-    )
-    const createdShippingOptions: ShippingOptionDTO[] =
-      await fulfillmentService.createShippingOptions(input)
-
-    const shippingOptionIds = createdShippingOptions.map((s) => s.id)
-
-    return new StepResponse(createdShippingOptions, shippingOptionIds)
-  },
-  async (shippingOptionIds, { container }) => {
-    if (!shippingOptionIds?.length) {
-      return
-    }
-
-    const fulfillmentService = container.resolve<IFulfillmentModuleService>(
-      ModuleRegistrationName.FULFILLMENT
-    )
-
-    await fulfillmentService.deleteShippingOptions(shippingOptionIds)
-  }
-)

packages/core-flows/src/fulfillment/steps/index.ts

@@ -2,6 +2,6 @@ export * from "./add-rules-to-fulfillment-shipping-option"
 export * from "./add-shipping-options-prices"
 export * from "./create-fulfillment-set"
 export * from "./create-service-zones"
-export * from "./create-shipping-options"
+export * from "./upsert-shipping-options"
 export * from "./delete-service-zones"
 export * from "./remove-rules-from-fulfillment-shipping-option"

packages/core-flows/src/fulfillment/steps/upsert-shipping-options.ts

@@ -0,0 +1,100 @@
+import { createStep, StepResponse } from "@medusajs/workflows-sdk"
+import {
+  FulfillmentWorkflow,
+  IFulfillmentModuleService,
+  ShippingOptionDTO,
+} from "@medusajs/types"
+import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+import {
+  arrayDifference,
+  getSelectsAndRelationsFromObjectArray,
+} from "@medusajs/utils"
+import { UpsertShippingOptionDTO } from "@medusajs/types/src"
+
+type StepInput = Omit<
+  | FulfillmentWorkflow.CreateShippingOptionsWorkflowInput
+  | FulfillmentWorkflow.UpdateShippingOptionsWorkflowInput,
+  "prices"
+>[]
+
+export const upsertShippingOptionsStepId = "create-shipping-options-step"
+export const upsertShippingOptionsStep = createStep(
+  upsertShippingOptionsStepId,
+  async (input: StepInput, { container }) => {
+    if (!input?.length) {
+      return new StepResponse([], {})
+    }
+
+    const fulfillmentService = container.resolve<IFulfillmentModuleService>(
+      ModuleRegistrationName.FULFILLMENT
+    )
+
+    const toUpdate: FulfillmentWorkflow.UpdateShippingOptionsWorkflowInput[] =
+      []
+
+    ;(
+      input as FulfillmentWorkflow.UpdateShippingOptionsWorkflowInput[]
+    ).forEach((inputItem) => {
+      if (!!inputItem.id) {
+        return toUpdate.push(inputItem)
+      }
+      return
+    })
+
+    let toUpdatePreviousData: ShippingOptionDTO[] = []
+
+    if (toUpdate.length) {
+      const { selects, relations } =
+        getSelectsAndRelationsFromObjectArray(toUpdate)
+      toUpdatePreviousData = await fulfillmentService.listShippingOptions(
+        {
+          id: toUpdate.map((s) => s.id),
+        },
+        {
+          select: selects,
+          relations,
+        }
+      )
+    }
+
+    const upsertedShippingOptions: ShippingOptionDTO[] =
+      await fulfillmentService.upsertShippingOptions(
+        input as UpsertShippingOptionDTO[]
+      )
+
+    const upsertedShippingOptionIds = upsertedShippingOptions.map((s) => s.id)
+
+    const updatedIds = toUpdate.map((s) => s.id)
+    return new StepResponse(upsertedShippingOptions, {
+      updatedPreviousData: toUpdatePreviousData,
+      createdIds: arrayDifference(
+        upsertedShippingOptionIds,
+        updatedIds
+      ) as string[],
+    })
+  },
+  async (shippingOptionIds: any, { container }) => {
+    if (
+      !shippingOptionIds?.updatedPreviousData?.length &&
+      !shippingOptionIds?.createdIds?.length
+    ) {
+      return
+    }
+
+    const fulfillmentService = container.resolve<IFulfillmentModuleService>(
+      ModuleRegistrationName.FULFILLMENT
+    )
+
+    if (shippingOptionIds.updatedPreviousData.length) {
+      await fulfillmentService.upsertShippingOptions(
+        shippingOptionIds.updatedPreviousData
+      )
+    }
+
+    if (shippingOptionIds.createdIds.length) {
+      await fulfillmentService.deleteShippingOptions(
+        shippingOptionIds.createdIds
+      )
+    }
+  }
+)

packages/core-flows/src/fulfillment/workflows/create-shipping-options.ts

@@ -6,7 +6,7 @@ import {
 } from "@medusajs/workflows-sdk"
 import {
   createShippingOptionsPriceSetsStep,
-  createShippingOptionsStep,
+  upsertShippingOptionsStep,
 } from "../steps"
 import { setShippingOptionsPriceSetsStep } from "../steps/set-shipping-options-price-sets"
 import { createPricingRuleTypesStep } from "../../pricing"
@@ -34,7 +34,7 @@ export const createShippingOptionsWorkflow = createWorkflow(
       }
     })
 
-    const createdShippingOptions = createShippingOptionsStep(
+    const createdShippingOptions = upsertShippingOptionsStep(
       data.shippingOptions
     )
 

packages/core-flows/src/fulfillment/workflows/index.ts

@@ -1,6 +1,7 @@
 export * from "./add-rules-to-fulfillment-shipping-option"
 export * from "./create-service-zones"
 export * from "./create-shipping-options"
+export * from "./update-shipping-options"
 export * from "./delete-service-zones"
 export * from "./remove-rules-from-fulfillment-shipping-option"
 export * from "./update-service-zones"

packages/core-flows/src/fulfillment/workflows/update-shipping-options.ts

@@ -0,0 +1,92 @@
+import { FulfillmentWorkflow } from "@medusajs/types"
+import {
+  createWorkflow,
+  transform,
+  WorkflowData,
+} from "@medusajs/workflows-sdk"
+import { upsertShippingOptionsStep } from "../steps"
+
+export const updateShippingOptionsWorkflowId =
+  "update-shipping-options-workflow"
+export const updateShippingOptionsWorkflow = createWorkflow(
+  updateShippingOptionsWorkflowId,
+  (
+    input: WorkflowData<
+      FulfillmentWorkflow.UpdateShippingOptionsWorkflowInput[]
+    >
+  ): WorkflowData<FulfillmentWorkflow.UpdateShippingOptionsWorkflowOutput> => {
+    const data = transform(input, (data) => {
+      const shippingOptionsIndexToPrices = data.map((option, index) => {
+        return {
+          shipping_option_index: index,
+          prices: option.prices,
+        }
+      })
+
+      return {
+        shippingOptions: data,
+        shippingOptionsIndexToPrices,
+      }
+    })
+
+    const updatedShippingOptions = upsertShippingOptionsStep(
+      data.shippingOptions
+    )
+
+    /*const normalizedShippingOptionsPrices = transform(
+      {
+        shippingOptions: updatedShippingOptions,
+        shippingOptionsIndexToPrices: data.shippingOptionsIndexToPrices,
+      },
+      (data) => {
+        const ruleTypes = new Set<Partial<RuleTypeDTO>>()
+        const shippingOptionsPrices = data.shippingOptionsIndexToPrices.map(
+          ({ shipping_option_index, prices }) => {
+            prices?.forEach((price) => {
+              if ("region_id" in price) {
+                ruleTypes.add({
+                  name: "region_id",
+                  rule_attribute: "region_id",
+                })
+              }
+            })
+
+            return {
+              id: data.shippingOptions[shipping_option_index].id,
+              prices,
+            }
+          }
+        )
+
+        return {
+          shippingOptionsPrices,
+          ruleTypes: Array.from(ruleTypes) as UpdateRuleTypeDTO[],
+        }
+      }
+    )*/
+
+    /*updatePricingRuleTypesStep(normalizedShippingOptionsPrices.ruleTypes)*/
+
+    /*const shippingOptionsPriceSetsLinkData = updateShippingOptionsPriceSetsStep(
+      normalizedShippingOptionsPrices.shippingOptionsPrices
+    )
+
+    const normalizedLinkData = transform(
+      {
+        shippingOptionsPriceSetsLinkData,
+      },
+      (data) => {
+        return data.shippingOptionsPriceSetsLinkData.map((item) => {
+          return {
+            id: item.id,
+            price_sets: [item.priceSetId],
+          }
+        })
+      }
+    )*/
+
+    /*setShippingOptionsPriceSetsStep(normalizedLinkData)*/
+
+    return updatedShippingOptions
+  }
+)