feat: Clean up shipping options management (#6977)

**What**
- cleanup existing route on some aspects but not all
- add new create shipping options end point and types
- add set of integration tests
- cleanup existing fulfillment routes
- align existing integration tests
- transform old type to zod types and validators
- fix stock location route

packages/medusa/src/api-v2/admin/fulfillment/middlewares.ts

@@ -1,29 +0,0 @@
-import { transformBody } from "../../../api/middlewares"
-import { MiddlewareRoute } from "../../../loaders/helpers/routing/types"
-import { authenticate } from "../../../utils/authenticate-middleware"
-import {
-  AdminPostFulfillmentShippingOptionsRulesBatchAddReq,
-  AdminPostFulfillmentShippingOptionsRulesBatchRemoveReq,
-} from "./validators"
-
-export const adminFulfillmentRoutesMiddlewares: MiddlewareRoute[] = [
-  {
-    matcher: "/admin/fulfillment*",
-    middlewares: [authenticate("admin", ["bearer", "session"])],
-  },
-  {
-    method: ["POST"],
-    matcher: "/admin/fulfillment/shipping-options/:id/rules/batch/add",
-    middlewares: [
-      transformBody(AdminPostFulfillmentShippingOptionsRulesBatchAddReq),
-    ],
-  },
-
-  {
-    method: ["POST"],
-    matcher: "/admin/fulfillment/shipping-options/:id/rules/batch/remove",
-    middlewares: [
-      transformBody(AdminPostFulfillmentShippingOptionsRulesBatchRemoveReq),
-    ],
-  },
-]

packages/medusa/src/api-v2/admin/fulfillment/query-config.ts

@@ -1,29 +0,0 @@
-export const defaultAdminShippingOptionRelations = ["rules"]
-export const allowedAdminShippingOptionRelations = [
-  ...defaultAdminShippingOptionRelations,
-]
-export const defaultAdminShippingOptionFields = [
-  "id",
-  "name",
-  "price_type",
-  "data",
-  "metadata",
-  "created_at",
-  "updated_at",
-  "rules.id",
-  "rules.attribute",
-  "rules.operator",
-  "rules.value",
-]
-
-export const retrieveTransformQueryConfig = {
-  defaultFields: defaultAdminShippingOptionFields,
-  defaultRelations: defaultAdminShippingOptionRelations,
-  allowedRelations: allowedAdminShippingOptionRelations,
-  isList: false,
-}
-
-export const listTransformQueryConfig = {
-  ...retrieveTransformQueryConfig,
-  isList: true,
-}

packages/medusa/src/api-v2/admin/fulfillment/shipping-options/[id]/rules/batch/add/route.ts

@@ -1,45 +0,0 @@
-import { addRulesToFulfillmentShippingOptionWorkflow } from "@medusajs/core-flows"
-import { ModuleRegistrationName } from "@medusajs/modules-sdk"
-import { IFulfillmentModuleService } from "@medusajs/types"
-import {
-  AuthenticatedMedusaRequest,
-  MedusaResponse,
-} from "../../../../../../../../types/routing"
-import {
-  defaultAdminShippingOptionFields,
-  defaultAdminShippingOptionRelations,
-} from "../../../../../query-config"
-import { AdminPostFulfillmentShippingOptionsRulesBatchAddReq } from "../../../../../validators"
-
-export const POST = async (
-  req: AuthenticatedMedusaRequest<AdminPostFulfillmentShippingOptionsRulesBatchAddReq>,
-  res: MedusaResponse
-) => {
-  const id = req.params.id
-  const workflow = addRulesToFulfillmentShippingOptionWorkflow(req.scope)
-
-  const { errors } = await workflow.run({
-    input: {
-      data: req.validatedBody.rules.map((rule) => ({
-        ...rule,
-        shipping_option_id: id,
-      })),
-    },
-    throwOnError: false,
-  })
-
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
-  const fulfillmentService: IFulfillmentModuleService = req.scope.resolve(
-    ModuleRegistrationName.FULFILLMENT
-  )
-
-  const shippingOption = await fulfillmentService.retrieveShippingOption(id, {
-    select: defaultAdminShippingOptionFields,
-    relations: defaultAdminShippingOptionRelations,
-  })
-
-  res.status(200).json({ shipping_option: shippingOption })
-}

packages/medusa/src/api-v2/admin/fulfillment/shipping-options/[id]/rules/batch/remove/route.ts

@@ -1,40 +0,0 @@
-import { removeRulesFromFulfillmentShippingOptionWorkflow } from "@medusajs/core-flows"
-import { ModuleRegistrationName } from "@medusajs/modules-sdk"
-import { IFulfillmentModuleService } from "@medusajs/types"
-import {
-  AuthenticatedMedusaRequest,
-  MedusaResponse,
-} from "../../../../../../../../types/routing"
-import {
-  defaultAdminShippingOptionFields,
-  defaultAdminShippingOptionRelations,
-} from "../../../../../query-config"
-import { AdminPostFulfillmentShippingOptionsRulesBatchRemoveReq } from "../../../../../validators"
-
-export const POST = async (
-  req: AuthenticatedMedusaRequest<AdminPostFulfillmentShippingOptionsRulesBatchRemoveReq>,
-  res: MedusaResponse
-) => {
-  const id = req.params.id
-  const workflow = removeRulesFromFulfillmentShippingOptionWorkflow(req.scope)
-
-  const { errors } = await workflow.run({
-    input: { ids: req.validatedBody.rule_ids },
-    throwOnError: false,
-  })
-
-  if (Array.isArray(errors) && errors[0]) {
-    throw errors[0].error
-  }
-
-  const fulfillmentService: IFulfillmentModuleService = req.scope.resolve(
-    ModuleRegistrationName.FULFILLMENT
-  )
-
-  const shippingOption = await fulfillmentService.retrieveShippingOption(id, {
-    select: defaultAdminShippingOptionFields,
-    relations: defaultAdminShippingOptionRelations,
-  })
-
-  res.status(200).json({ shipping_option: shippingOption })
-}

packages/medusa/src/api-v2/admin/fulfillment/validators.ts

@@ -1,36 +0,0 @@
-import { RuleOperator } from "@medusajs/utils"
-import { Type } from "class-transformer"
-import {
-  ArrayNotEmpty,
-  IsArray,
-  IsEnum,
-  IsNotEmpty,
-  IsString,
-  ValidateNested,
-} from "class-validator"
-import { IsType } from "../../../utils"
-
-export class AdminPostFulfillmentShippingOptionsRulesBatchAddReq {
-  @IsArray()
-  @ValidateNested({ each: true })
-  @Type(() => FulfillmentRuleCreate)
-  rules: FulfillmentRuleCreate[]
-}
-
-export class AdminPostFulfillmentShippingOptionsRulesBatchRemoveReq {
-  @ArrayNotEmpty()
-  @IsString({ each: true })
-  rule_ids: string[]
-}
-
-export class FulfillmentRuleCreate {
-  @IsEnum(RuleOperator)
-  operator: RuleOperator
-
-  @IsNotEmpty()
-  @IsString()
-  attribute: string
-
-  @IsType([String, [String]])
-  value: string | string[]
-}

packages/medusa/src/api-v2/admin/inventory-items/route.ts

@@ -27,7 +27,7 @@ export const POST = async (
       variables: {
         id: result[0].id,
       },
-      fields: req.retrieveConfig.select as string[],
+      fields: req.remoteQueryConfig.fields,
     })
   )
 
