Chore(order): endpoints - Part 1:N (#7360)

packages/medusa/src/api-v2/admin/orders/[id]/archive/route.ts

@@ -0,0 +1,34 @@
+import { archiveOrderWorkflow } from "@medusajs/core-flows"
+import { remoteQueryObjectFromString } from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../../types/routing"
+import { AdminArchiveOrderType } from "../../validators"
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest<AdminArchiveOrderType>,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve("remoteQuery")
+  const { id } = req.params
+
+  const { errors } = await archiveOrderWorkflow(req.scope).run({
+    input: { order_ids: [req.validatedBody.order_id] },
+    throwOnError: false,
+  })
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order",
+    variables: { id },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [order] = await remoteQuery(queryObject)
+
+  res.status(200).json({ order })
+}

packages/medusa/src/api-v2/admin/orders/[id]/cancel/route.ts

@@ -0,0 +1,25 @@
+import { remoteQueryObjectFromString } from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../../types/routing"
+
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve("remoteQuery")
+
+  const variables = { id: req.params.id }
+
+  // TODO: cancel order - v1.x - packages/medusa/src/api/routes/admin/orders/cancel-order.ts
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order",
+    variables,
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [order] = await remoteQuery(queryObject)
+  res.status(200).json({ order })
+}

packages/medusa/src/api-v2/admin/orders/[id]/complete/route.ts

@@ -0,0 +1,34 @@
+import { completeOrderWorkflow } from "@medusajs/core-flows"
+import { remoteQueryObjectFromString } from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../../types/routing"
+import { AdminCompleteOrderType } from "../../validators"
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest<AdminCompleteOrderType>,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve("remoteQuery")
+  const { id } = req.params
+
+  const { errors } = await completeOrderWorkflow(req.scope).run({
+    input: { order_ids: [req.validatedBody.order_id] },
+    throwOnError: false,
+  })
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order",
+    variables: { id },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [order] = await remoteQuery(queryObject)
+
+  res.status(200).json({ order })
+}

packages/medusa/src/api-v2/admin/orders/[id]/refund/route.ts

@@ -0,0 +1,19 @@
+import { remoteQueryObjectFromString } from "@medusajs/utils"
+import { MedusaRequest, MedusaResponse } from "../../../../../types/routing"
+
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const remoteQuery = req.scope.resolve("remoteQuery")
+
+  const variables = { id: req.params.id }
+
+  // TODO: refund payment - v1.x - packages/medusa/src/api/routes/admin/orders/refund-payment.ts
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order",
+    variables,
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [order] = await remoteQuery(queryObject)
+  res.status(200).json({ order })
+}

packages/medusa/src/api-v2/admin/orders/[id]/route.ts

@@ -1,7 +1,13 @@
 import { remoteQueryObjectFromString } from "@medusajs/utils"
-import { MedusaRequest, MedusaResponse } from "../../../../types/routing"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../types/routing"
 
-export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
   const remoteQuery = req.scope.resolve("remoteQuery")
 
   const variables = { id: req.params.id }
@@ -15,3 +21,23 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
   const [order] = await remoteQuery(queryObject)
   res.status(200).json({ order })
 }
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve("remoteQuery")
+
+  const variables = { id: req.params.id }
+
+  // TODO: update order
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order",
+    variables,
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [order] = await remoteQuery(queryObject)
+  res.status(200).json({ order })
+}

packages/medusa/src/api-v2/admin/orders/fulfillments/[fulfillment_id]/cancel/route.ts

@@ -0,0 +1,25 @@
+import { remoteQueryObjectFromString } from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../../../types/routing"
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve("remoteQuery")
+
+  const variables = { id: req.params.id }
+
+  // TODO: Workflow to cancel fulfillment + adjust inventory
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order",
+    variables,
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [order] = await remoteQuery(queryObject)
+  res.status(200).json({ order })
+}

packages/medusa/src/api-v2/admin/orders/fulfillments/route.ts

@@ -0,0 +1,25 @@
+import { remoteQueryObjectFromString } from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../types/routing"
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve("remoteQuery")
+
+  const variables = { id: req.params.id }
+
+  // TODO: Workflow fulfill items, create fulfillments and adjust inventory - v1.x - packages/medusa/src/api/routes/admin/orders/create-fulfillment.ts
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order",
+    variables,
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [order] = await remoteQuery(queryObject)
+  res.status(200).json({ order })
+}

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

