chore: rename route from api-v2 to api (#7379)

* chore: rename route from api-v2 to api

* chore: change oas references

* chore: remove v2 ref
This commit is contained in:
Riqwan Thamir
2024-05-21 10:44:02 +02:00
committed by GitHub
parent e72174c4ff
commit 442b0b2038
368 changed files with 43 additions and 46 deletions
@@ -0,0 +1,21 @@
import { MedusaError } from "@medusajs/utils"
import { MedusaRequest, MedusaResponse } from "../../../../types/routing"
import { refetchOrder } from "../helpers"
import { defaultAdminOrderFields } from "../query-config"
export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
const draftOrder = await refetchOrder(
req.params.id,
req.scope,
defaultAdminOrderFields
)
if (!draftOrder) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`Draft order with id: ${req.params.id} was not found`
)
}
res.status(200).json({ draft_order: draftOrder })
}
@@ -0,0 +1,23 @@
import { MedusaContainer } from "@medusajs/types"
import {
ContainerRegistrationKeys,
remoteQueryObjectFromString,
} from "@medusajs/utils"
export const refetchOrder = async (
orderId: string,
scope: MedusaContainer,
fields: string[]
) => {
const remoteQuery = scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
const queryObject = remoteQueryObjectFromString({
entryPoint: "order",
variables: {
filters: { id: orderId },
},
fields: fields,
})
const orders = await remoteQuery(queryObject)
return orders[0]
}
@@ -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 {
AdminCreateDraftOrder,
AdminGetOrderParams,
AdminGetOrdersParams,
} from "./validators"
export const adminDraftOrderRoutesMiddlewares: MiddlewareRoute[] = [
{
method: ["ALL"],
matcher: "/admin/draft-orders*",
middlewares: [authenticate("admin", ["bearer", "session", "api-key"])],
},
{
method: ["GET"],
matcher: "/admin/draft-orders",
middlewares: [
validateAndTransformQuery(
AdminGetOrdersParams,
QueryConfig.listTransformQueryConfig
),
],
},
{
method: ["GET"],
matcher: "/admin/draft-orders/:id",
middlewares: [
validateAndTransformQuery(
AdminGetOrderParams,
QueryConfig.retrieveTransformQueryConfig
),
],
},
{
method: ["POST"],
matcher: "/admin/draft-orders",
middlewares: [
validateAndTransformBody(AdminCreateDraftOrder),
validateAndTransformQuery(
AdminGetOrderParams,
QueryConfig.retrieveTransformQueryConfig
),
],
},
]
@@ -0,0 +1,42 @@
export const defaultAdminListOrderFields = [
"id",
"status",
"version",
"*items",
"summary",
"metadata",
"created_at",
"updated_at",
]
export const defaultAdminOrderFields = [
"id",
"status",
"version",
"*items",
"*items.tax_lines",
"*items.adjustments",
"*items.detail",
"*items.variant",
"*items.variant.product",
"*shipping_address",
"*billing_address",
"*shipping_methods",
"*shipping_methods.tax_lines",
"*shipping_methods.adjustments",
"summary",
"metadata",
"created_at",
"updated_at",
]
export const retrieveTransformQueryConfig = {
defaults: defaultAdminOrderFields,
isList: false,
}
export const listTransformQueryConfig = {
defaults: defaultAdminListOrderFields,
defaultLimit: 20,
isList: true,
}
@@ -0,0 +1,95 @@
import { createOrdersWorkflow } from "@medusajs/core-flows"
import {
ContainerRegistrationKeys,
OrderStatus,
remoteQueryObjectFromString,
} from "@medusajs/utils"
import {
AuthenticatedMedusaRequest,
MedusaRequest,
MedusaResponse,
} from "../../../types/routing"
import { AdminCreateDraftOrderType } from "./validators"
import { refetchOrder } from "./helpers"
import { CreateOrderDTO } from "@medusajs/types"
export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
const queryObject = remoteQueryObjectFromString({
entryPoint: "order",
variables: {
filters: {
...req.filterableFields,
is_draft_order: true,
},
...req.remoteQueryConfig.pagination,
},
fields: req.remoteQueryConfig.fields,
})
const { rows: draft_orders, metadata } = await remoteQuery(queryObject)
res.json({
draft_orders,
count: metadata.count,
offset: metadata.skip,
limit: metadata.take,
})
}
export const POST = async (
req: AuthenticatedMedusaRequest<AdminCreateDraftOrderType>,
res: MedusaResponse
) => {
const input = req.validatedBody
const workflowInput = {
...input,
no_notification: !!input.no_notification_order,
status: OrderStatus.DRAFT,
is_draft_order: true,
} as CreateOrderDTO
const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
if (!input.currency_code) {
const queryObject = remoteQueryObjectFromString({
entryPoint: "region",
variables: {
filters: { id: input.region_id },
},
fields: ["currency_code"],
})
const [region] = await remoteQuery(queryObject)
input.currency_code = region?.currency_code
}
if (!input.email) {
const queryObject = remoteQueryObjectFromString({
entryPoint: "customer",
variables: {
filters: { id: input.customer_id },
},
fields: ["email"],
})
const [customer] = await remoteQuery(queryObject)
input.email = customer?.email
}
const { result, errors } = 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,
req.remoteQueryConfig.fields
)
res.status(200).json({ draft_order: draftOrder })
}
@@ -0,0 +1,79 @@
import { createFindParams, createSelectParams } from "../../utils/validators"
import { AddressPayload, BigNumberInput } from "../../utils/common-validators"
import { z } from "zod"
export type AdminGetOrderParamsType = z.infer<typeof AdminGetOrderParams>
export const AdminGetOrderParams = createSelectParams()
export type AdminGetOrdersParamsType = z.infer<typeof AdminGetOrdersParams>
export const AdminGetOrdersParams = createFindParams({
limit: 50,
offset: 0,
}).merge(
z.object({
id: z.union([z.string(), z.array(z.string())]).optional(),
name: z.union([z.string(), z.array(z.string())]).optional(),
$and: z.lazy(() => AdminGetOrdersParams.array()).optional(),
$or: z.lazy(() => AdminGetOrdersParams.array()).optional(),
})
)
enum Status {
completed = "completed",
}
const ShippingMethod = z.object({
shipping_method_id: z.string().optional(),
order_id: z.string().optional(),
name: z.string(),
option_id: z.string(),
data: z.record(z.string(), z.unknown()).optional(),
amount: BigNumberInput,
})
const Item = z
.object({
title: z.string().optional(),
sku: z.string().optional(),
barcode: z.string().optional(),
variant_id: z.string().optional(),
unit_price: BigNumberInput.optional(),
quantity: z.number(),
metadata: z.record(z.string(), z.unknown()).optional(),
})
.refine((data) => {
if (!data.variant_id) {
return data.title && (data.sku || data.barcode)
}
return true
})
export type AdminCreateDraftOrderType = z.infer<typeof AdminCreateDraftOrder>
export const AdminCreateDraftOrder = z
.object({
status: z.nativeEnum(Status).optional(),
sales_channel_id: z.string().optional(),
email: z.string().optional(),
customer_id: z.string().optional(),
billing_address: AddressPayload.optional(),
shipping_address: AddressPayload.optional(),
items: z.array(Item).optional(),
region_id: z.string(),
promo_codes: z.array(z.string()).optional(),
currency_code: z.string().optional(),
no_notification_order: z.boolean().optional(),
shipping_methods: z.array(ShippingMethod),
metadata: z.record(z.string(), z.unknown()).optional(),
})
.strict()
.refine(
(data) => {
if (!data.email && !data.customer_id) {
return false
}
return true
},
{ message: "Either email or customer_id must be provided" }
)