@@ -45,11 +45,9 @@ export const GET = async (
     entryPoint: "inventory_items",
     variables: {
       filters: req.filterableFields,
-      order: req.listConfig.order,
-      skip: req.listConfig.skip,
-      take: req.listConfig.take,
+      ...req.remoteQueryConfig.pagination,
     },
-    fields: [...(req.listConfig.select as string[])],
+    fields: req.remoteQueryConfig.fields,
   })
 
   const { rows: inventory_items, metadata } = await remoteQuery({

packages/medusa/src/api-v2/admin/shipping-options/[id]/rules/batch/add/route.ts

@@ -0,0 +1,48 @@
+import { addRulesToFulfillmentShippingOptionWorkflow } from "@medusajs/core-flows"
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import { AdminShippingOptionRetrieveResponse } from "@medusajs/types"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../../../../types/routing"
+import { AdminShippingOptionRulesBatchAddType } from "../../../../validators"
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest<
+    AdminShippingOptionRulesBatchAddType
+  >,
+  res: MedusaResponse<AdminShippingOptionRetrieveResponse>
+) => {
+  const id = req.params.id
+  const workflow = addRulesToFulfillmentShippingOptionWorkflow(req.scope)
+
+  const { errors } = await workflow.run({
+    input: {
+      data: req.validatedBody.rules.map((rule) => ({
+        ...rule,
+        shipping_option_id: id,
+      })),
+    },
+    throwOnError: false,
+  })
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  const query = remoteQueryObjectFromString({
+    entryPoint: "shipping_options",
+    variables: {
+      id: req.params.id,
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+  const [shippingOption] = await remoteQuery(query)
+
+  res.status(200).json({ shipping_option: shippingOption })
+}

packages/medusa/src/api-v2/admin/shipping-options/[id]/rules/batch/remove/route.ts

@@ -0,0 +1,40 @@
+import { removeRulesFromFulfillmentShippingOptionWorkflow } from "@medusajs/core-flows"
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import { AdminShippingOptionRetrieveResponse } from "@medusajs/types"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../../../../types/routing"
+import { AdminShippingOptionRulesBatchRemoveType } from "../../../../validators"
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest<AdminShippingOptionRulesBatchRemoveType>,
+  res: MedusaResponse<AdminShippingOptionRetrieveResponse>
+) => {
+  const workflow = removeRulesFromFulfillmentShippingOptionWorkflow(req.scope)
+
+  const { errors } = await workflow.run({
+    input: { ids: req.validatedBody.rule_ids },
+    throwOnError: false,
+  })
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  const query = remoteQueryObjectFromString({
+    entryPoint: "shipping_options",
+    variables: {
+      id: req.params.id,
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+  const [shippingOption] = await remoteQuery(query)
+
+  res.status(200).json({ shipping_option: shippingOption })
+}

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

@@ -0,0 +1,54 @@
+import { MiddlewareRoute } from "../../../loaders/helpers/routing/types"
+import { authenticate } from "../../../utils/authenticate-middleware"
+import {
+  AdminCreateShippingOption,
+  AdminGetShippingOptionParams,
+  AdminShippingOptionRulesBatchAdd,
+  AdminShippingOptionRulesBatchRemove,
+} from "./validators"
+import { retrieveTransformQueryConfig } from "./query-config"
+import { validateAndTransformBody } from "../../utils/validate-body"
+import { validateAndTransformQuery } from "../../utils/validate-query"
+
+export const adminShippingOptionRoutesMiddlewares: MiddlewareRoute[] = [
+  {
+    matcher: "/admin/shipping-options*",
+    middlewares: [authenticate("admin", ["bearer", "session"])],
+  },
+
+  {
+    method: ["POST"],
+    matcher: "/admin/shipping-options",
+    middlewares: [
+      validateAndTransformQuery(
+        AdminGetShippingOptionParams,
+        retrieveTransformQueryConfig
+      ),
+      validateAndTransformBody(AdminCreateShippingOption),
+    ],
+  },
+
+  {
+    method: ["POST"],
+    matcher: "/admin/shipping-options/:id/rules/batch/add",
+    middlewares: [
+      validateAndTransformQuery(
+        AdminGetShippingOptionParams,
+        retrieveTransformQueryConfig
+      ),
+      validateAndTransformBody(AdminShippingOptionRulesBatchAdd),
+    ],
+  },
+
+  {
+    method: ["POST"],
+    matcher: "/admin/shipping-options/:id/rules/batch/remove",
+    middlewares: [
+      validateAndTransformQuery(
+        AdminGetShippingOptionParams,
+        retrieveTransformQueryConfig
+      ),
+      validateAndTransformBody(AdminShippingOptionRulesBatchRemove),
+    ],
+  },
+]

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

@@ -0,0 +1,25 @@
+export const defaultAdminShippingOptionFields = [
+  "id",
+  "name",
+  "price_type",
+  "data",
+  "metadata",
+  "created_at",
+  "updated_at",
+  "*rules",
+  "*type",
+  "*prices",
+  "*service_zone",
+  "*shipping_profile",
+  "*provider",
+]
+
+export const retrieveTransformQueryConfig = {
+  defaults: defaultAdminShippingOptionFields,
+  isList: false,
+}
+
+export const listTransformQueryConfig = {
+  ...retrieveTransformQueryConfig,
+  isList: true,
+}

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

@@ -0,0 +1,44 @@
+import { createShippingOptionsWorkflow } from "@medusajs/core-flows"
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import { AdminShippingOptionRetrieveResponse } from "@medusajs/types"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../types/routing"
+import { AdminCreateShippingOptionType } from "./validators"
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest<AdminCreateShippingOptionType>,
+  res: MedusaResponse<AdminShippingOptionRetrieveResponse>
+) => {
+  const shippingOptionPayload = req.validatedBody
+
+  const workflow = createShippingOptionsWorkflow(req.scope)
+
+  const { result, errors } = await workflow.run({
+    input: [shippingOptionPayload],
+    throwOnError: false,
+  })
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  const shippingOptionId = result[0].id
+
+  const query = remoteQueryObjectFromString({
+    entryPoint: "shipping_options",
+    variables: {
+      id: shippingOptionId,
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+  const [shippingOption] = await remoteQuery(query)
+
+  res.status(200).json({ shipping_option: shippingOption })
+}

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

@@ -0,0 +1,87 @@
+import {
+  RuleOperator,
+  ShippingOptionPriceType as ShippingOptionPriceTypeEnum,
+} from "@medusajs/utils"
+import { z } from "zod"
+import { createSelectParams } from "../../utils/validators"
+
+export const AdminGetShippingOptionParams = createSelectParams()
+
+/**
+ * SHIPPING OPTIONS RULES
+ */
+
+export const AdminCreateShippingOptionRule = z
+  .object({
+    operator: z.nativeEnum(RuleOperator),
+    attribute: z.string(),
+    value: z.string().or(z.array(z.string())),
+  })
+  .strict()
+
+export const AdminShippingOptionRulesBatchAdd = z
+  .object({
+    rules: AdminCreateShippingOptionRule.array(),
+  })
+  .strict()
+
+export type AdminShippingOptionRulesBatchAddType = z.infer<
+  typeof AdminShippingOptionRulesBatchAdd
+>
+
+export const AdminShippingOptionRulesBatchRemove = z
+  .object({
+    rule_ids: z.array(z.string()),
+  })
+  .strict()
+
+export type AdminShippingOptionRulesBatchRemoveType = z.infer<
+  typeof AdminShippingOptionRulesBatchRemove
+>
+
+/**
+ * SHIPPING OPTIONS
+ */
+
+export const AdminCreateShippingOptionType = z
+  .object({
+    label: z.string(),
+    description: z.string(),
+    code: z.string(),
+  })
+  .strict()
+
+// eslint-disable-next-line max-len
+export const AdminCreateShippingOptionPriceWithCurrency = z
+  .object({
+    currency_code: z.string(),
+    amount: z.number(),
+  })
+  .strict()
+
+export const AdminCreateShippingOptionPriceWithRegion = z
+  .object({
+    region_id: z.string(),
+    amount: z.number(),
+  })
+  .strict()
+
+export const AdminCreateShippingOption = z
+  .object({
+    name: z.string(),
+    service_zone_id: z.string(),
+    shipping_profile_id: z.string(),
+    data: z.record(z.unknown()).optional(),
+    price_type: z.nativeEnum(ShippingOptionPriceTypeEnum),
+    provider_id: z.string(),
+    type: AdminCreateShippingOptionType,
+    prices: AdminCreateShippingOptionPriceWithCurrency.or(
+      AdminCreateShippingOptionPriceWithRegion
+    ).array(),
+    rules: AdminCreateShippingOptionRule.array().optional(),
+  })
+  .strict()
+
+export type AdminCreateShippingOptionType = z.infer<
+  typeof AdminCreateShippingOption
+>

packages/medusa/src/api-v2/middlewares.ts

@@ -5,8 +5,8 @@ import { adminCollectionRoutesMiddlewares } from "./admin/collections/middleware
 import { adminCurrencyRoutesMiddlewares } from "./admin/currencies/middlewares"
 import { adminCustomerGroupRoutesMiddlewares } from "./admin/customer-groups/middlewares"
 import { adminCustomerRoutesMiddlewares } from "./admin/customers/middlewares"
+import { adminShippingOptionRoutesMiddlewares } from "./admin/shipping-options/middlewares"
 import { adminDraftOrderRoutesMiddlewares } from "./admin/draft-orders/middlewares"
-import { adminFulfillmentRoutesMiddlewares } from "./admin/fulfillment/middlewares"
 import { adminInventoryRoutesMiddlewares } from "./admin/inventory-items/middlewares"
 import { adminInviteRoutesMiddlewares } from "./admin/invites/middlewares"
 import { adminPaymentRoutesMiddlewares } from "./admin/payments/middlewares"
@@ -59,7 +59,7 @@ export const config: MiddlewaresConfig = {
     ...adminInventoryRoutesMiddlewares,
     ...adminCollectionRoutesMiddlewares,
     ...adminPricingRoutesMiddlewares,
-    ...adminFulfillmentRoutesMiddlewares,
+    ...adminShippingOptionRoutesMiddlewares,
     ...adminDraftOrderRoutesMiddlewares,
     ...adminSalesChannelRoutesMiddlewares,
     ...adminStockLocationRoutesMiddlewares,

packages/medusa/src/api-v2/store/payment-collections/[id]/payment-sessions/route.ts

@@ -12,7 +12,7 @@ export const POST = async (
   res: MedusaResponse
 ) => {
   const { id } = req.params
-  const { context, provider_id, data } = req.body
+  const { context = {}, provider_id, data } = req.body
 
   // If the customer is logged in, we auto-assign them to the payment collection
   if (req.auth?.actor_id) {

packages/medusa/src/types/routing.ts

@@ -3,8 +3,10 @@ import type { Customer, User } from "../models"
 
 import { MedusaContainer, RequestQueryFields } from "@medusajs/types"
 import { FindConfig } from "./common"
+import * as core from "express-serve-static-core"
 
-export interface MedusaRequest<Body = unknown> extends Request {
+export interface MedusaRequest<Body = unknown>
+  extends Request<core.ParamsDictionary, any, Body> {
   validatedBody: Body
   validatedQuery: RequestQueryFields & Record<string, unknown>
   /**
@@ -22,7 +24,10 @@ export interface MedusaRequest<Body = unknown> extends Request {
   /**
    * An object containing fields and variables to be used with the remoteQuery
    */
-  remoteQueryConfig: { fields: string[]; pagination: { order?: Record<string, string>, skip?: number, take?: number } }
+  remoteQueryConfig: {
+    fields: string[]
+    pagination: { order?: Record<string, string>; skip?: number; take?: number }
+  }
   /**
    * An object containing the fields that are filterable e.g `{ id: Any<String> }`
    */
@@ -58,12 +63,12 @@ export interface AuthenticatedMedusaRequest<Body = never>
   }
 }
 
-export type MedusaResponse = Response
+export type MedusaResponse<Body = unknown> = Response<Body>
 
 export type MedusaNextFunction = NextFunction
 
-export type MedusaRequestHandler = (
-  req: MedusaRequest<unknown>,
-  res: MedusaResponse,
+export type MedusaRequestHandler<Body = unknown, Res = unknown> = (
+  req: MedusaRequest<Body>,
+  res: MedusaResponse<Res>,
   next: MedusaNextFunction
 ) => Promise<void> | void

packages/types/src/http/fulfillment/admin/shipping-option.ts

@@ -4,12 +4,12 @@ import { AdminShippingOptionTypeResponse } from "./shipping-option-type"
 import { AdminShippingOptionRuleResponse } from "./shipping-option-rule"
 import { AdminShippingProfileResponse } from "./shipping-profile"
 import { AdminFulfillmentProviderResponse } from "./fulfillment-provider"
-import { AdminFulfillmentResponse } from "./fulfillment"
+import { AdminPriceSetPriceResponse } from "../../pricing"
 
 /**
  * @experimental
  */
-export interface AdminShippingOptionResponse {
+interface AdminShippingOptionResponse {
   id: string
   name: string
   price_type: ShippingOptionPriceType
@@ -21,11 +21,18 @@ export interface AdminShippingOptionResponse {
   metadata: Record<string, unknown> | null
   service_zone: AdminServiceZoneResponse
   shipping_profile: AdminShippingProfileResponse
-  fulfillment_provider: AdminFulfillmentProviderResponse
+  provider: AdminFulfillmentProviderResponse
   type: AdminShippingOptionTypeResponse
   rules: AdminShippingOptionRuleResponse[]
-  fulfillments: AdminFulfillmentResponse[]
+  prices: AdminPriceSetPriceResponse[]
   created_at: Date
   updated_at: Date
   deleted_at: Date | null
 }
+
+/**
+ * @experimental
+ */
+export interface AdminShippingOptionRetrieveResponse {
+  shipping_option: AdminShippingOptionResponse[]
+}

packages/types/src/http/index.ts

@@ -1,4 +1,5 @@
 export * from "./api-key"
 export * from "./fulfillment"
+export * from "./pricing"
 export * from "./sales-channel"
 export * from "./stock-locations"

packages/types/src/http/pricing/index.ts

@@ -0,0 +1 @@
+export * from "./price"

packages/types/src/http/pricing/price.ts

@@ -0,0 +1,7 @@
+export interface AdminPriceSetPriceResponse {
+  id: string
+  amount: number
+  currency_code: string
+  created_at: string
+  updated_at: string
+}