@@ -1,8 +1,14 @@
 import { MiddlewareRoute } from "../../../loaders/helpers/routing/types"
 import { authenticate } from "../../../utils/middlewares/authenticate-middleware"
+import { validateAndTransformBody } from "../../utils/validate-body"
 import { validateAndTransformQuery } from "../../utils/validate-query"
 import * as QueryConfig from "./query-config"
-import { AdminGetOrdersOrderParams, AdminGetOrdersParams } from "./validators"
+import {
+  AdminArchiveOrder,
+  AdminCompleteOrder,
+  AdminGetOrdersOrderParams,
+  AdminGetOrdersParams,
+} from "./validators"
 
 export const adminOrderRoutesMiddlewares: MiddlewareRoute[] = [
   {
@@ -30,4 +36,60 @@ export const adminOrderRoutesMiddlewares: MiddlewareRoute[] = [
       ),
     ],
   },
+  {
+    method: ["POST"],
+    matcher: "/admin/orders/:id/archive",
+    middlewares: [
+      validateAndTransformBody(AdminArchiveOrder),
+      validateAndTransformQuery(
+        AdminGetOrdersOrderParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["POST"],
+    matcher: "/admin/orders/:id/cancel",
+    middlewares: [
+      // validateAndTransformBody(),
+      validateAndTransformQuery(
+        AdminGetOrdersOrderParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["POST"],
+    matcher: "/admin/orders/:id/complete",
+    middlewares: [
+      validateAndTransformBody(AdminCompleteOrder),
+      validateAndTransformQuery(
+        AdminGetOrdersOrderParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+
+  {
+    method: ["POST"],
+    matcher: "/admin/orders/:id/fulfillments",
+    middlewares: [
+      // validateAndTransformBody(),
+      validateAndTransformQuery(
+        AdminGetOrdersOrderParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["POST"],
+    matcher: "/admin/orders/:id/fulfillments/cancel",
+    middlewares: [
+      // validateAndTransformBody(),
+      validateAndTransformQuery(
+        AdminGetOrdersOrderParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
 ]

packages/medusa/src/api-v2/admin/orders/route.ts

@@ -2,9 +2,15 @@ import {
   ContainerRegistrationKeys,
   remoteQueryObjectFromString,
 } from "@medusajs/utils"
-import { MedusaRequest, MedusaResponse } from "../../../types/routing"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../types/routing"
 
-export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
   const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
 
   const queryObject = remoteQueryObjectFromString({

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

@@ -36,3 +36,13 @@ export const AdminGetOrdersParams = createFindParams({
 )
 
 export type AdminGetOrdersParamsType = z.infer<typeof AdminGetOrdersParams>
+
+export const AdminArchiveOrder = z.object({
+  order_id: z.string(),
+})
+export type AdminArchiveOrderType = z.infer<typeof AdminArchiveOrder>
+
+export const AdminCompleteOrder = z.object({
+  order_id: z.string(),
+})
+export type AdminCompleteOrderType = z.infer<typeof AdminArchiveOrder>

packages/medusa/src/api-v2/admin/return-reasons/[id]/route.ts

@@ -0,0 +1,84 @@
+import {
+  deleteReturnReasonsWorkflow,
+  updateReturnReasonsWorkflow,
+} from "@medusajs/core-flows"
+import { UpdateOrderReturnReasonDTO } from "@medusajs/types"
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../types/routing"
+
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  const variables = { id: req.params.id }
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "return_reason",
+    variables,
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [return_reason] = await remoteQuery(queryObject)
+
+  res.json({ return_reason })
+}
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest<UpdateOrderReturnReasonDTO>,
+  res: MedusaResponse
+) => {
+  const workflow = updateReturnReasonsWorkflow(req.scope)
+
+  const { id } = req.params
+  const input = {
+    selector: { id },
+    update: req.validatedBody,
+  }
+
+  const { result, errors } = await workflow.run({ input })
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  const variables = { id: result[0].id }
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "return_reason",
+    variables,
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+  const [return_reason] = await remoteQuery(queryObject)
+
+  res.json({ return_reason })
+}
+
+export const DELETE = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const { id } = req.params
+
+  const workflow = deleteReturnReasonsWorkflow(req.scope)
+
+  const input = {
+    ids: [id],
+  }
+  await workflow.run({ input })
+
+  res.json({
+    id,
+    object: "return_reason",
+    deleted: true,
+  })
+}

packages/medusa/src/api-v2/admin/return-reasons/middlewares.ts

@@ -0,0 +1,53 @@
+import { MiddlewareRoute } from "../../../loaders/helpers/routing/types"
+import { authenticate } from "../../../utils/middlewares/authenticate-middleware"
+import { validateAndTransformBody } from "../../utils/validate-body"
+import { validateAndTransformQuery } from "../../utils/validate-query"
+import * as QueryConfig from "./query-config"
+import {
+  AdminCreateReturnReason,
+  AdminGetReturnReasonsParams,
+  AdminGetReturnReasonsReturnReasonParams,
+} from "./validators"
+
+export const adminReturnReasonRoutesMiddlewares: MiddlewareRoute[] = [
+  {
+    method: ["ALL"],
+    matcher: "/admin/return-reasons*",
+    middlewares: [authenticate("admin", ["bearer", "session", "api-key"])],
+  },
+  {
+    method: ["GET"],
+    matcher: "/admin/return-reasons",
+    middlewares: [
+      validateAndTransformQuery(
+        AdminGetReturnReasonsParams,
+        QueryConfig.listTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["GET"],
+    matcher: "/admin/return-reasons/:id",
+    middlewares: [
+      validateAndTransformQuery(
+        AdminGetReturnReasonsReturnReasonParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["POST"],
+    matcher: "/admin/return-reasons",
+    middlewares: [
+      validateAndTransformBody(AdminCreateReturnReason),
+      validateAndTransformQuery(
+        AdminGetReturnReasonsReturnReasonParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["DELETE"],
+    matcher: "/admin/return-reasons/:id",
+  },
+]

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

@@ -0,0 +1,34 @@
+export const defaultAdminReturnReasonFields = [
+  "id",
+  "display_id",
+  "status",
+  "version",
+  "summary",
+  "metadata",
+  "created_at",
+  "updated_at",
+]
+
+export const defaultAdminRetrieveReturnReasonFields = [
+  "id",
+  "value",
+  "label",
+  "parent_return_reason_id",
+  "description",
+  "created_at",
+  "updated_at",
+  "deleted_at",
+  "*.parent_return_reason",
+  "*.return_reason_children",
+]
+
+export const retrieveTransformQueryConfig = {
+  defaultFields: defaultAdminRetrieveReturnReasonFields,
+  isList: false,
+}
+
+export const listTransformQueryConfig = {
+  defaults: defaultAdminReturnReasonFields,
+  defaultLimit: 20,
+  isList: true,
+}

packages/medusa/src/api-v2/admin/return-reasons/route.ts

@@ -0,0 +1,71 @@
+import { createReturnReasonsWorkflow } from "@medusajs/core-flows"
+import { CreateOrderReturnReasonDTO } from "@medusajs/types"
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../types/routing"
+
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "return_reason",
+    variables: {
+      filters: {
+        ...req.filterableFields,
+      },
+      ...req.remoteQueryConfig.pagination,
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const { rows: return_reasons, metadata } = await remoteQuery(queryObject)
+
+  res.json({
+    return_reasons,
+    count: metadata.count,
+    offset: metadata.skip,
+    limit: metadata.take,
+  })
+}
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest<CreateOrderReturnReasonDTO>,
+  res: MedusaResponse
+) => {
+  const workflow = createReturnReasonsWorkflow(req.scope)
+
+  const input = {
+    data: [
+      {
+        ...req.validatedBody,
+      },
+    ],
+  }
+
+  const { result, errors } = await workflow.run({ input })
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  const variables = { id: result[0].id }
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "return_reason",
+    variables,
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+  const [return_reason] = await remoteQuery(queryObject)
+
+  res.json({ return_reason })
+}

packages/medusa/src/api-v2/admin/return-reasons/validators.ts

@@ -0,0 +1,71 @@
+import { z } from "zod"
+import {
+  createFindParams,
+  createOperatorMap,
+  createSelectParams,
+} from "../../utils/validators"
+
+export const AdminGetReturnReasonsReturnReasonParams =
+  createSelectParams().merge(
+    z.object({
+      id: z.union([z.string(), z.array(z.string())]).optional(),
+      value: z.union([z.string(), z.array(z.string())]).optional(),
+      label: z.union([z.string(), z.array(z.string())]).optional(),
+      description: z.union([z.string(), z.array(z.string())]).optional(),
+      parent_return_reason_id: z
+        .union([z.string(), z.array(z.string())])
+        .optional(),
+      created_at: createOperatorMap().optional(),
+      updated_at: createOperatorMap().optional(),
+      deleted_at: createOperatorMap().optional(),
+    })
+  )
+
+export type AdminGetReturnReasonsReturnReasonParamsType = z.infer<
+  typeof AdminGetReturnReasonsReturnReasonParams
+>
+
+/**
+ * Parameters used to filter and configure the pagination of the retrieved order.
+ */
+export const AdminGetReturnReasonsParams = createFindParams({
+  limit: 15,
+  offset: 0,
+}).merge(
+  z.object({
+    id: z.union([z.string(), z.array(z.string())]).optional(),
+    value: z.union([z.string(), z.array(z.string())]).optional(),
+    label: z.union([z.string(), z.array(z.string())]).optional(),
+    description: z.union([z.string(), z.array(z.string())]).optional(),
+    parent_return_reason_id: z
+      .union([z.string(), z.array(z.string())])
+      .optional(),
+    created_at: createOperatorMap().optional(),
+    updated_at: createOperatorMap().optional(),
+    deleted_at: createOperatorMap().optional(),
+  })
+)
+export type AdminGetReturnReasonsParamsType = z.infer<
+  typeof AdminGetReturnReasonsParams
+>
+
+export const AdminCreateReturnReason = z.object({
+  value: z.string(),
+  label: z.string(),
+  descripton: z.string().optional(),
+  parent_return_reason_id: z.string().optional(),
+  metadata: z.record(z.unknown()).optional(),
+})
+export type AdminCreateReturnReasonType = z.infer<
+  typeof AdminCreateReturnReason
+>
+
+export const AdminUpdateReturnReason = z.object({
+  value: z.string(),
+  label: z.string(),
+  descripton: z.string().optional(),
+  metadata: z.record(z.unknown()).optional(),
+})
+export type AdminUpdateReturnReasonType = z.infer<
+  typeof AdminUpdateReturnReason
+>

packages/medusa/src/api-v2/admin/returns/[id]/cancel/route.ts

@@ -0,0 +1,35 @@
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../../types/routing"
+
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order",
+    variables: {
+      filters: {
+        ...req.filterableFields,
+      },
+      ...req.remoteQueryConfig.pagination,
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const { rows: orders, metadata } = await remoteQuery(queryObject)
+
+  res.json({
+    orders,
+    count: metadata.count,
+    offset: metadata.skip,
+    limit: metadata.take,
+  })
+}

packages/medusa/src/api-v2/admin/returns/[id]/receive/route.ts

@@ -0,0 +1,36 @@
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../../types/routing"
+
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order",
+    variables: {
+      filters: {
+        ...req.filterableFields,
+        is_draft_order: false,
+      },
+      ...req.remoteQueryConfig.pagination,
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const { rows: orders, metadata } = await remoteQuery(queryObject)
+
+  res.json({
+    orders,
+    count: metadata.count,
+    offset: metadata.skip,
+    limit: metadata.take,
+  })
+}

packages/medusa/src/api-v2/admin/returns/[id]/route.ts

@@ -0,0 +1,35 @@
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../types/routing"
+
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order",
+    variables: {
+      filters: {
+        ...req.filterableFields,
+      },
+      ...req.remoteQueryConfig.pagination,
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const { rows: orders, metadata } = await remoteQuery(queryObject)
+
+  res.json({
+    orders,
+    count: metadata.count,
+    offset: metadata.skip,
+    limit: metadata.take,
+  })
+}

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

@@ -0,0 +1,49 @@
+import { MiddlewareRoute } from "../../../loaders/helpers/routing/types"
+import { authenticate } from "../../../utils/middlewares/authenticate-middleware"
+import { validateAndTransformBody } from "../../utils/validate-body"
+import { validateAndTransformQuery } from "../../utils/validate-query"
+import * as QueryConfig from "./query-config"
+import {
+  AdminGetOrdersOrderParams,
+  AdminGetOrdersParams,
+  AdminPostReturnsReqSchema,
+} from "./validators"
+
+export const adminOrderRoutesMiddlewares: MiddlewareRoute[] = [
+  {
+    method: ["ALL"],
+    matcher: "/admin/returns*",
+    middlewares: [authenticate("admin", ["bearer", "session", "api-key"])],
+  },
+  {
+    method: ["GET"],
+    matcher: "/admin/returns",
+    middlewares: [
+      validateAndTransformQuery(
+        AdminGetOrdersParams,
+        QueryConfig.listTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["GET"],
+    matcher: "/admin/returns/:id",
+    middlewares: [
+      validateAndTransformQuery(
+        AdminGetOrdersOrderParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["POST"],
+    matcher: "/admin/returns/create-return",
+    middlewares: [
+      validateAndTransformBody(AdminPostReturnsReqSchema),
+      validateAndTransformQuery(
+        AdminGetOrdersOrderParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+]

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

@@ -0,0 +1,62 @@
+export const defaultAdminOrderFields = [
+  "id",
+  "display_id",
+  "status",
+  "version",
+  "summary",
+  "metadata",
+  "created_at",
+  "updated_at",
+]
+
+export const defaultAdminRetrieveOrderFields = [
+  "id",
+  "display_id",
+  "status",
+  "version",
+  "summary",
+  "total",
+  "subtotal",
+  "tax_total",
+  "discount_total",
+  "discount_tax_total",
+  "original_total",
+  "original_tax_total",
+  "item_total",
+  "item_subtotal",
+  "item_tax_total",
+  "original_item_total",
+  "original_item_subtotal",
+  "original_item_tax_total",
+  "shipping_total",
+  "shipping_subtotal",
+  "shipping_tax_total",
+  "original_shipping_tax_total",
+  "original_shipping_tax_subtotal",
+  "original_shipping_total",
+  "created_at",
+  "updated_at",
+  "*items",
+  "*items.tax_lines",
+  "*items.adjustments",
+  "*items.variant",
+  "*items.variant.product",
+  "*items.detail",
+  "*shipping_address",
+  "*billing_address",
+  "*shipping_methods",
+  "*shipping_methods.tax_lines",
+  "*shipping_methods.adjustments",
+  "*payment_collections",
+]
+
+export const retrieveTransformQueryConfig = {
+  defaultFields: defaultAdminRetrieveOrderFields,
+  isList: false,
+}
+
+export const listTransformQueryConfig = {
+  defaults: defaultAdminOrderFields,
+  defaultLimit: 20,
+  isList: true,
+}

packages/medusa/src/api-v2/admin/returns/route.ts

@@ -0,0 +1,56 @@
+import { createReturnOrderWorkflow } from "@medusajs/core-flows"
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../types/routing"
+import { AdminPostReturnsReqSchemaType } from "./validators"
+
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order",
+    variables: {
+      filters: {
+        ...req.filterableFields,
+      },
+      ...req.remoteQueryConfig.pagination,
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const { rows: orders, metadata } = await remoteQuery(queryObject)
+
+  res.json({
+    orders,
+    count: metadata.count,
+    offset: metadata.skip,
+    limit: metadata.take,
+  })
+}
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest<AdminPostReturnsReqSchemaType>,
+  res: MedusaResponse
+) => {
+  const input = req.validatedBody as AdminPostReturnsReqSchemaType
+
+  const workflow = createReturnOrderWorkflow(req.scope)
+  const { result, errors } = await workflow.run({
+    input,
+    throwOnError: false,
+  })
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  res.status(200).json({ return: result })
+}

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

@@ -0,0 +1,63 @@
+import { z } from "zod"
+import {
+  createFindParams,
+  createOperatorMap,
+  createSelectParams,
+} from "../../utils/validators"
+
+export const AdminGetOrdersOrderParams = createSelectParams().merge(
+  z.object({
+    id: z.union([z.string(), z.array(z.string())]).optional(),
+    status: z.union([z.string(), z.array(z.string())]).optional(),
+    created_at: createOperatorMap().optional(),
+    updated_at: createOperatorMap().optional(),
+    deleted_at: createOperatorMap().optional(),
+  })
+)
+
+export type AdminGetOrdersOrderParamsType = z.infer<
+  typeof AdminGetOrdersOrderParams
+>
+
+/**
+ * Parameters used to filter and configure the pagination of the retrieved order.
+ */
+export const AdminGetOrdersParams = createFindParams({
+  limit: 15,
+  offset: 0,
+}).merge(
+  z.object({
+    id: z.union([z.string(), z.array(z.string())]).optional(),
+    status: z.union([z.string(), z.array(z.string())]).optional(),
+    created_at: createOperatorMap().optional(),
+    updated_at: createOperatorMap().optional(),
+    deleted_at: createOperatorMap().optional(),
+  })
+)
+
+export type AdminGetOrdersParamsType = z.infer<typeof AdminGetOrdersParams>
+
+const ReturnShippingSchema = z.object({
+  option_id: z.string(),
+  price: z.number().optional(),
+})
+
+const ItemSchema = z.object({
+  id: z.string(),
+  quantity: z.number().min(1),
+  reason_id: z.string().optional(),
+  note: z.string().optional(),
+})
+
+export const AdminPostReturnsReqSchema = z.object({
+  order_id: z.string(),
+  items: z.array(ItemSchema),
+  return_shipping: ReturnShippingSchema,
+  note: z.string().optional(),
+  receive_now: z.boolean().optional(),
+  refund_amount: z.number().optional(),
+  location_id: z.string().optional(),
+})
+export type AdminPostReturnsReqSchemaType = z.infer<
+  typeof AdminPostReturnsReqSchema
+>

packages/medusa/src/api-v2/admin/stock-locations/[id]/fulfillment-sets/route.ts

@@ -1,10 +1,13 @@
 import { createLocationFulfillmentSetWorkflow } from "@medusajs/core-flows"
-import { MedusaRequest, MedusaResponse } from "../../../../../types/routing"
-import { AdminCreateStockLocationFulfillmentSetType } from "../../validators"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../../types/routing"
 import { refetchStockLocation } from "../../helpers"
+import { AdminCreateStockLocationFulfillmentSetType } from "../../validators"
 
 export const POST = async (
-  req: MedusaRequest<AdminCreateStockLocationFulfillmentSetType>,
+  req: AuthenticatedMedusaRequest<AdminCreateStockLocationFulfillmentSetType>,
   res: MedusaResponse
 ) => {
   const { errors } = await createLocationFulfillmentSetWorkflow(req.scope).run({

packages/medusa/src/api-v2/admin/stock-locations/[id]/route.ts

@@ -1,18 +1,21 @@
-import { MedusaRequest, MedusaResponse } from "../../../../types/routing"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../types/routing"
 
 import {
   deleteStockLocationsWorkflow,
   updateStockLocationsWorkflow,
 } from "@medusajs/core-flows"
 import { MedusaError } from "@medusajs/utils"
+import { refetchStockLocation } from "../helpers"
 import {
   AdminGetStockLocationParamsType,
   AdminUpdateStockLocationType,
 } from "../validators"
-import { refetchStockLocation } from "../helpers"
 
 export const POST = async (
-  req: MedusaRequest<AdminUpdateStockLocationType>,
+  req: AuthenticatedMedusaRequest<AdminUpdateStockLocationType>,
   res: MedusaResponse
 ) => {
   const { id } = req.params
@@ -35,7 +38,7 @@ export const POST = async (
 }
 
 export const GET = async (
-  req: MedusaRequest<AdminGetStockLocationParamsType>,
+  req: AuthenticatedMedusaRequest<AdminGetStockLocationParamsType>,
   res: MedusaResponse
 ) => {
   const { id } = req.params
@@ -56,7 +59,10 @@ export const GET = async (
   res.status(200).json({ stock_location: stockLocation })
 }
 
-export const DELETE = async (req: MedusaRequest, res: MedusaResponse) => {
+export const DELETE = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
   const { id } = req.params
 
   const { errors } = await deleteStockLocationsWorkflow(req.scope).run({

packages/medusa/src/api-v2/admin/stock-locations/route.ts

@@ -2,18 +2,21 @@ import {
   ContainerRegistrationKeys,
   remoteQueryObjectFromString,
 } from "@medusajs/utils"
-import { MedusaRequest, MedusaResponse } from "../../../types/routing"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../types/routing"
 
 import { createStockLocationsWorkflow } from "@medusajs/core-flows"
+import { refetchStockLocation } from "./helpers"
 import {
   AdminCreateStockLocationType,
   AdminGetStockLocationsParamsType,
 } from "./validators"
-import { refetchStockLocation } from "./helpers"
 
 // Create stock location
 export const POST = async (
-  req: MedusaRequest<AdminCreateStockLocationType>,
+  req: AuthenticatedMedusaRequest<AdminCreateStockLocationType>,
   res: MedusaResponse
 ) => {
   const { result } = await createStockLocationsWorkflow(req.scope).run({
@@ -30,7 +33,7 @@ export const POST = async (
 }
 
 export const GET = async (
-  req: MedusaRequest<AdminGetStockLocationsParamsType>,
+  req: AuthenticatedMedusaRequest<AdminGetStockLocationsParamsType>,
   res: MedusaResponse
 ) => {
   const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)

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

@@ -21,6 +21,7 @@ import { adminProductRoutesMiddlewares } from "./admin/products/middlewares"
 import { adminPromotionRoutesMiddlewares } from "./admin/promotions/middlewares"
 import { adminRegionRoutesMiddlewares } from "./admin/regions/middlewares"
 import { adminReservationRoutesMiddlewares } from "./admin/reservations/middlewares"
+import { adminReturnReasonRoutesMiddlewares } from "./admin/return-reasons/middlewares"
 import { adminSalesChannelRoutesMiddlewares } from "./admin/sales-channels/middlewares"
 import { adminShippingOptionRoutesMiddlewares } from "./admin/shipping-options/middlewares"
 import { adminShippingProfilesMiddlewares } from "./admin/shipping-profiles/middlewares"
@@ -37,13 +38,14 @@ import { storeCartRoutesMiddlewares } from "./store/carts/middlewares"
 import { storeCollectionRoutesMiddlewares } from "./store/collections/middlewares"
 import { storeCurrencyRoutesMiddlewares } from "./store/currencies/middlewares"
 import { storeCustomerRoutesMiddlewares } from "./store/customers/middlewares"
-import { storeProductRoutesMiddlewares } from "./store/products/middlewares"
-import { storeProductCategoryRoutesMiddlewares } from "./store/product-categories/middlewares"
-import { storeRegionRoutesMiddlewares } from "./store/regions/middlewares"
-import { storePaymentProvidersMiddlewares } from "./store/payment-providers/middlewares"
-import { storePaymentCollectionsMiddlewares } from "./store/payment-collections/middlewares"
-import { storeShippingOptionRoutesMiddlewares } from "./store/shipping-options/middlewares"
 import { storeOrderRoutesMiddlewares } from "./store/orders/middlewares"
+import { storePaymentCollectionsMiddlewares } from "./store/payment-collections/middlewares"
+import { storePaymentProvidersMiddlewares } from "./store/payment-providers/middlewares"
+import { storeProductCategoryRoutesMiddlewares } from "./store/product-categories/middlewares"
+import { storeProductRoutesMiddlewares } from "./store/products/middlewares"
+import { storeRegionRoutesMiddlewares } from "./store/regions/middlewares"
+import { storeReturnReasonRoutesMiddlewares } from "./store/return-reasons/middlewares"
+import { storeShippingOptionRoutesMiddlewares } from "./store/shipping-options/middlewares"
 
 export const config: MiddlewaresConfig = {
   routes: [
@@ -94,5 +96,7 @@ export const config: MiddlewaresConfig = {
     ...adminFulfillmentsRoutesMiddlewares,
     ...adminFulfillmentProvidersRoutesMiddlewares,
     ...storeProductRoutesMiddlewares,
+    ...storeReturnReasonRoutesMiddlewares,
+    ...adminReturnReasonRoutesMiddlewares,
   ],
 }

packages/medusa/src/api-v2/store/orders/[id]/route.ts

@@ -1,8 +1,12 @@
 import { MedusaRequest, MedusaResponse } from "../../../../types/routing"
 import { refetchOrder } from "../helpers"
+import { StoreGetOrdersParamsType } from "../validators"
 
 // TODO: Do we want to apply some sort of authentication here? My suggestion is that we do
-export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+export const GET = async (
+  req: MedusaRequest<StoreGetOrdersParamsType>,
+  res: MedusaResponse
+) => {
   const order = await refetchOrder(
     req.params.id,
     req.scope,

packages/medusa/src/api-v2/store/return-reasons/[id]/route.ts

@@ -0,0 +1,25 @@
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import { MedusaRequest, MedusaResponse } from "../../../../types/routing"
+import { StoreReturnReasonParamsType } from "../validators"
+
+export const GET = async (
+  req: MedusaRequest<StoreReturnReasonParamsType>,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  const variables = { id: req.params.id }
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "return_reason",
+    variables,
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [return_reason] = await remoteQuery(queryObject)
+
+  res.json({ return_reason })
+}

packages/medusa/src/api-v2/store/return-reasons/middlewares.ts

@@ -0,0 +1,27 @@
+import { MiddlewareRoute } from "../../../loaders/helpers/routing/types"
+import { validateAndTransformQuery } from "../../utils/validate-query"
+import * as QueryConfig from "./query-config"
+import { StoreReturnReasonParams } from "./validators"
+
+export const storeReturnReasonRoutesMiddlewares: MiddlewareRoute[] = [
+  {
+    method: ["GET"],
+    matcher: "/admin/return-reasons",
+    middlewares: [
+      validateAndTransformQuery(
+        StoreReturnReasonParams,
+        QueryConfig.listTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["GET"],
+    matcher: "/admin/return-reasons/:id",
+    middlewares: [
+      validateAndTransformQuery(
+        StoreReturnReasonParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+]

packages/medusa/src/api-v2/store/return-reasons/query-config.ts

@@ -0,0 +1,23 @@
+export const defaultStoreRetrieveReturnReasonFields = [
+  "id",
+  "value",
+  "label",
+  "parent_return_reason_id",
+  "description",
+  "created_at",
+  "updated_at",
+  "deleted_at",
+  "*.parent_return_reason",
+  "*.return_reason_children",
+]
+
+export const retrieveTransformQueryConfig = {
+  defaultFields: defaultStoreRetrieveReturnReasonFields,
+  isList: false,
+}
+
+export const listTransformQueryConfig = {
+  defaults: defaultStoreRetrieveReturnReasonFields,
+  defaultLimit: 20,
+  isList: true,
+}

packages/medusa/src/api-v2/store/return-reasons/route.ts

@@ -0,0 +1,29 @@
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import { MedusaRequest, MedusaResponse } from "../../../types/routing"
+
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "return_reason",
+    variables: {
+      filters: {
+        ...req.filterableFields,
+      },
+      ...req.remoteQueryConfig.pagination,
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const { rows: return_reasons, metadata } = await remoteQuery(queryObject)
+
+  res.json({
+    return_reasons,
+    count: metadata.count,
+    offset: metadata.skip,
+    limit: metadata.take,
+  })
+}

packages/medusa/src/api-v2/store/return-reasons/validators.ts

@@ -0,0 +1,12 @@
+import { z } from "zod"
+import { createFindParams, createSelectParams } from "../../utils/validators"
+
+export type StoreReturnReasonParamsType = z.infer<
+  typeof StoreReturnReasonParams
+>
+export const StoreReturnReasonParams = createSelectParams()
+
+export type StoreReturnReasonsParamsType = z.infer<
+  typeof StoreReturnReasonsParams
+>
+export const StoreReturnReasonsParams = createFindParams()

packages/medusa/src/api-v2/store/return/route.ts

@@ -1,10 +1,22 @@
-import { CreateOrderReturnDTO } from "@medusajs/types"
+import { createReturnOrderWorkflow } from "@medusajs/core-flows"
 import { MedusaRequest, MedusaResponse } from "../../../types/routing"
+import { StorePostReturnsReqSchemaType } from "./validators"
 
-export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
-  const input = [req.validatedBody as CreateOrderReturnDTO]
+export const POST = async (
+  req: MedusaRequest<StorePostReturnsReqSchemaType>,
+  res: MedusaResponse
+) => {
+  const input = req.validatedBody as StorePostReturnsReqSchemaType
 
-  // TODO: create return workflow
+  const workflow = createReturnOrderWorkflow(req.scope)
+  const { result, errors } = await workflow.run({
+    input,
+    throwOnError: false,
+  })
 
-  res.status(200).json({ return: {} })
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  res.status(200).json({ return: result })
 }

packages/medusa/src/api-v2/store/return/validators.ts

@@ -16,10 +16,11 @@ export const ReturnsParams = createFindParams().merge(
 
 const ReturnShippingSchema = z.object({
   option_id: z.string(),
+  price: z.number().optional(),
 })
 
 const ItemSchema = z.object({
-  item_id: z.string(),
+  id: z.string(),
   quantity: z.number().min(1),
   reason_id: z.string().optional(),
   note: z.string().optional(),
@@ -28,5 +29,12 @@ const ItemSchema = z.object({
 export const StorePostReturnsReqSchema = z.object({
   order_id: z.string(),
   items: z.array(ItemSchema),
-  return_shipping: ReturnShippingSchema.optional(),
+  return_shipping: ReturnShippingSchema,
+  note: z.string().optional(),
+  receive_now: z.boolean().optional(),
+  refund_amount: z.number().optional(),
+  location_id: z.string().optional(),
 })
+export type StorePostReturnsReqSchemaType = z.infer<
+  typeof StorePostReturnsReqSchema
+>