From fff1b3ef9c343a9374b2db07f52623334be9b54b Mon Sep 17 00:00:00 2001
From: Adrien de Peretti <adrien.deperetti@gmail.com>
Date: Fri, 24 May 2024 14:55:05 +0200
Subject: [PATCH] chore(medusa, workflows-sdk): Workflow default to throw the
 first error (#7442)

**What**
Currently when a workflow fail it will throw an error which contains the messages of all error thrown durring the workflow lifetime. Therefore, in our cases we are always preventing workflow to throw and grab the first error that we then re throw.
This pr eliminate that need by throwing back the first error among the error thrown by a workflow as it is the main case. In case someone need a special handling they can still set the option throwOnError to false and handle the error the way they need
---
 .../core/workflows-sdk/src/helper/empty-handler.ts |  1 -
 packages/core/workflows-sdk/src/helper/index.ts    |  1 -
 .../core/workflows-sdk/src/helper/merge-data.ts    |  1 +
 packages/core/workflows-sdk/src/helper/pipe.ts     |  5 +++++
 .../workflows-sdk/src/helper/workflow-export.ts    |  9 +++++----
 .../src/api/admin/api-keys/[id]/revoke/route.ts    |  7 +------
 .../medusa/src/api/admin/api-keys/[id]/route.ts    | 14 ++------------
 .../admin/api-keys/[id]/sales-channels/route.ts    |  7 +------
 packages/medusa/src/api/admin/api-keys/route.ts    | 11 +++--------
 .../api/admin/campaigns/[id]/promotions/route.ts   | 13 +++----------
 .../medusa/src/api/admin/campaigns/[id]/route.ts   | 14 ++------------
 packages/medusa/src/api/admin/campaigns/route.ts   | 13 ++++---------
 .../api/admin/collections/[id]/products/route.ts   |  7 +------
 .../medusa/src/api/admin/collections/[id]/route.ts | 14 ++------------
 packages/medusa/src/api/admin/collections/route.ts |  7 +------
 .../admin/customer-groups/[id]/customers/route.ts  |  7 +------
 .../src/api/admin/customer-groups/[id]/route.ts    | 14 ++------------
 .../medusa/src/api/admin/customer-groups/route.ts  |  7 +------
 .../customers/[id]/addresses/[address_id]/route.ts | 14 ++------------
 .../api/admin/customers/[id]/addresses/route.ts    |  7 +------
 .../medusa/src/api/admin/customers/[id]/route.ts   | 14 ++------------
 packages/medusa/src/api/admin/customers/route.ts   |  7 +------
 .../medusa/src/api/admin/draft-orders/route.ts     |  7 +------
 .../src/api/admin/fulfillment-sets/[id]/route.ts   |  7 +------
 .../[id]/service-zones/[zone_id]/route.ts          | 14 ++------------
 .../fulfillment-sets/[id]/service-zones/route.ts   |  7 +------
 .../api/admin/fulfillments/[id]/cancel/route.ts    |  7 +------
 .../api/admin/fulfillments/[id]/shipment/route.ts  |  7 +------
 .../medusa/src/api/admin/fulfillments/route.ts     |  7 +------
 .../[id]/location-levels/[location_id]/route.ts    |  7 +------
 .../[id]/location-levels/batch/route.ts            |  7 +------
 .../inventory-items/[id]/location-levels/route.ts  |  7 +------
 .../src/api/admin/inventory-items/[id]/route.ts    |  7 +------
 .../medusa/src/api/admin/invites/[id]/route.ts     |  7 +------
 packages/medusa/src/api/admin/invites/route.ts     |  7 +------
 .../src/api/admin/orders/[id]/archive/route.ts     |  7 +------
 .../src/api/admin/orders/[id]/complete/route.ts    |  7 +------
 .../src/api/admin/payments/[id]/capture/route.ts   |  7 +------
 .../src/api/admin/payments/[id]/refund/route.ts    |  7 +------
 .../admin/price-lists/[id]/prices/batch/route.ts   |  7 +------
 .../api/admin/price-lists/[id]/products/route.ts   |  7 +------
 .../medusa/src/api/admin/price-lists/[id]/route.ts | 14 ++------------
 packages/medusa/src/api/admin/price-lists/route.ts |  7 +------
 .../src/api/admin/pricing/rule-types/[id]/route.ts | 14 ++------------
 .../src/api/admin/pricing/rule-types/route.ts      |  7 +------
 .../product-categories/[id]/products/route.ts      |  7 +------
 .../src/api/admin/product-categories/[id]/route.ts |  7 +------
 .../src/api/admin/product-categories/route.ts      | 13 +++----------
 .../src/api/admin/product-types/[id]/route.ts      | 14 ++------------
 .../medusa/src/api/admin/product-types/route.ts    |  7 +------
 .../products/[id]/options/[option_id]/route.ts     | 14 ++------------
 .../src/api/admin/products/[id]/options/route.ts   |  7 +------
 .../medusa/src/api/admin/products/[id]/route.ts    | 14 ++------------
 .../products/[id]/variants/[variant_id]/route.ts   | 14 ++------------
 .../admin/products/[id]/variants/batch/route.ts    |  7 +------
 .../src/api/admin/products/[id]/variants/route.ts  |  7 +------
 .../medusa/src/api/admin/products/batch/route.ts   |  7 +------
 packages/medusa/src/api/admin/products/route.ts    |  7 +------
 .../admin/promotions/[id]/buy-rules/batch/route.ts |  7 +------
 .../medusa/src/api/admin/promotions/[id]/route.ts  | 14 ++------------
 .../api/admin/promotions/[id]/rules/batch/route.ts |  7 +------
 .../promotions/[id]/target-rules/batch/route.ts    |  7 +------
 packages/medusa/src/api/admin/promotions/route.ts  |  7 +------
 .../medusa/src/api/admin/regions/[id]/route.ts     | 14 ++------------
 packages/medusa/src/api/admin/regions/route.ts     |  7 +------
 .../src/api/admin/reservations/[id]/route.ts       | 14 ++------------
 .../medusa/src/api/admin/reservations/route.ts     |  7 +------
 .../src/api/admin/return-reasons/[id]/route.ts     |  6 +-----
 .../medusa/src/api/admin/return-reasons/route.ts   |  6 +-----
 packages/medusa/src/api/admin/returns/route.ts     | 11 +++--------
 .../admin/sales-channels/[id]/products/route.ts    |  7 +------
 .../src/api/admin/sales-channels/[id]/route.ts     | 14 ++------------
 .../medusa/src/api/admin/sales-channels/route.ts   |  7 +------
 .../src/api/admin/shipping-options/[id]/route.ts   | 14 ++------------
 .../shipping-options/[id]/rules/batch/route.ts     |  9 +--------
 .../medusa/src/api/admin/shipping-options/route.ts |  7 +------
 .../src/api/admin/shipping-profiles/[id]/route.ts  |  7 +------
 .../src/api/admin/shipping-profiles/route.ts       |  9 +--------
 .../stock-locations/[id]/fulfillment-sets/route.ts |  7 +------
 .../src/api/admin/stock-locations/[id]/route.ts    |  7 +------
 .../stock-locations/[id]/sales-channels/route.ts   |  7 +------
 packages/medusa/src/api/admin/stores/[id]/route.ts |  7 +------
 .../medusa/src/api/admin/tax-rates/[id]/route.ts   | 14 ++------------
 .../admin/tax-rates/[id]/rules/[rule_id]/route.ts  |  7 +------
 .../src/api/admin/tax-rates/[id]/rules/route.ts    |  7 +------
 packages/medusa/src/api/admin/tax-rates/route.ts   |  7 +------
 .../medusa/src/api/admin/tax-regions/[id]/route.ts |  7 +------
 packages/medusa/src/api/admin/tax-regions/route.ts |  7 +------
 .../medusa/src/api/admin/uploads/[id]/route.ts     |  7 +------
 packages/medusa/src/api/admin/uploads/route.ts     |  7 +------
 packages/medusa/src/api/admin/users/[id]/route.ts  |  7 +------
 packages/medusa/src/api/admin/users/route.ts       |  9 +--------
 .../[workflow_id]/run/route.ts                     |  1 -
 .../src/api/store/carts/[id]/complete/route.ts     |  2 +-
 .../store/carts/[id]/line-items/[line_id]/route.ts | 14 ++------------
 .../src/api/store/carts/[id]/line-items/route.ts   |  7 +------
 .../src/api/store/carts/[id]/promotions/route.ts   | 14 ++------------
 packages/medusa/src/api/store/carts/[id]/route.ts  |  7 +------
 .../api/store/carts/[id]/shipping-methods/route.ts |  7 +------
 .../medusa/src/api/store/carts/[id]/taxes/route.ts |  7 +------
 packages/medusa/src/api/store/carts/route.ts       |  7 +------
 .../customers/me/addresses/[address_id]/route.ts   | 14 ++------------
 .../src/api/store/customers/me/addresses/route.ts  |  7 +------
 .../medusa/src/api/store/customers/me/route.ts     |  7 +------
 packages/medusa/src/api/store/customers/route.ts   |  6 +-----
 .../[id]/payment-sessions/route.ts                 |  7 +------
 .../src/api/store/payment-collections/route.ts     |  8 +-------
 packages/medusa/src/api/store/return/route.ts      |  7 +------
 .../medusa/src/api/store/shipping-options/route.ts |  9 +--------
 109 files changed, 147 insertions(+), 773 deletions(-)
 delete mode 100644 packages/core/workflows-sdk/src/helper/empty-handler.ts

diff --git a/packages/core/workflows-sdk/src/helper/empty-handler.ts b/packages/core/workflows-sdk/src/helper/empty-handler.ts
deleted file mode 100644
index 34233673d1..0000000000
--- a/packages/core/workflows-sdk/src/helper/empty-handler.ts
+++ /dev/null
@@ -1 +0,0 @@
-export const emptyHandler: any = () => {}
diff --git a/packages/core/workflows-sdk/src/helper/index.ts b/packages/core/workflows-sdk/src/helper/index.ts
index 9f8801da04..3b5fff9e09 100644
--- a/packages/core/workflows-sdk/src/helper/index.ts
+++ b/packages/core/workflows-sdk/src/helper/index.ts
@@ -1,5 +1,4 @@
 export * from "./merge-data"
-export * from "./empty-handler"
 export * from "./pipe"
 export * from "./workflow-export"
 export * from "./type"
diff --git a/packages/core/workflows-sdk/src/helper/merge-data.ts b/packages/core/workflows-sdk/src/helper/merge-data.ts
index 134d41c240..6384bb582e 100644
--- a/packages/core/workflows-sdk/src/helper/merge-data.ts
+++ b/packages/core/workflows-sdk/src/helper/merge-data.ts
@@ -4,6 +4,7 @@ import { isObject } from "@medusajs/utils"
 /**
  * Pipe utils that merges data from an object into a new object.
  * The new object will have a target key with the merged data from the keys if specified.
+ * @deprecated
  * @param keys
  * @param target
  */
diff --git a/packages/core/workflows-sdk/src/helper/pipe.ts b/packages/core/workflows-sdk/src/helper/pipe.ts
index 38b934677b..c92cba23dc 100644
--- a/packages/core/workflows-sdk/src/helper/pipe.ts
+++ b/packages/core/workflows-sdk/src/helper/pipe.ts
@@ -66,6 +66,11 @@ export type PipelineHandler<T extends any = undefined> = (
     : T
 >
 
+/**
+ * @deprecated
+ * @param input
+ * @param functions
+ */
 export function pipe<T>(
   input: PipelineInput,
   ...functions: [...PipelineHandler[], PipelineHandler<T>]
diff --git a/packages/core/workflows-sdk/src/helper/workflow-export.ts b/packages/core/workflows-sdk/src/helper/workflow-export.ts
index 1dfbb7af71..a8cc2261ae 100644
--- a/packages/core/workflows-sdk/src/helper/workflow-export.ts
+++ b/packages/core/workflows-sdk/src/helper/workflow-export.ts
@@ -5,7 +5,7 @@ import {
   TransactionState,
 } from "@medusajs/orchestration"
 import { LoadedModule, MedusaContainer } from "@medusajs/types"
-import { MedusaContextType, isPresent } from "@medusajs/utils"
+import { isPresent, MedusaContextType } from "@medusajs/utils"
 import { EOL } from "os"
 import { ulid } from "ulid"
 import { MedusaWorkflow } from "../medusa-workflow"
@@ -87,10 +87,11 @@ function createContextualWorkflowRunner<
       failedStatus.includes(transaction.getState()) &&
       throwOnError
     ) {
-      const errorMessage = errors
+      /*const errorMessage = errors
         ?.map((err) => `${err.error?.message}${EOL}${err.error?.stack}`)
-        ?.join(`${EOL}`)
-      throw new Error(errorMessage)
+        ?.join(`${EOL}`)*/
+      const firstError = errors?.[0]?.error ?? new Error("Unknown error")
+      throw firstError
     }
 
     let result
diff --git a/packages/medusa/src/api/admin/api-keys/[id]/revoke/route.ts b/packages/medusa/src/api/admin/api-keys/[id]/revoke/route.ts
index bd40729057..6265ce2387 100644
--- a/packages/medusa/src/api/admin/api-keys/[id]/revoke/route.ts
+++ b/packages/medusa/src/api/admin/api-keys/[id]/revoke/route.ts
@@ -10,7 +10,7 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminRevokeApiKeyType>,
   res: MedusaResponse
 ) => {
-  const { errors } = await revokeApiKeysWorkflow(req.scope).run({
+  await revokeApiKeysWorkflow(req.scope).run({
     input: {
       selector: { id: req.params.id },
       revoke: {
@@ -18,13 +18,8 @@ export const POST = async (
         revoked_by: req.auth_context.actor_id,
       },
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const apiKey = await refetchApiKey(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/api-keys/[id]/route.ts b/packages/medusa/src/api/admin/api-keys/[id]/route.ts
index cd91dfee0d..d4a786fa67 100644
--- a/packages/medusa/src/api/admin/api-keys/[id]/route.ts
+++ b/packages/medusa/src/api/admin/api-keys/[id]/route.ts
@@ -27,18 +27,13 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminUpdateApiKeyType>,
   res: MedusaResponse
 ) => {
-  const { errors } = await updateApiKeysWorkflow(req.scope).run({
+  await updateApiKeysWorkflow(req.scope).run({
     input: {
       selector: { id: req.params.id },
       update: req.validatedBody,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const apiKey = await refetchApiKey(
     req.params.id,
     req.scope,
@@ -54,15 +49,10 @@ export const DELETE = async (
 ) => {
   const id = req.params.id
 
-  const { errors } = await deleteApiKeysWorkflow(req.scope).run({
+  await deleteApiKeysWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "api_key",
diff --git a/packages/medusa/src/api/admin/api-keys/[id]/sales-channels/route.ts b/packages/medusa/src/api/admin/api-keys/[id]/sales-channels/route.ts
index 91eda3b9e1..48ff111aad 100644
--- a/packages/medusa/src/api/admin/api-keys/[id]/sales-channels/route.ts
+++ b/packages/medusa/src/api/admin/api-keys/[id]/sales-channels/route.ts
@@ -21,19 +21,14 @@ export const POST = async (
     )
   }
 
-  const { errors } = await linkSalesChannelsToApiKeyWorkflow(req.scope).run({
+  await linkSalesChannelsToApiKeyWorkflow(req.scope).run({
     input: {
       id: req.params.id,
       add,
       remove,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const updatedApiKey = await refetchApiKey(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/api-keys/route.ts b/packages/medusa/src/api/admin/api-keys/route.ts
index 0f77f5c80f..e16479512b 100644
--- a/packages/medusa/src/api/admin/api-keys/route.ts
+++ b/packages/medusa/src/api/admin/api-keys/route.ts
@@ -1,4 +1,4 @@
-import { createApiKeysWorkflow } from "@medusajs/core-flows"
+import {createApiKeysWorkflow} from "@medusajs/core-flows"
 import {
   ContainerRegistrationKeys,
   remoteQueryObjectFromString,
@@ -7,7 +7,7 @@ import {
   AuthenticatedMedusaRequest,
   MedusaResponse,
 } from "../../../types/routing"
-import { AdminCreateApiKeyType } from "./validators"
+import {AdminCreateApiKeyType} from "./validators"
 
 export const GET = async (
   req: AuthenticatedMedusaRequest,
@@ -45,15 +45,10 @@ export const POST = async (
     },
   ]
 
-  const { result, errors } = await createApiKeysWorkflow(req.scope).run({
+  const { result } = await createApiKeysWorkflow(req.scope).run({
     input: { api_keys: input },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   // We should not refetch the api key here, as we need to show the secret key in the response (and never again)
   // And the only time we get to see the secret, is when we create it
   res.status(200).json({ api_key: result[0] })
diff --git a/packages/medusa/src/api/admin/campaigns/[id]/promotions/route.ts b/packages/medusa/src/api/admin/campaigns/[id]/promotions/route.ts
index 05cd7251d4..4479322577 100644
--- a/packages/medusa/src/api/admin/campaigns/[id]/promotions/route.ts
+++ b/packages/medusa/src/api/admin/campaigns/[id]/promotions/route.ts
@@ -13,16 +13,9 @@ export const POST = async (
 ) => {
   const { id } = req.params
   const { add, remove } = req.validatedBody
-  const { errors } = await addOrRemoveCampaignPromotionsWorkflow(req.scope).run(
-    {
-      input: { id, add, remove },
-      throwOnError: false,
-    }
-  )
-
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
+  await addOrRemoveCampaignPromotionsWorkflow(req.scope).run({
+    input: { id, add, remove },
+  })
 
   const campaign = await refetchCampaign(
     req.params.id,
diff --git a/packages/medusa/src/api/admin/campaigns/[id]/route.ts b/packages/medusa/src/api/admin/campaigns/[id]/route.ts
index 710643fa59..ae4b5bd75b 100644
--- a/packages/medusa/src/api/admin/campaigns/[id]/route.ts
+++ b/packages/medusa/src/api/admin/campaigns/[id]/route.ts
@@ -43,15 +43,10 @@ export const POST = async (
     },
   ]
 
-  const { errors } = await updateCampaigns.run({
+  await updateCampaigns.run({
     input: { campaignsData },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const campaign = await refetchCampaign(
     req.params.id,
     req.scope,
@@ -67,15 +62,10 @@ export const DELETE = async (
   const id = req.params.id
   const deleteCampaigns = deleteCampaignsWorkflow(req.scope)
 
-  const { errors } = await deleteCampaigns.run({
+  await deleteCampaigns.run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "campaign",
diff --git a/packages/medusa/src/api/admin/campaigns/route.ts b/packages/medusa/src/api/admin/campaigns/route.ts
index 7951f0eb02..988b7dacba 100644
--- a/packages/medusa/src/api/admin/campaigns/route.ts
+++ b/packages/medusa/src/api/admin/campaigns/route.ts
@@ -2,13 +2,13 @@ import {
   AuthenticatedMedusaRequest,
   MedusaResponse,
 } from "../../../types/routing"
-import { createCampaignsWorkflow } from "@medusajs/core-flows"
+import {createCampaignsWorkflow} from "@medusajs/core-flows"
 import {
   ContainerRegistrationKeys,
   remoteQueryObjectFromString,
 } from "@medusajs/utils"
-import { AdminCreateCampaignType } from "./validators"
-import { refetchCampaign } from "./helpers"
+import {AdminCreateCampaignType} from "./validators"
+import {refetchCampaign} from "./helpers"
 
 export const GET = async (
   req: AuthenticatedMedusaRequest,
@@ -42,18 +42,13 @@ export const POST = async (
   const createCampaigns = createCampaignsWorkflow(req.scope)
   const campaignsData = [req.validatedBody]
 
-  const { result, errors } = await createCampaigns.run({
+  const { result } = await createCampaigns.run({
     input: { campaignsData },
-    throwOnError: false,
     context: {
       requestId: req.requestId,
     },
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const campaign = await refetchCampaign(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/collections/[id]/products/route.ts b/packages/medusa/src/api/admin/collections/[id]/products/route.ts
index 92e9fe12e4..96d6ed5316 100644
--- a/packages/medusa/src/api/admin/collections/[id]/products/route.ts
+++ b/packages/medusa/src/api/admin/collections/[id]/products/route.ts
@@ -14,19 +14,14 @@ export const POST = async (
   const { add = [], remove = [] } = req.validatedBody
 
   const workflow = batchLinkProductsToCollectionWorkflow(req.scope)
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       id,
       add,
       remove,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const collection = await refetchCollection(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/collections/[id]/route.ts b/packages/medusa/src/api/admin/collections/[id]/route.ts
index 61c9480d91..5cbbd3a430 100644
--- a/packages/medusa/src/api/admin/collections/[id]/route.ts
+++ b/packages/medusa/src/api/admin/collections/[id]/route.ts
@@ -27,18 +27,13 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminUpdateCollectionType>,
   res: MedusaResponse
 ) => {
-  const { errors } = await updateCollectionsWorkflow(req.scope).run({
+  await updateCollectionsWorkflow(req.scope).run({
     input: {
       selector: { id: req.params.id },
       update: req.validatedBody,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const collection = await refetchCollection(
     req.params.id,
     req.scope,
@@ -54,15 +49,10 @@ export const DELETE = async (
 ) => {
   const id = req.params.id
 
-  const { errors } = await deleteCollectionsWorkflow(req.scope).run({
+  await deleteCollectionsWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "collection",
diff --git a/packages/medusa/src/api/admin/collections/route.ts b/packages/medusa/src/api/admin/collections/route.ts
index 386b8b2e92..fd4a26f900 100644
--- a/packages/medusa/src/api/admin/collections/route.ts
+++ b/packages/medusa/src/api/admin/collections/route.ts
@@ -46,15 +46,10 @@ export const POST = async (
     },
   ]
 
-  const { result, errors } = await createCollectionsWorkflow(req.scope).run({
+  const { result } = await createCollectionsWorkflow(req.scope).run({
     input: { collections: input },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const collection = await refetchCollection(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/customer-groups/[id]/customers/route.ts b/packages/medusa/src/api/admin/customer-groups/[id]/customers/route.ts
index c769339722..64b21a7fac 100644
--- a/packages/medusa/src/api/admin/customer-groups/[id]/customers/route.ts
+++ b/packages/medusa/src/api/admin/customer-groups/[id]/customers/route.ts
@@ -15,19 +15,14 @@ export const POST = async (
   const { add, remove } = req.validatedBody
 
   const workflow = linkCustomersToCustomerGroupWorkflow(req.scope)
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       id,
       add,
       remove,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const customerGroup = await refetchCustomerGroup(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/customer-groups/[id]/route.ts b/packages/medusa/src/api/admin/customer-groups/[id]/route.ts
index 4085d0e865..9c977f6caa 100644
--- a/packages/medusa/src/api/admin/customer-groups/[id]/route.ts
+++ b/packages/medusa/src/api/admin/customer-groups/[id]/route.ts
@@ -28,18 +28,13 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const updateGroups = updateCustomerGroupsWorkflow(req.scope)
-  const { errors } = await updateGroups.run({
+  await updateGroups.run({
     input: {
       selector: { id: req.params.id },
       update: req.validatedBody,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const customerGroup = await refetchCustomerGroup(
     req.params.id,
     req.scope,
@@ -55,15 +50,10 @@ export const DELETE = async (
   const id = req.params.id
   const deleteCustomerGroups = deleteCustomerGroupsWorkflow(req.scope)
 
-  const { errors } = await deleteCustomerGroups.run({
+  await deleteCustomerGroups.run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "customer_group",
diff --git a/packages/medusa/src/api/admin/customer-groups/route.ts b/packages/medusa/src/api/admin/customer-groups/route.ts
index 7fc8591e43..2cc21efbb0 100644
--- a/packages/medusa/src/api/admin/customer-groups/route.ts
+++ b/packages/medusa/src/api/admin/customer-groups/route.ts
@@ -47,15 +47,10 @@ export const POST = async (
     },
   ]
 
-  const { result, errors } = await createGroups.run({
+  const { result } = await createGroups.run({
     input: { customersData },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const customerGroup = await refetchCustomerGroup(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/customers/[id]/addresses/[address_id]/route.ts b/packages/medusa/src/api/admin/customers/[id]/addresses/[address_id]/route.ts
index 3d731f827e..e15203000d 100644
--- a/packages/medusa/src/api/admin/customers/[id]/addresses/[address_id]/route.ts
+++ b/packages/medusa/src/api/admin/customers/[id]/addresses/[address_id]/route.ts
@@ -37,18 +37,13 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const updateAddresses = updateCustomerAddressesWorkflow(req.scope)
-  const { errors } = await updateAddresses.run({
+  await updateAddresses.run({
     input: {
       selector: { id: req.params.address_id, customer_id: req.params.id },
       update: req.validatedBody,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const customer = await refetchCustomer(
     req.params.id,
     req.scope,
@@ -65,15 +60,10 @@ export const DELETE = async (
   const id = req.params.address_id
   const deleteAddress = deleteCustomerAddressesWorkflow(req.scope)
 
-  const { errors } = await deleteAddress.run({
+  await deleteAddress.run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const customer = await refetchCustomer(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/customers/[id]/addresses/route.ts b/packages/medusa/src/api/admin/customers/[id]/addresses/route.ts
index dc3332490e..2038b91115 100644
--- a/packages/medusa/src/api/admin/customers/[id]/addresses/route.ts
+++ b/packages/medusa/src/api/admin/customers/[id]/addresses/route.ts
@@ -49,15 +49,10 @@ export const POST = async (
     },
   ]
 
-  const { errors } = await createAddresses.run({
+  await createAddresses.run({
     input: { addresses },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const customer = await refetchCustomer(
     customerId,
     req.scope,
diff --git a/packages/medusa/src/api/admin/customers/[id]/route.ts b/packages/medusa/src/api/admin/customers/[id]/route.ts
index 937a94aa5f..9a117857d5 100644
--- a/packages/medusa/src/api/admin/customers/[id]/route.ts
+++ b/packages/medusa/src/api/admin/customers/[id]/route.ts
@@ -35,18 +35,13 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminUpdateCustomerType>,
   res: MedusaResponse<{ customer: AdminCustomer }>
 ) => {
-  const { errors } = await updateCustomersWorkflow(req.scope).run({
+  await updateCustomersWorkflow(req.scope).run({
     input: {
       selector: { id: req.params.id },
       update: req.validatedBody,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const customer = await refetchCustomer(
     req.params.id,
     req.scope,
@@ -62,15 +57,10 @@ export const DELETE = async (
   const id = req.params.id
   const deleteCustomers = deleteCustomersWorkflow(req.scope)
 
-  const { errors } = await deleteCustomers.run({
+  await deleteCustomers.run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "customer",
diff --git a/packages/medusa/src/api/admin/customers/route.ts b/packages/medusa/src/api/admin/customers/route.ts
index f8c85c7204..5fb4af733d 100644
--- a/packages/medusa/src/api/admin/customers/route.ts
+++ b/packages/medusa/src/api/admin/customers/route.ts
@@ -50,15 +50,10 @@ export const POST = async (
     },
   ]
 
-  const { result, errors } = await createCustomers.run({
+  const { result } = await createCustomers.run({
     input: { customersData },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const customer = await refetchCustomer(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/draft-orders/route.ts b/packages/medusa/src/api/admin/draft-orders/route.ts
index 691cceaf15..6a459200bf 100644
--- a/packages/medusa/src/api/admin/draft-orders/route.ts
+++ b/packages/medusa/src/api/admin/draft-orders/route.ts
@@ -76,15 +76,10 @@ export const POST = async (
     input.email = customer?.email
   }
 
-  const { result, errors } = await createOrdersWorkflow(req.scope).run({
+  const { result } = await createOrdersWorkflow(req.scope).run({
     input: workflowInput,
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const draftOrder = await refetchOrder(
     result.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/fulfillment-sets/[id]/route.ts b/packages/medusa/src/api/admin/fulfillment-sets/[id]/route.ts
index c722b0f4b0..4dbfb951df 100644
--- a/packages/medusa/src/api/admin/fulfillment-sets/[id]/route.ts
+++ b/packages/medusa/src/api/admin/fulfillment-sets/[id]/route.ts
@@ -12,15 +12,10 @@ export const DELETE = async (
 ) => {
   const { id } = req.params
 
-  const { errors } = await deleteFulfillmentSetsWorkflow(req.scope).run({
+  await deleteFulfillmentSetsWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "fulfillment_set",
diff --git a/packages/medusa/src/api/admin/fulfillment-sets/[id]/service-zones/[zone_id]/route.ts b/packages/medusa/src/api/admin/fulfillment-sets/[id]/service-zones/[zone_id]/route.ts
index 2bdd6df476..dcdadaed2a 100644
--- a/packages/medusa/src/api/admin/fulfillment-sets/[id]/service-zones/[zone_id]/route.ts
+++ b/packages/medusa/src/api/admin/fulfillment-sets/[id]/service-zones/[zone_id]/route.ts
@@ -75,15 +75,10 @@ export const POST = async (
     update: req.validatedBody,
   }
 
-  const { errors } = await updateServiceZonesWorkflow(req.scope).run({
+  await updateServiceZonesWorkflow(req.scope).run({
     input: workflowInput,
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const [fulfillment_set] = await remoteQuery(
     remoteQueryObjectFromString({
       entryPoint: "fulfillment_sets",
@@ -119,15 +114,10 @@ export const DELETE = async (
     )
   }
 
-  const { errors } = await deleteServiceZonesWorkflow(req.scope).run({
+  await deleteServiceZonesWorkflow(req.scope).run({
     input: { ids: [zone_id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id: zone_id,
     object: "service-zone",
diff --git a/packages/medusa/src/api/admin/fulfillment-sets/[id]/service-zones/route.ts b/packages/medusa/src/api/admin/fulfillment-sets/[id]/service-zones/route.ts
index 059e499f23..b40735b9e2 100644
--- a/packages/medusa/src/api/admin/fulfillment-sets/[id]/service-zones/route.ts
+++ b/packages/medusa/src/api/admin/fulfillment-sets/[id]/service-zones/route.ts
@@ -17,15 +17,10 @@ export const POST = async (
     ],
   }
 
-  const { errors } = await createServiceZonesWorkflow(req.scope).run({
+  await createServiceZonesWorkflow(req.scope).run({
     input: workflowInput,
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const fulfillmentSet = await refetchFulfillmentSet(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/fulfillments/[id]/cancel/route.ts b/packages/medusa/src/api/admin/fulfillments/[id]/cancel/route.ts
index 0de2fd96b1..686519c856 100644
--- a/packages/medusa/src/api/admin/fulfillments/[id]/cancel/route.ts
+++ b/packages/medusa/src/api/admin/fulfillments/[id]/cancel/route.ts
@@ -11,15 +11,10 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const { id } = req.params
-  const { errors } = await cancelFulfillmentWorkflow(req.scope).run({
+  await cancelFulfillmentWorkflow(req.scope).run({
     input: { id },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const fulfillment = await refetchFulfillment(
     id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/fulfillments/[id]/shipment/route.ts b/packages/medusa/src/api/admin/fulfillments/[id]/shipment/route.ts
index 6917eef5bb..7d98ad8758 100644
--- a/packages/medusa/src/api/admin/fulfillments/[id]/shipment/route.ts
+++ b/packages/medusa/src/api/admin/fulfillments/[id]/shipment/route.ts
@@ -12,15 +12,10 @@ export const POST = async (
 ) => {
   const { id } = req.params
 
-  const { errors } = await createShipmentWorkflow(req.scope).run({
+  await createShipmentWorkflow(req.scope).run({
     input: { id, ...req.validatedBody },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const fulfillment = await refetchFulfillment(
     id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/fulfillments/route.ts b/packages/medusa/src/api/admin/fulfillments/route.ts
index 78c2f3f3bd..be3e8dbe64 100644
--- a/packages/medusa/src/api/admin/fulfillments/route.ts
+++ b/packages/medusa/src/api/admin/fulfillments/route.ts
@@ -10,17 +10,12 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminCreateFulfillmentType>,
   res: MedusaResponse
 ) => {
-  const { result: fullfillment, errors } = await createFulfillmentWorkflow(
+  const { result: fullfillment } = await createFulfillmentWorkflow(
     req.scope
   ).run({
     input: req.validatedBody,
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const fulfillment = await refetchFulfillment(
     fullfillment.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/inventory-items/[id]/location-levels/[location_id]/route.ts b/packages/medusa/src/api/admin/inventory-items/[id]/location-levels/[location_id]/route.ts
index e49b13cb52..4ac69c99be 100644
--- a/packages/medusa/src/api/admin/inventory-items/[id]/location-levels/[location_id]/route.ts
+++ b/packages/medusa/src/api/admin/inventory-items/[id]/location-levels/[location_id]/route.ts
@@ -64,17 +64,12 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const { id, location_id } = req.params
-  const { errors } = await updateInventoryLevelsWorkflow(req.scope).run({
+  await updateInventoryLevelsWorkflow(req.scope).run({
     input: {
       updates: [{ ...req.validatedBody, inventory_item_id: id, location_id }],
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const inventoryItem = await refetchInventoryItem(
     id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/inventory-items/[id]/location-levels/batch/route.ts b/packages/medusa/src/api/admin/inventory-items/[id]/location-levels/batch/route.ts
index 5cde87d9ad..8a16087b9b 100644
--- a/packages/medusa/src/api/admin/inventory-items/[id]/location-levels/batch/route.ts
+++ b/packages/medusa/src/api/admin/inventory-items/[id]/location-levels/batch/route.ts
@@ -20,7 +20,7 @@ export const POST = async (
 
   // TODO: Normalize workflow and response, and add support for updates
   const workflow = bulkCreateDeleteLevelsWorkflow(req.scope)
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       deletes:
         req.validatedBody.delete?.map((location_id) => ({
@@ -33,12 +33,7 @@ export const POST = async (
           inventory_item_id: id,
         })) ?? [],
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({ inventory_item: {} })
 }
diff --git a/packages/medusa/src/api/admin/inventory-items/[id]/location-levels/route.ts b/packages/medusa/src/api/admin/inventory-items/[id]/location-levels/route.ts
index da863f663a..b96436ba9d 100644
--- a/packages/medusa/src/api/admin/inventory-items/[id]/location-levels/route.ts
+++ b/packages/medusa/src/api/admin/inventory-items/[id]/location-levels/route.ts
@@ -18,7 +18,7 @@ export const POST = async (
   const { id } = req.params
 
   const workflow = createInventoryLevelsWorkflow(req.scope)
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       inventory_levels: [
         {
@@ -27,13 +27,8 @@ export const POST = async (
         },
       ],
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const inventoryItem = await refetchInventoryItem(
     id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/inventory-items/[id]/route.ts b/packages/medusa/src/api/admin/inventory-items/[id]/route.ts
index e18ad6aad1..b2d216a30a 100644
--- a/packages/medusa/src/api/admin/inventory-items/[id]/route.ts
+++ b/packages/medusa/src/api/admin/inventory-items/[id]/route.ts
@@ -60,15 +60,10 @@ export const DELETE = async (req: MedusaRequest, res: MedusaResponse) => {
   const id = req.params.id
   const deleteInventoryItems = deleteInventoryItemWorkflow(req.scope)
 
-  const { errors } = await deleteInventoryItems.run({
+  await deleteInventoryItems.run({
     input: [id],
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "inventory_item",
diff --git a/packages/medusa/src/api/admin/invites/[id]/route.ts b/packages/medusa/src/api/admin/invites/[id]/route.ts
index e21975ca97..66846b6836 100644
--- a/packages/medusa/src/api/admin/invites/[id]/route.ts
+++ b/packages/medusa/src/api/admin/invites/[id]/route.ts
@@ -35,15 +35,10 @@ export const DELETE = async (
   const { id } = req.params
   const workflow = deleteInvitesWorkflow(req.scope)
 
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "invite",
diff --git a/packages/medusa/src/api/admin/invites/route.ts b/packages/medusa/src/api/admin/invites/route.ts
index aa8399a3ba..e6c70bba02 100644
--- a/packages/medusa/src/api/admin/invites/route.ts
+++ b/packages/medusa/src/api/admin/invites/route.ts
@@ -45,14 +45,9 @@ export const POST = async (
     input: {
       invites: [req.validatedBody],
     },
-    throwOnError: false,
   }
 
-  const { result, errors } = await workflow.run(input)
-
-  if (errors?.length) {
-    throw errors[0].error
-  }
+  const { result } = await workflow.run(input)
 
   const invite = await refetchInvite(
     result[0].id,
diff --git a/packages/medusa/src/api/admin/orders/[id]/archive/route.ts b/packages/medusa/src/api/admin/orders/[id]/archive/route.ts
index 25ae624645..606b0f8720 100644
--- a/packages/medusa/src/api/admin/orders/[id]/archive/route.ts
+++ b/packages/medusa/src/api/admin/orders/[id]/archive/route.ts
@@ -13,15 +13,10 @@ export const POST = async (
   const remoteQuery = req.scope.resolve("remoteQuery")
   const { id } = req.params
 
-  const { errors } = await archiveOrderWorkflow(req.scope).run({
+  await archiveOrderWorkflow(req.scope).run({
     input: { orderIds: [req.validatedBody.order_id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const queryObject = remoteQueryObjectFromString({
     entryPoint: "order",
     variables: { id },
diff --git a/packages/medusa/src/api/admin/orders/[id]/complete/route.ts b/packages/medusa/src/api/admin/orders/[id]/complete/route.ts
index 9f58e05542..8c5cb1dcaf 100644
--- a/packages/medusa/src/api/admin/orders/[id]/complete/route.ts
+++ b/packages/medusa/src/api/admin/orders/[id]/complete/route.ts
@@ -13,15 +13,10 @@ export const POST = async (
   const remoteQuery = req.scope.resolve("remoteQuery")
   const { id } = req.params
 
-  const { errors } = await completeOrderWorkflow(req.scope).run({
+  await completeOrderWorkflow(req.scope).run({
     input: { orderIds: [req.validatedBody.order_id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const queryObject = remoteQueryObjectFromString({
     entryPoint: "order",
     variables: { id },
diff --git a/packages/medusa/src/api/admin/payments/[id]/capture/route.ts b/packages/medusa/src/api/admin/payments/[id]/capture/route.ts
index 4802f18edc..f8ed45c2b4 100644
--- a/packages/medusa/src/api/admin/payments/[id]/capture/route.ts
+++ b/packages/medusa/src/api/admin/payments/[id]/capture/route.ts
@@ -12,19 +12,14 @@ export const POST = async (
 ) => {
   const { id } = req.params
 
-  const { errors } = await capturePaymentWorkflow(req.scope).run({
+  await capturePaymentWorkflow(req.scope).run({
     input: {
       payment_id: id,
       captured_by: req.auth_context.actor_id,
       amount: req.validatedBody.amount,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const payment = await refetchPayment(
     id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/payments/[id]/refund/route.ts b/packages/medusa/src/api/admin/payments/[id]/refund/route.ts
index a627f9b252..8dfa60d83e 100644
--- a/packages/medusa/src/api/admin/payments/[id]/refund/route.ts
+++ b/packages/medusa/src/api/admin/payments/[id]/refund/route.ts
@@ -11,19 +11,14 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const { id } = req.params
-  const { errors } = await refundPaymentWorkflow(req.scope).run({
+  await refundPaymentWorkflow(req.scope).run({
     input: {
       payment_id: id,
       created_by: req.auth_context.actor_id,
       amount: req.validatedBody.amount,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const payment = await refetchPayment(
     id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/price-lists/[id]/prices/batch/route.ts b/packages/medusa/src/api/admin/price-lists/[id]/prices/batch/route.ts
index 3d9be66ddc..7b31cf5e65 100644
--- a/packages/medusa/src/api/admin/price-lists/[id]/prices/batch/route.ts
+++ b/packages/medusa/src/api/admin/price-lists/[id]/prices/batch/route.ts
@@ -29,7 +29,7 @@ export const POST = async (
   } = req.validatedBody
 
   const workflow = batchPriceListPricesWorkflow(req.scope)
-  const { result, errors } = await workflow.run({
+  const { result } = await workflow.run({
     input: {
       data: {
         id,
@@ -38,13 +38,8 @@ export const POST = async (
         delete: deletePriceIds,
       },
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const [created, updated] = await promiseAll([
     listPrices(
       result.created.map((c) => c.id),
diff --git a/packages/medusa/src/api/admin/price-lists/[id]/products/route.ts b/packages/medusa/src/api/admin/price-lists/[id]/products/route.ts
index 0e453bc716..a9efbc1bf5 100644
--- a/packages/medusa/src/api/admin/price-lists/[id]/products/route.ts
+++ b/packages/medusa/src/api/admin/price-lists/[id]/products/route.ts
@@ -34,7 +34,7 @@ export const POST = async (
   )
 
   const workflow = batchPriceListPricesWorkflow(req.scope)
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       data: {
         id,
@@ -43,13 +43,8 @@ export const POST = async (
         delete: productPriceIds,
       },
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const priceList = await fetchPriceList(
     id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/price-lists/[id]/route.ts b/packages/medusa/src/api/admin/price-lists/[id]/route.ts
index b9bc841eae..04b4e13281 100644
--- a/packages/medusa/src/api/admin/price-lists/[id]/route.ts
+++ b/packages/medusa/src/api/admin/price-lists/[id]/route.ts
@@ -29,15 +29,10 @@ export const POST = async (
   const id = req.params.id
   const workflow = updatePriceListsWorkflow(req.scope)
 
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: { price_lists_data: [{ ...req.validatedBody, id }] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const price_list = await fetchPriceList(
     id,
     req.scope,
@@ -54,15 +49,10 @@ export const DELETE = async (
   const id = req.params.id
   const workflow = deletePriceListsWorkflow(req.scope)
 
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "price_list",
diff --git a/packages/medusa/src/api/admin/price-lists/route.ts b/packages/medusa/src/api/admin/price-lists/route.ts
index fc7024a738..26c8cf3fc8 100644
--- a/packages/medusa/src/api/admin/price-lists/route.ts
+++ b/packages/medusa/src/api/admin/price-lists/route.ts
@@ -40,15 +40,10 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const workflow = createPriceListsWorkflow(req.scope)
-  const { result, errors } = await workflow.run({
+  const { result } = await workflow.run({
     input: { price_lists_data: [req.validatedBody] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const price_list = await fetchPriceList(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/pricing/rule-types/[id]/route.ts b/packages/medusa/src/api/admin/pricing/rule-types/[id]/route.ts
index 55c4fe5350..914ef8592d 100644
--- a/packages/medusa/src/api/admin/pricing/rule-types/[id]/route.ts
+++ b/packages/medusa/src/api/admin/pricing/rule-types/[id]/route.ts
@@ -38,17 +38,12 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const workflow = updatePricingRuleTypesWorkflow(req.scope)
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       data: [{ ...req.validatedBody, id: req.params.id }],
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const ruleType = await refetchRuleType(
     req.params.id,
     req.scope,
@@ -67,15 +62,10 @@ export const DELETE = async (
   const id = req.params.id
   const workflow = deletePricingRuleTypesWorkflow(req.scope)
 
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "rule_type",
diff --git a/packages/medusa/src/api/admin/pricing/rule-types/route.ts b/packages/medusa/src/api/admin/pricing/rule-types/route.ts
index a4060a99cd..be5498bbb7 100644
--- a/packages/medusa/src/api/admin/pricing/rule-types/route.ts
+++ b/packages/medusa/src/api/admin/pricing/rule-types/route.ts
@@ -44,15 +44,10 @@ export const POST = async (
   const workflow = createPricingRuleTypesWorkflow(req.scope)
   const ruleTypesData = [req.validatedBody]
 
-  const { result, errors } = await workflow.run({
+  const { result } = await workflow.run({
     input: { data: ruleTypesData },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const ruleType = await refetchRuleType(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/product-categories/[id]/products/route.ts b/packages/medusa/src/api/admin/product-categories/[id]/products/route.ts
index f39e2fe00c..f27719463e 100644
--- a/packages/medusa/src/api/admin/product-categories/[id]/products/route.ts
+++ b/packages/medusa/src/api/admin/product-categories/[id]/products/route.ts
@@ -15,15 +15,10 @@ export const POST = async (
 ) => {
   const { id } = req.params
 
-  const { errors } = await batchLinkProductsToCategoryWorkflow(req.scope).run({
+  await batchLinkProductsToCategoryWorkflow(req.scope).run({
     input: { id, ...req.validatedBody },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const category = await refetchEntity(
     "product_category",
     id,
diff --git a/packages/medusa/src/api/admin/product-categories/[id]/route.ts b/packages/medusa/src/api/admin/product-categories/[id]/route.ts
index 8473e13649..f374dcefee 100644
--- a/packages/medusa/src/api/admin/product-categories/[id]/route.ts
+++ b/packages/medusa/src/api/admin/product-categories/[id]/route.ts
@@ -31,15 +31,10 @@ export const POST = async (
   const { id } = req.params
 
   // TODO: Should be converted to bulk update
-  const { errors } = await updateProductCategoryWorkflow(req.scope).run({
+  await updateProductCategoryWorkflow(req.scope).run({
     input: { id, data: req.validatedBody },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const [category] = await refetchEntities(
     "product_category",
     { id, ...req.filterableFields },
diff --git a/packages/medusa/src/api/admin/product-categories/route.ts b/packages/medusa/src/api/admin/product-categories/route.ts
index 0c73e1b39c..a5c15a3415 100644
--- a/packages/medusa/src/api/admin/product-categories/route.ts
+++ b/packages/medusa/src/api/admin/product-categories/route.ts
@@ -37,16 +37,9 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminCreateProductCategoryType>,
   res: MedusaResponse<AdminProductCategoryResponse>
 ) => {
-  const { result, errors } = await createProductCategoryWorkflow(req.scope).run(
-    {
-      input: { product_category: req.validatedBody },
-      throwOnError: false,
-    }
-  )
-
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
+  const { result } = await createProductCategoryWorkflow(req.scope).run({
+    input: { product_category: req.validatedBody },
+  })
 
   const [category] = await refetchEntities(
     "product_category",
diff --git a/packages/medusa/src/api/admin/product-types/[id]/route.ts b/packages/medusa/src/api/admin/product-types/[id]/route.ts
index c33c43489e..33cac51338 100644
--- a/packages/medusa/src/api/admin/product-types/[id]/route.ts
+++ b/packages/medusa/src/api/admin/product-types/[id]/route.ts
@@ -30,18 +30,13 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminUpdateProductTypeType>,
   res: MedusaResponse
 ) => {
-  const { result, errors } = await updateProductTypesWorkflow(req.scope).run({
+  const { result } = await updateProductTypesWorkflow(req.scope).run({
     input: {
       selector: { id: req.params.id },
       update: req.validatedBody,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const productType = await refetchProductType(
     result[0].id,
     req.scope,
@@ -57,15 +52,10 @@ export const DELETE = async (
 ) => {
   const id = req.params.id
 
-  const { errors } = await deleteProductTypesWorkflow(req.scope).run({
+  await deleteProductTypesWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "product_type",
diff --git a/packages/medusa/src/api/admin/product-types/route.ts b/packages/medusa/src/api/admin/product-types/route.ts
index 2b2bbd7d05..2929738639 100644
--- a/packages/medusa/src/api/admin/product-types/route.ts
+++ b/packages/medusa/src/api/admin/product-types/route.ts
@@ -44,15 +44,10 @@ export const POST = async (
 ) => {
   const input = [req.validatedBody]
 
-  const { result, errors } = await createProductTypesWorkflow(req.scope).run({
+  const { result } = await createProductTypesWorkflow(req.scope).run({
     input: { product_types: input },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const productType = await refetchProductType(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/products/[id]/options/[option_id]/route.ts b/packages/medusa/src/api/admin/products/[id]/options/[option_id]/route.ts
index 3fe078fe39..efddb3d562 100644
--- a/packages/medusa/src/api/admin/products/[id]/options/[option_id]/route.ts
+++ b/packages/medusa/src/api/admin/products/[id]/options/[option_id]/route.ts
@@ -42,18 +42,13 @@ export const POST = async (
   const productId = req.params.id
   const optionId = req.params.option_id
 
-  const { errors } = await updateProductOptionsWorkflow(req.scope).run({
+  await updateProductOptionsWorkflow(req.scope).run({
     input: {
       selector: { id: optionId, product_id: productId },
       update: req.validatedBody,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const product = await refetchProduct(
     productId,
     req.scope,
@@ -70,15 +65,10 @@ export const DELETE = async (
   const optionId = req.params.option_id
 
   // TODO: I believe here we cannot even enforce the product ID based on the standard API we provide?
-  const { errors } = await deleteProductOptionsWorkflow(req.scope).run({
+  await deleteProductOptionsWorkflow(req.scope).run({
     input: { ids: [optionId] /* product_id: productId */ },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const product = await refetchProduct(
     productId,
     req.scope,
diff --git a/packages/medusa/src/api/admin/products/[id]/options/route.ts b/packages/medusa/src/api/admin/products/[id]/options/route.ts
index caa0379476..fe14beb844 100644
--- a/packages/medusa/src/api/admin/products/[id]/options/route.ts
+++ b/packages/medusa/src/api/admin/products/[id]/options/route.ts
@@ -51,15 +51,10 @@ export const POST = async (
     },
   ]
 
-  const { errors } = await createProductOptionsWorkflow(req.scope).run({
+  await createProductOptionsWorkflow(req.scope).run({
     input: { product_options: input },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const product = await refetchProduct(
     productId,
     req.scope,
diff --git a/packages/medusa/src/api/admin/products/[id]/route.ts b/packages/medusa/src/api/admin/products/[id]/route.ts
index eb77a18e5b..96221e7409 100644
--- a/packages/medusa/src/api/admin/products/[id]/route.ts
+++ b/packages/medusa/src/api/admin/products/[id]/route.ts
@@ -43,18 +43,13 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminUpdateProductType>,
   res: MedusaResponse
 ) => {
-  const { result, errors } = await updateProductsWorkflow(req.scope).run({
+  const { result } = await updateProductsWorkflow(req.scope).run({
     input: {
       selector: { id: req.params.id },
       update: req.validatedBody as UpdateProductDTO,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const product = await refetchProduct(
     result[0].id,
     req.scope,
@@ -69,15 +64,10 @@ export const DELETE = async (
 ) => {
   const id = req.params.id
 
-  const { errors } = await deleteProductsWorkflow(req.scope).run({
+  await deleteProductsWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "product",
diff --git a/packages/medusa/src/api/admin/products/[id]/variants/[variant_id]/route.ts b/packages/medusa/src/api/admin/products/[id]/variants/[variant_id]/route.ts
index bd47f746cf..b6bb2cefd4 100644
--- a/packages/medusa/src/api/admin/products/[id]/variants/[variant_id]/route.ts
+++ b/packages/medusa/src/api/admin/products/[id]/variants/[variant_id]/route.ts
@@ -49,18 +49,13 @@ export const POST = async (
   const productId = req.params.id
   const variantId = req.params.variant_id
 
-  const { errors } = await updateProductVariantsWorkflow(req.scope).run({
+  await updateProductVariantsWorkflow(req.scope).run({
     input: {
       selector: { id: variantId, product_id: productId },
       update: req.validatedBody,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const product = await refetchProduct(
     productId,
     req.scope,
@@ -78,15 +73,10 @@ export const DELETE = async (
   const variantId = req.params.variant_id
 
   // TODO: I believe here we cannot even enforce the product ID based on the standard API we provide?
-  const { errors } = await deleteProductVariantsWorkflow(req.scope).run({
+  await deleteProductVariantsWorkflow(req.scope).run({
     input: { ids: [variantId] /* product_id: productId */ },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const product = await refetchProduct(
     productId,
     req.scope,
diff --git a/packages/medusa/src/api/admin/products/[id]/variants/batch/route.ts b/packages/medusa/src/api/admin/products/[id]/variants/batch/route.ts
index 2e9de2391d..533c3a06b9 100644
--- a/packages/medusa/src/api/admin/products/[id]/variants/batch/route.ts
+++ b/packages/medusa/src/api/admin/products/[id]/variants/batch/route.ts
@@ -34,15 +34,10 @@ export const POST = async (
     // TODO: Fix types
   } as any
 
-  const { result, errors } = await batchProductVariantsWorkflow(req.scope).run({
+  const { result } = await batchProductVariantsWorkflow(req.scope).run({
     input: normalizedInput,
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const batchResults = await refetchBatchVariants(
     result,
     req.scope,
diff --git a/packages/medusa/src/api/admin/products/[id]/variants/route.ts b/packages/medusa/src/api/admin/products/[id]/variants/route.ts
index 22cb9f88a6..a2ebcca8ce 100644
--- a/packages/medusa/src/api/admin/products/[id]/variants/route.ts
+++ b/packages/medusa/src/api/admin/products/[id]/variants/route.ts
@@ -56,15 +56,10 @@ export const POST = async (
     },
   ]
 
-  const { errors } = await createProductVariantsWorkflow(req.scope).run({
+  await createProductVariantsWorkflow(req.scope).run({
     input: { product_variants: input },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const product = await refetchProduct(
     productId,
     req.scope,
diff --git a/packages/medusa/src/api/admin/products/batch/route.ts b/packages/medusa/src/api/admin/products/batch/route.ts
index 51a56ddbd7..2bf91d92b6 100644
--- a/packages/medusa/src/api/admin/products/batch/route.ts
+++ b/packages/medusa/src/api/admin/products/batch/route.ts
@@ -19,15 +19,10 @@ export const POST = async (
   // TODO: Fix types
   const input = req.validatedBody as any
 
-  const { result, errors } = await batchProductsWorkflow(req.scope).run({
+  const { result } = await batchProductsWorkflow(req.scope).run({
     input,
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const batchResults = await refetchBatchProducts(
     result,
     req.scope,
diff --git a/packages/medusa/src/api/admin/products/route.ts b/packages/medusa/src/api/admin/products/route.ts
index 50162ef1c0..ea533156c0 100644
--- a/packages/medusa/src/api/admin/products/route.ts
+++ b/packages/medusa/src/api/admin/products/route.ts
@@ -50,15 +50,10 @@ export const POST = async (
 ) => {
   const input = [req.validatedBody as CreateProductDTO]
 
-  const { result, errors } = await createProductsWorkflow(req.scope).run({
+  const { result } = await createProductsWorkflow(req.scope).run({
     input: { products: input },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const product = await refetchProduct(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/promotions/[id]/buy-rules/batch/route.ts b/packages/medusa/src/api/admin/promotions/[id]/buy-rules/batch/route.ts
index 5eacd49848..49396be58f 100644
--- a/packages/medusa/src/api/admin/promotions/[id]/buy-rules/batch/route.ts
+++ b/packages/medusa/src/api/admin/promotions/[id]/buy-rules/batch/route.ts
@@ -21,7 +21,7 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const id = req.params.id
-  const { result, errors } = await batchPromotionRulesWorkflow(req.scope).run({
+  const { result } = await batchPromotionRulesWorkflow(req.scope).run({
     input: {
       id,
       rule_type: RuleType.BUY_RULES,
@@ -29,13 +29,8 @@ export const POST = async (
       update: req.validatedBody.update,
       delete: req.validatedBody.delete,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const batchResults = await refetchBatchRules(
     result,
     req.scope,
diff --git a/packages/medusa/src/api/admin/promotions/[id]/route.ts b/packages/medusa/src/api/admin/promotions/[id]/route.ts
index ce43f63c5d..12badbee95 100644
--- a/packages/medusa/src/api/admin/promotions/[id]/route.ts
+++ b/packages/medusa/src/api/admin/promotions/[id]/route.ts
@@ -54,15 +54,10 @@ export const POST = async (
     } as any,
   ]
 
-  const { errors } = await updatePromotions.run({
+  await updatePromotions.run({
     input: { promotionsData },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const promotion = await refetchPromotion(
     req.params.id,
     req.scope,
@@ -79,15 +74,10 @@ export const DELETE = async (
   const id = req.params.id
   const deletePromotions = deletePromotionsWorkflow(req.scope)
 
-  const { errors } = await deletePromotions.run({
+  await deletePromotions.run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "promotion",
diff --git a/packages/medusa/src/api/admin/promotions/[id]/rules/batch/route.ts b/packages/medusa/src/api/admin/promotions/[id]/rules/batch/route.ts
index 5b043fb392..d93fdc0951 100644
--- a/packages/medusa/src/api/admin/promotions/[id]/rules/batch/route.ts
+++ b/packages/medusa/src/api/admin/promotions/[id]/rules/batch/route.ts
@@ -21,7 +21,7 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const id = req.params.id
-  const { result, errors } = await batchPromotionRulesWorkflow(req.scope).run({
+  const { result } = await batchPromotionRulesWorkflow(req.scope).run({
     input: {
       id,
       rule_type: RuleType.RULES,
@@ -29,13 +29,8 @@ export const POST = async (
       update: req.validatedBody.update,
       delete: req.validatedBody.delete,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const batchResults = await refetchBatchRules(
     result,
     req.scope,
diff --git a/packages/medusa/src/api/admin/promotions/[id]/target-rules/batch/route.ts b/packages/medusa/src/api/admin/promotions/[id]/target-rules/batch/route.ts
index ba72354838..e5f84e6035 100644
--- a/packages/medusa/src/api/admin/promotions/[id]/target-rules/batch/route.ts
+++ b/packages/medusa/src/api/admin/promotions/[id]/target-rules/batch/route.ts
@@ -21,7 +21,7 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const id = req.params.id
-  const { result, errors } = await batchPromotionRulesWorkflow(req.scope).run({
+  const { result } = await batchPromotionRulesWorkflow(req.scope).run({
     input: {
       id,
       rule_type: RuleType.TARGET_RULES,
@@ -29,13 +29,8 @@ export const POST = async (
       update: req.validatedBody.update,
       delete: req.validatedBody.delete,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const batchResults = await refetchBatchRules(
     result,
     req.scope,
diff --git a/packages/medusa/src/api/admin/promotions/route.ts b/packages/medusa/src/api/admin/promotions/route.ts
index e9731503a5..95e20da979 100644
--- a/packages/medusa/src/api/admin/promotions/route.ts
+++ b/packages/medusa/src/api/admin/promotions/route.ts
@@ -45,15 +45,10 @@ export const POST = async (
   const createPromotions = createPromotionsWorkflow(req.scope)
   const promotionsData = [req.validatedBody] as any
 
-  const { result, errors } = await createPromotions.run({
+  const { result } = await createPromotions.run({
     input: { promotionsData },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const promotion = await refetchPromotion(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/regions/[id]/route.ts b/packages/medusa/src/api/admin/regions/[id]/route.ts
index b3eba2f69a..4342f8f1e9 100644
--- a/packages/medusa/src/api/admin/regions/[id]/route.ts
+++ b/packages/medusa/src/api/admin/regions/[id]/route.ts
@@ -25,18 +25,13 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminUpdateRegionType>,
   res: MedusaResponse
 ) => {
-  const { result, errors } = await updateRegionsWorkflow(req.scope).run({
+  const { result } = await updateRegionsWorkflow(req.scope).run({
     input: {
       selector: { id: req.params.id },
       update: req.validatedBody,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const region = await refetchRegion(
     result[0].id,
     req.scope,
@@ -52,15 +47,10 @@ export const DELETE = async (
 ) => {
   const id = req.params.id
 
-  const { errors } = await deleteRegionsWorkflow(req.scope).run({
+  await deleteRegionsWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "region",
diff --git a/packages/medusa/src/api/admin/regions/route.ts b/packages/medusa/src/api/admin/regions/route.ts
index d7be4022f8..53407c1aa1 100644
--- a/packages/medusa/src/api/admin/regions/route.ts
+++ b/packages/medusa/src/api/admin/regions/route.ts
@@ -41,15 +41,10 @@ export const POST = async (
 ) => {
   const input = [req.validatedBody]
 
-  const { result, errors } = await createRegionsWorkflow(req.scope).run({
+  const { result } = await createRegionsWorkflow(req.scope).run({
     input: { regions: input },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const region = await refetchRegion(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/reservations/[id]/route.ts b/packages/medusa/src/api/admin/reservations/[id]/route.ts
index d0c1bf4f16..afbecd3154 100644
--- a/packages/medusa/src/api/admin/reservations/[id]/route.ts
+++ b/packages/medusa/src/api/admin/reservations/[id]/route.ts
@@ -38,17 +38,12 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const { id } = req.params
-  const { errors } = await updateReservationsWorkflow(req.scope).run({
+  await updateReservationsWorkflow(req.scope).run({
     input: {
       updates: [{ ...req.validatedBody, id }],
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const reservation = await refetchReservation(
     id,
     req.scope,
@@ -63,15 +58,10 @@ export const DELETE = async (
 ) => {
   const id = req.params.id
 
-  const { errors } = await deleteReservationsWorkflow(req.scope).run({
+  await deleteReservationsWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "reservation",
diff --git a/packages/medusa/src/api/admin/reservations/route.ts b/packages/medusa/src/api/admin/reservations/route.ts
index 5b7319d80a..74cb1a01d1 100644
--- a/packages/medusa/src/api/admin/reservations/route.ts
+++ b/packages/medusa/src/api/admin/reservations/route.ts
@@ -45,15 +45,10 @@ export const POST = async (
 ) => {
   const input = [req.validatedBody]
 
-  const { result, errors } = await createReservationsWorkflow(req.scope).run({
+  const { result } = await createReservationsWorkflow(req.scope).run({
     input: { reservations: input },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const reservation = await refetchReservation(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/return-reasons/[id]/route.ts b/packages/medusa/src/api/admin/return-reasons/[id]/route.ts
index 779a4fbab3..e8be4d7713 100644
--- a/packages/medusa/src/api/admin/return-reasons/[id]/route.ts
+++ b/packages/medusa/src/api/admin/return-reasons/[id]/route.ts
@@ -43,11 +43,7 @@ export const POST = async (
     update: req.validatedBody,
   }
 
-  const { result, errors } = await workflow.run({ input })
-
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
+  const { result } = await workflow.run({ input })
 
   const variables = { id: result[0].id }
 
diff --git a/packages/medusa/src/api/admin/return-reasons/route.ts b/packages/medusa/src/api/admin/return-reasons/route.ts
index 502a3ceafd..497c537043 100644
--- a/packages/medusa/src/api/admin/return-reasons/route.ts
+++ b/packages/medusa/src/api/admin/return-reasons/route.ts
@@ -50,11 +50,7 @@ export const POST = async (
     ],
   }
 
-  const { result, errors } = await workflow.run({ input })
-
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
+  const { result } = await workflow.run({ input })
 
   const variables = { id: result[0].id }
 
diff --git a/packages/medusa/src/api/admin/returns/route.ts b/packages/medusa/src/api/admin/returns/route.ts
index 6fdcd14314..3928352114 100644
--- a/packages/medusa/src/api/admin/returns/route.ts
+++ b/packages/medusa/src/api/admin/returns/route.ts
@@ -1,4 +1,4 @@
-import { createReturnOrderWorkflow } from "@medusajs/core-flows"
+import {createReturnOrderWorkflow} from "@medusajs/core-flows"
 import {
   ContainerRegistrationKeys,
   remoteQueryObjectFromString,
@@ -7,7 +7,7 @@ import {
   AuthenticatedMedusaRequest,
   MedusaResponse,
 } from "../../../types/routing"
-import { AdminPostReturnsReqSchemaType } from "./validators"
+import {AdminPostReturnsReqSchemaType} from "./validators"
 
 export const GET = async (
   req: AuthenticatedMedusaRequest,
@@ -43,14 +43,9 @@ export const POST = async (
   const input = req.validatedBody as AdminPostReturnsReqSchemaType
 
   const workflow = createReturnOrderWorkflow(req.scope)
-  const { result, errors } = await workflow.run({
+  const { result } = await workflow.run({
     input,
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({ return: result })
 }
diff --git a/packages/medusa/src/api/admin/sales-channels/[id]/products/route.ts b/packages/medusa/src/api/admin/sales-channels/[id]/products/route.ts
index ff142c0a3b..83e928b828 100644
--- a/packages/medusa/src/api/admin/sales-channels/[id]/products/route.ts
+++ b/packages/medusa/src/api/admin/sales-channels/[id]/products/route.ts
@@ -15,19 +15,14 @@ export const POST = async (
   const { add, remove } = req.validatedBody
 
   const workflow = linkProductsToSalesChannelWorkflow(req.scope)
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       id,
       add,
       remove,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const salesChannel = await refetchSalesChannel(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/sales-channels/[id]/route.ts b/packages/medusa/src/api/admin/sales-channels/[id]/route.ts
index 898e2ccfa4..534ee322af 100644
--- a/packages/medusa/src/api/admin/sales-channels/[id]/route.ts
+++ b/packages/medusa/src/api/admin/sales-channels/[id]/route.ts
@@ -29,18 +29,13 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminUpdateSalesChannelType>,
   res: MedusaResponse
 ) => {
-  const { errors } = await updateSalesChannelsWorkflow(req.scope).run({
+  await updateSalesChannelsWorkflow(req.scope).run({
     input: {
       selector: { id: req.params.id },
       update: req.validatedBody,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const salesChannel = await refetchSalesChannel(
     req.params.id,
     req.scope,
@@ -55,15 +50,10 @@ export const DELETE = async (
 ) => {
   const id = req.params.id
 
-  const { errors } = await deleteSalesChannelsWorkflow(req.scope).run({
+  await deleteSalesChannelsWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "sales-channel",
diff --git a/packages/medusa/src/api/admin/sales-channels/route.ts b/packages/medusa/src/api/admin/sales-channels/route.ts
index bbd8bd02f5..74c8fe79bc 100644
--- a/packages/medusa/src/api/admin/sales-channels/route.ts
+++ b/packages/medusa/src/api/admin/sales-channels/route.ts
@@ -44,15 +44,10 @@ export const POST = async (
 ) => {
   const salesChannelsData = [req.validatedBody]
 
-  const { errors, result } = await createSalesChannelsWorkflow(req.scope).run({
+  const { result } = await createSalesChannelsWorkflow(req.scope).run({
     input: { salesChannelsData },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const salesChannel = await refetchSalesChannel(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/shipping-options/[id]/route.ts b/packages/medusa/src/api/admin/shipping-options/[id]/route.ts
index 8dbcf951b2..509e99cbc6 100644
--- a/packages/medusa/src/api/admin/shipping-options/[id]/route.ts
+++ b/packages/medusa/src/api/admin/shipping-options/[id]/route.ts
@@ -28,15 +28,10 @@ export const POST = async (
       ...shippingOptionPayload,
     }
 
-  const { result, errors } = await workflow.run({
+  const { result } = await workflow.run({
     input: [workflowInput],
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const shippingOption = await refetchShippingOption(
     result[0].id,
     req.scope,
@@ -54,15 +49,10 @@ export const DELETE = async (
 
   const workflow = deleteShippingOptionsWorkflow(req.scope)
 
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: { ids: [shippingOptionId] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res
     .status(200)
     .json({ id: shippingOptionId, object: "shipping_option", deleted: true })
diff --git a/packages/medusa/src/api/admin/shipping-options/[id]/rules/batch/route.ts b/packages/medusa/src/api/admin/shipping-options/[id]/rules/batch/route.ts
index 7df7349f8e..e6e3b716f0 100644
--- a/packages/medusa/src/api/admin/shipping-options/[id]/rules/batch/route.ts
+++ b/packages/medusa/src/api/admin/shipping-options/[id]/rules/batch/route.ts
@@ -20,9 +20,7 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const id = req.params.id
-  const { result, errors } = await batchShippingOptionRulesWorkflow(
-    req.scope
-  ).run({
+  const { result } = await batchShippingOptionRulesWorkflow(req.scope).run({
     input: {
       create: req.validatedBody.create?.map((c) => ({
         ...c,
@@ -31,13 +29,8 @@ export const POST = async (
       update: req.validatedBody.update,
       delete: req.validatedBody.delete,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const batchResults = await refetchBatchRules(
     result,
     req.scope,
diff --git a/packages/medusa/src/api/admin/shipping-options/route.ts b/packages/medusa/src/api/admin/shipping-options/route.ts
index ffe096bb4e..9a67fcb6d4 100644
--- a/packages/medusa/src/api/admin/shipping-options/route.ts
+++ b/packages/medusa/src/api/admin/shipping-options/route.ts
@@ -50,15 +50,10 @@ export const POST = async (
 
   const workflow = createShippingOptionsWorkflow(req.scope)
 
-  const { result, errors } = await workflow.run({
+  const { result } = await workflow.run({
     input: [shippingOptionPayload],
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const shippingOption = await refetchShippingOption(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/shipping-profiles/[id]/route.ts b/packages/medusa/src/api/admin/shipping-profiles/[id]/route.ts
index 2948becaa5..06d0a883fa 100644
--- a/packages/medusa/src/api/admin/shipping-profiles/[id]/route.ts
+++ b/packages/medusa/src/api/admin/shipping-profiles/[id]/route.ts
@@ -38,15 +38,10 @@ export const DELETE = async (
   // Test if exists
   await fulfillmentModuleService.retrieveShippingProfile(id)
 
-  const { errors } = await deleteShippingProfileWorkflow(req.scope).run({
+  await deleteShippingProfileWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "shipping_profile",
diff --git a/packages/medusa/src/api/admin/shipping-profiles/route.ts b/packages/medusa/src/api/admin/shipping-profiles/route.ts
index a37f8526ca..d562533eff 100644
--- a/packages/medusa/src/api/admin/shipping-profiles/route.ts
+++ b/packages/medusa/src/api/admin/shipping-profiles/route.ts
@@ -23,17 +23,10 @@ export const POST = async (
 ) => {
   const shippingProfilePayload = req.validatedBody
 
-  const { result, errors } = await createShippingProfilesWorkflow(
-    req.scope
-  ).run({
+  const { result } = await createShippingProfilesWorkflow(req.scope).run({
     input: { data: [shippingProfilePayload] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const shippingProfile = await refetchShippingProfile(
     result?.[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/stock-locations/[id]/fulfillment-sets/route.ts b/packages/medusa/src/api/admin/stock-locations/[id]/fulfillment-sets/route.ts
index b726fcef7d..09f51b529d 100644
--- a/packages/medusa/src/api/admin/stock-locations/[id]/fulfillment-sets/route.ts
+++ b/packages/medusa/src/api/admin/stock-locations/[id]/fulfillment-sets/route.ts
@@ -10,7 +10,7 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminCreateStockLocationFulfillmentSetType>,
   res: MedusaResponse
 ) => {
-  const { errors } = await createLocationFulfillmentSetWorkflow(req.scope).run({
+  await createLocationFulfillmentSetWorkflow(req.scope).run({
     input: {
       location_id: req.params.id,
       fulfillment_set_data: {
@@ -18,13 +18,8 @@ export const POST = async (
         type: req.validatedBody.type,
       },
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const stockLocation = await refetchStockLocation(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/stock-locations/[id]/route.ts b/packages/medusa/src/api/admin/stock-locations/[id]/route.ts
index 224b5b5a30..9029bf8949 100644
--- a/packages/medusa/src/api/admin/stock-locations/[id]/route.ts
+++ b/packages/medusa/src/api/admin/stock-locations/[id]/route.ts
@@ -65,15 +65,10 @@ export const DELETE = async (
 ) => {
   const { id } = req.params
 
-  const { errors } = await deleteStockLocationsWorkflow(req.scope).run({
+  await deleteStockLocationsWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "stock_location",
diff --git a/packages/medusa/src/api/admin/stock-locations/[id]/sales-channels/route.ts b/packages/medusa/src/api/admin/stock-locations/[id]/sales-channels/route.ts
index 1c9aa4029c..44f7d2da75 100644
--- a/packages/medusa/src/api/admin/stock-locations/[id]/sales-channels/route.ts
+++ b/packages/medusa/src/api/admin/stock-locations/[id]/sales-channels/route.ts
@@ -15,19 +15,14 @@ export const POST = async (
   const { add, remove } = req.validatedBody
 
   const workflow = linkSalesChannelsToStockLocationWorkflow(req.scope)
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       id,
       add,
       remove,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const stockLocation = await refetchStockLocation(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/stores/[id]/route.ts b/packages/medusa/src/api/admin/stores/[id]/route.ts
index a0944466a8..78285eae7f 100644
--- a/packages/medusa/src/api/admin/stores/[id]/route.ts
+++ b/packages/medusa/src/api/admin/stores/[id]/route.ts
@@ -32,18 +32,13 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminUpdateStoreType>,
   res: MedusaResponse
 ) => {
-  const { result, errors } = await updateStoresWorkflow(req.scope).run({
+  const { result } = await updateStoresWorkflow(req.scope).run({
     input: {
       selector: { id: req.params.id },
       update: req.validatedBody as UpdateStoreDTO,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const store = await refetchStore(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/tax-rates/[id]/route.ts b/packages/medusa/src/api/admin/tax-rates/[id]/route.ts
index ceea8720f4..0b5864077d 100644
--- a/packages/medusa/src/api/admin/tax-rates/[id]/route.ts
+++ b/packages/medusa/src/api/admin/tax-rates/[id]/route.ts
@@ -20,18 +20,13 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminUpdateTaxRateType>,
   res: MedusaResponse
 ) => {
-  const { errors } = await updateTaxRatesWorkflow(req.scope).run({
+  await updateTaxRatesWorkflow(req.scope).run({
     input: {
       selector: { id: req.params.id },
       update: { ...req.validatedBody, updated_by: req.auth_context.actor_id },
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const taxRate = await refetchTaxRate(
     req.params.id,
     req.scope,
@@ -62,15 +57,10 @@ export const DELETE = async (
   res: MedusaResponse
 ) => {
   const id = req.params.id
-  const { errors } = await deleteTaxRatesWorkflow(req.scope).run({
+  await deleteTaxRatesWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "tax_rate",
diff --git a/packages/medusa/src/api/admin/tax-rates/[id]/rules/[rule_id]/route.ts b/packages/medusa/src/api/admin/tax-rates/[id]/rules/[rule_id]/route.ts
index 8bb2aec0f9..b8b68ee9d2 100644
--- a/packages/medusa/src/api/admin/tax-rates/[id]/rules/[rule_id]/route.ts
+++ b/packages/medusa/src/api/admin/tax-rates/[id]/rules/[rule_id]/route.ts
@@ -9,15 +9,10 @@ export const DELETE = async (
   req: AuthenticatedMedusaRequest,
   res: MedusaResponse
 ) => {
-  const { errors } = await deleteTaxRateRulesWorkflow(req.scope).run({
+  await deleteTaxRateRulesWorkflow(req.scope).run({
     input: { ids: [req.params.rule_id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const taxRate = await refetchTaxRate(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/tax-rates/[id]/rules/route.ts b/packages/medusa/src/api/admin/tax-rates/[id]/rules/route.ts
index 09ce7d1981..b24535ed74 100644
--- a/packages/medusa/src/api/admin/tax-rates/[id]/rules/route.ts
+++ b/packages/medusa/src/api/admin/tax-rates/[id]/rules/route.ts
@@ -10,7 +10,7 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminCreateTaxRateRuleType>,
   res: MedusaResponse
 ) => {
-  const { errors } = await createTaxRateRulesWorkflow(req.scope).run({
+  await createTaxRateRulesWorkflow(req.scope).run({
     input: {
       rules: [
         {
@@ -20,13 +20,8 @@ export const POST = async (
         },
       ],
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const taxRate = await refetchTaxRate(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/tax-rates/route.ts b/packages/medusa/src/api/admin/tax-rates/route.ts
index 8bf64b302f..31ebd7c17d 100644
--- a/packages/medusa/src/api/admin/tax-rates/route.ts
+++ b/packages/medusa/src/api/admin/tax-rates/route.ts
@@ -17,20 +17,15 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminCreateTaxRateType>,
   res: MedusaResponse
 ) => {
-  const { result, errors } = await createTaxRatesWorkflow(req.scope).run({
+  const { result } = await createTaxRatesWorkflow(req.scope).run({
     input: [
       {
         ...req.validatedBody,
         created_by: req.auth_context.actor_id,
       },
     ],
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const taxRate = await refetchTaxRate(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/tax-regions/[id]/route.ts b/packages/medusa/src/api/admin/tax-regions/[id]/route.ts
index 4e4697953e..f42d013c24 100644
--- a/packages/medusa/src/api/admin/tax-regions/[id]/route.ts
+++ b/packages/medusa/src/api/admin/tax-regions/[id]/route.ts
@@ -32,15 +32,10 @@ export const DELETE = async (
 ) => {
   const id = req.params.id
 
-  const { errors } = await deleteTaxRegionsWorkflow(req.scope).run({
+  await deleteTaxRegionsWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "tax_region",
diff --git a/packages/medusa/src/api/admin/tax-regions/route.ts b/packages/medusa/src/api/admin/tax-regions/route.ts
index 055e46e8d0..32ac89b019 100644
--- a/packages/medusa/src/api/admin/tax-regions/route.ts
+++ b/packages/medusa/src/api/admin/tax-regions/route.ts
@@ -17,20 +17,15 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminCreateTaxRegionType>,
   res: MedusaResponse
 ) => {
-  const { result, errors } = await createTaxRegionsWorkflow(req.scope).run({
+  const { result } = await createTaxRegionsWorkflow(req.scope).run({
     input: [
       {
         ...req.validatedBody,
         created_by: req.auth_context.actor_id,
       },
     ],
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const taxRegion = await refetchTaxRegion(
     result[0].id,
     req.scope,
diff --git a/packages/medusa/src/api/admin/uploads/[id]/route.ts b/packages/medusa/src/api/admin/uploads/[id]/route.ts
index f88d1cb310..2a2bfccfc6 100644
--- a/packages/medusa/src/api/admin/uploads/[id]/route.ts
+++ b/packages/medusa/src/api/admin/uploads/[id]/route.ts
@@ -36,15 +36,10 @@ export const DELETE = async (
 ) => {
   const id = req.params.id
 
-  const { errors } = await deleteFilesWorkflow(req.scope).run({
+  await deleteFilesWorkflow(req.scope).run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "file",
diff --git a/packages/medusa/src/api/admin/uploads/route.ts b/packages/medusa/src/api/admin/uploads/route.ts
index 7373964877..9db8b1c96b 100644
--- a/packages/medusa/src/api/admin/uploads/route.ts
+++ b/packages/medusa/src/api/admin/uploads/route.ts
@@ -19,7 +19,7 @@ export const POST = async (
     )
   }
 
-  const { result, errors } = await uploadFilesWorkflow(req.scope).run({
+  const { result } = await uploadFilesWorkflow(req.scope).run({
     input: {
       files: input?.map((f) => ({
         filename: f.originalname,
@@ -27,12 +27,7 @@ export const POST = async (
         content: f.buffer.toString("binary"),
       })),
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({ files: result })
 }
diff --git a/packages/medusa/src/api/admin/users/[id]/route.ts b/packages/medusa/src/api/admin/users/[id]/route.ts
index 1241ec204a..40433c212a 100644
--- a/packages/medusa/src/api/admin/users/[id]/route.ts
+++ b/packages/medusa/src/api/admin/users/[id]/route.ts
@@ -73,15 +73,10 @@ export const DELETE = async (
   const { id } = req.params
   const workflow = deleteUsersWorkflow(req.scope)
 
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: { ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({
     id,
     object: "user",
diff --git a/packages/medusa/src/api/admin/users/route.ts b/packages/medusa/src/api/admin/users/route.ts
index 90e4b93c3b..60078c000c 100644
--- a/packages/medusa/src/api/admin/users/route.ts
+++ b/packages/medusa/src/api/admin/users/route.ts
@@ -53,16 +53,9 @@ export const POST = async (
       userData: req.validatedBody,
       authIdentityId: req.auth_context.auth_identity_id,
     },
-    throwOnError: false,
   }
 
-  const { result, errors } = await createUserAccountWorkflow(req.scope).run(
-    input
-  )
-
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
+  const { result } = await createUserAccountWorkflow(req.scope).run(input)
 
   const { http } = req.scope.resolve(
     ContainerRegistrationKeys.CONFIG_MODULE
diff --git a/packages/medusa/src/api/admin/workflows-executions/[workflow_id]/run/route.ts b/packages/medusa/src/api/admin/workflows-executions/[workflow_id]/run/route.ts
index 1e95da82b9..9124b073f3 100644
--- a/packages/medusa/src/api/admin/workflows-executions/[workflow_id]/run/route.ts
+++ b/packages/medusa/src/api/admin/workflows-executions/[workflow_id]/run/route.ts
@@ -28,7 +28,6 @@ export const POST = async (
     context: {
       requestId: req.requestId,
     },
-    throwOnError: false,
   } as WorkflowOrchestratorTypes.WorkflowOrchestratorRunDTO
 
   const { acknowledgement } = await workflowEngineService.run(
diff --git a/packages/medusa/src/api/store/carts/[id]/complete/route.ts b/packages/medusa/src/api/store/carts/[id]/complete/route.ts
index 17e53623a9..3604c56015 100644
--- a/packages/medusa/src/api/store/carts/[id]/complete/route.ts
+++ b/packages/medusa/src/api/store/carts/[id]/complete/route.ts
@@ -22,7 +22,7 @@ export const POST = async (
   // When an error occurs on the workflow, its potentially got to with cart validations, payments
   // or inventory checks. Return the cart here along with errors for the consumer to take more action
   // and fix them
-  if (Array.isArray(errors) && errors[0]) {
+  if (errors?.[0]) {
     const error = errors[0].error
     const statusOKErrors: string[] = [
       // TODO: add inventory specific errors
diff --git a/packages/medusa/src/api/store/carts/[id]/line-items/[line_id]/route.ts b/packages/medusa/src/api/store/carts/[id]/line-items/[line_id]/route.ts
index 2286fcab48..1244c030cf 100644
--- a/packages/medusa/src/api/store/carts/[id]/line-items/[line_id]/route.ts
+++ b/packages/medusa/src/api/store/carts/[id]/line-items/[line_id]/route.ts
@@ -45,15 +45,10 @@ export const POST = async (
     update: req.validatedBody,
   }
 
-  const { errors } = await updateLineItemInCartWorkflow(req.scope).run({
+  await updateLineItemInCartWorkflow(req.scope).run({
     input,
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const updatedCart = await refetchCart(
     req.params.id,
     req.scope,
@@ -69,15 +64,10 @@ export const DELETE = async (
 ) => {
   const id = req.params.line_id
 
-  const { errors } = await deleteLineItemsWorkflow(req.scope).run({
+  await deleteLineItemsWorkflow(req.scope).run({
     input: { cart_id: req.params.id, ids: [id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const cart = await refetchCart(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/store/carts/[id]/line-items/route.ts b/packages/medusa/src/api/store/carts/[id]/line-items/route.ts
index 694137c2a0..dd0275a180 100644
--- a/packages/medusa/src/api/store/carts/[id]/line-items/route.ts
+++ b/packages/medusa/src/api/store/carts/[id]/line-items/route.ts
@@ -18,15 +18,10 @@ export const POST = async (
     cart,
   }
 
-  const { errors } = await addToCartWorkflow(req.scope).run({
+  await addToCartWorkflow(req.scope).run({
     input: workflowInput,
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const updatedCart = await refetchCart(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/store/carts/[id]/promotions/route.ts b/packages/medusa/src/api/store/carts/[id]/promotions/route.ts
index 4b79c4295f..f2ededec03 100644
--- a/packages/medusa/src/api/store/carts/[id]/promotions/route.ts
+++ b/packages/medusa/src/api/store/carts/[id]/promotions/route.ts
@@ -14,19 +14,14 @@ export const POST = async (
   const workflow = updateCartPromotionsWorkflow(req.scope)
   const payload = req.validatedBody
 
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       promoCodes: payload.promo_codes,
       cartId: req.params.id,
       action: PromotionActions.ADD,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const cart = await refetchCart(
     req.params.id,
     req.scope,
@@ -43,19 +38,14 @@ export const DELETE = async (
   const workflow = updateCartPromotionsWorkflow(req.scope)
   const payload = req.validatedBody
 
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       promoCodes: payload.promo_codes,
       cartId: req.params.id,
       action: PromotionActions.REMOVE,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const cart = await refetchCart(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/store/carts/[id]/route.ts b/packages/medusa/src/api/store/carts/[id]/route.ts
index bbd49bef27..56e79b2fae 100644
--- a/packages/medusa/src/api/store/carts/[id]/route.ts
+++ b/packages/medusa/src/api/store/carts/[id]/route.ts
@@ -20,18 +20,13 @@ export const POST = async (
 ) => {
   const workflow = updateCartWorkflow(req.scope)
 
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       ...(req.validatedBody as UpdateCartDataDTO),
       id: req.params.id,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const cart = await refetchCart(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/store/carts/[id]/shipping-methods/route.ts b/packages/medusa/src/api/store/carts/[id]/shipping-methods/route.ts
index 6414e38365..371fb6e7a4 100644
--- a/packages/medusa/src/api/store/carts/[id]/shipping-methods/route.ts
+++ b/packages/medusa/src/api/store/carts/[id]/shipping-methods/route.ts
@@ -10,18 +10,13 @@ export const POST = async (
   const workflow = addShippingMethodToWorkflow(req.scope)
   const payload = req.validatedBody
 
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       options: [{ id: payload.option_id, data: payload.data }],
       cart_id: req.params.id,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const cart = await refetchCart(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/store/carts/[id]/taxes/route.ts b/packages/medusa/src/api/store/carts/[id]/taxes/route.ts
index 75565db903..93213f514a 100644
--- a/packages/medusa/src/api/store/carts/[id]/taxes/route.ts
+++ b/packages/medusa/src/api/store/carts/[id]/taxes/route.ts
@@ -9,18 +9,13 @@ export const POST = async (
 ) => {
   const workflow = updateTaxLinesWorkflow(req.scope)
 
-  const { errors } = await workflow.run({
+  await workflow.run({
     input: {
       cart_or_cart_id: req.params.id,
       force_tax_calculation: true,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const cart = await refetchCart(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/store/carts/route.ts b/packages/medusa/src/api/store/carts/route.ts
index fad2f22855..e09fcc230f 100644
--- a/packages/medusa/src/api/store/carts/route.ts
+++ b/packages/medusa/src/api/store/carts/route.ts
@@ -15,15 +15,10 @@ export const POST = async (
     customer_id: req.auth_context?.actor_id,
   }
 
-  const { result, errors } = await createCartWorkflow(req.scope).run({
+  const { result } = await createCartWorkflow(req.scope).run({
     input: workflowInput,
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const cart = await refetchCart(
     result.id,
     req.scope,
diff --git a/packages/medusa/src/api/store/customers/me/addresses/[address_id]/route.ts b/packages/medusa/src/api/store/customers/me/addresses/[address_id]/route.ts
index 8e24ede288..a3928889a4 100644
--- a/packages/medusa/src/api/store/customers/me/addresses/[address_id]/route.ts
+++ b/packages/medusa/src/api/store/customers/me/addresses/[address_id]/route.ts
@@ -53,18 +53,13 @@ export const POST = async (
   await validateCustomerAddress(req.scope, id, req.params.address_id)
 
   const updateAddresses = updateCustomerAddressesWorkflow(req.scope)
-  const { errors } = await updateAddresses.run({
+  await updateAddresses.run({
     input: {
       selector: { id: req.params.address_id, customer_id: req.params.id },
       update: req.validatedBody,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const customer = await refetchCustomer(
     id,
     req.scope,
@@ -82,15 +77,10 @@ export const DELETE = async (
   await validateCustomerAddress(req.scope, id, req.params.address_id)
 
   const deleteAddress = deleteCustomerAddressesWorkflow(req.scope)
-  const { errors } = await deleteAddress.run({
+  await deleteAddress.run({
     input: { ids: [req.params.address_id] },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const customer = await refetchCustomer(
     id,
     req.scope,
diff --git a/packages/medusa/src/api/store/customers/me/addresses/route.ts b/packages/medusa/src/api/store/customers/me/addresses/route.ts
index 8c0c6a6a48..e51e5d3197 100644
--- a/packages/medusa/src/api/store/customers/me/addresses/route.ts
+++ b/packages/medusa/src/api/store/customers/me/addresses/route.ts
@@ -54,15 +54,10 @@ export const POST = async (
     },
   ]
 
-  const { errors } = await createAddresses.run({
+  await createAddresses.run({
     input: { addresses },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const customer = await refetchCustomer(
     customerId,
     req.scope,
diff --git a/packages/medusa/src/api/store/customers/me/route.ts b/packages/medusa/src/api/store/customers/me/route.ts
index fc2069cb6e..8bd180f186 100644
--- a/packages/medusa/src/api/store/customers/me/route.ts
+++ b/packages/medusa/src/api/store/customers/me/route.ts
@@ -37,18 +37,13 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const customerId = req.auth_context.actor_id
-  const { errors } = await updateCustomersWorkflow(req.scope).run({
+  await updateCustomersWorkflow(req.scope).run({
     input: {
       selector: { id: customerId },
       update: req.validatedBody,
     },
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const customer = await refetchCustomer(
     req.params.id,
     req.scope,
diff --git a/packages/medusa/src/api/store/customers/route.ts b/packages/medusa/src/api/store/customers/route.ts
index a6e7dbdcf6..1f466accf5 100644
--- a/packages/medusa/src/api/store/customers/route.ts
+++ b/packages/medusa/src/api/store/customers/route.ts
@@ -24,14 +24,10 @@ export const POST = async (
   const createCustomers = createCustomerAccountWorkflow(req.scope)
   const customersData = req.validatedBody
 
-  const { result, errors } = await createCustomers.run({
+  const { result } = await createCustomers.run({
     input: { customersData, authIdentityId: req.auth_context.auth_identity_id },
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const { http } = req.scope.resolve(
     ContainerRegistrationKeys.CONFIG_MODULE
   ).projectConfig
diff --git a/packages/medusa/src/api/store/payment-collections/[id]/payment-sessions/route.ts b/packages/medusa/src/api/store/payment-collections/[id]/payment-sessions/route.ts
index 184637da55..e11e455267 100644
--- a/packages/medusa/src/api/store/payment-collections/[id]/payment-sessions/route.ts
+++ b/packages/medusa/src/api/store/payment-collections/[id]/payment-sessions/route.ts
@@ -26,15 +26,10 @@ export const POST = async (
     context,
   }
 
-  const { errors } = await createPaymentSessionsWorkflow(req.scope).run({
+  await createPaymentSessionsWorkflow(req.scope).run({
     input: workflowInput,
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   const paymentCollection = await refetchPaymentCollection(
     collectionId,
     req.scope,
diff --git a/packages/medusa/src/api/store/payment-collections/route.ts b/packages/medusa/src/api/store/payment-collections/route.ts
index a1cacff58b..f1ddc9c628 100644
--- a/packages/medusa/src/api/store/payment-collections/route.ts
+++ b/packages/medusa/src/api/store/payment-collections/route.ts
@@ -29,16 +29,10 @@ export const POST = async (
   let paymentCollection = cartCollectionRelation?.payment_collection
 
   if (!paymentCollection) {
-    const { errors } = await createPaymentCollectionForCartWorkflow(
-      req.scope
-    ).run({
+    await createPaymentCollectionForCartWorkflow(req.scope).run({
       input: req.body,
     })
 
-    if (Array.isArray(errors) && errors[0]) {
-      throw errors[0].error
-    }
-
     const [cartCollectionRelation] = await remoteQuery(
       remoteQueryObjectFromString({
         entryPoint: "cart_payment_collection",
diff --git a/packages/medusa/src/api/store/return/route.ts b/packages/medusa/src/api/store/return/route.ts
index 587ed3b848..9d0db5cb50 100644
--- a/packages/medusa/src/api/store/return/route.ts
+++ b/packages/medusa/src/api/store/return/route.ts
@@ -9,14 +9,9 @@ export const POST = async (
   const input = req.validatedBody as StorePostReturnsReqSchemaType
 
   const workflow = createReturnOrderWorkflow(req.scope)
-  const { result, errors } = await workflow.run({
+  const { result } = await workflow.run({
     input,
-    throwOnError: false,
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.status(200).json({ return: result })
 }
diff --git a/packages/medusa/src/api/store/shipping-options/route.ts b/packages/medusa/src/api/store/shipping-options/route.ts
index 4f2e98136d..222bb70816 100644
--- a/packages/medusa/src/api/store/shipping-options/route.ts
+++ b/packages/medusa/src/api/store/shipping-options/route.ts
@@ -29,10 +29,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     relations: ["shipping_address"],
   })
 
-  const { result, errors } = await listShippingOptionsForCartWorkflow(
-    req.scope
-  ).run({
-    throwOnError: false,
+  const { result } = await listShippingOptionsForCartWorkflow(req.scope).run({
     input: {
       cart_id: cart.id,
       sales_channel_id: cart.sales_channel_id,
@@ -45,9 +42,5 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     },
   })
 
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
   res.json({ shipping_options: result })
 }