feat(medusa): skip draft orders on order list (#10195)

integration-tests/http/__tests__/fixtures/order.ts

@@ -13,20 +13,27 @@ import {
 export async function createOrderSeeder({
   api,
   container,
+  storeHeaderOverride,
   productOverride,
   additionalProducts,
   stockChannelOverride,
   inventoryItemOverride,
 }: {
   api: any
   container: MedusaContainer
+  storeHeaderOverride?: any
   productOverride?: AdminProduct
   stockChannelOverride?: AdminStockLocation
   additionalProducts?: { variant_id: string; quantity: number }[]
   inventoryItemOverride?: AdminInventoryItem
 }) {
   const publishableKey = await generatePublishableKey(container)
-  const storeHeaders = generateStoreHeaders({ publishableKey })
+
+  const storeHeaders =
+    storeHeaderOverride ??
+    generateStoreHeaders({
+      publishableKey,
+    })
 
   const region = (
     await api.post(

integration-tests/http/__tests__/order/store/order.spec.ts

@@ -0,0 +1,138 @@
+import { medusaIntegrationTestRunner } from "@medusajs/test-utils"
+import { ModuleRegistrationName } from "@medusajs/utils"
+import {
+  adminHeaders,
+  createAdminUser,
+  generatePublishableKey,
+  generateStoreHeaders,
+} from "../../../../helpers/create-admin-user"
+import { setupTaxStructure } from "../../../../modules/__tests__/fixtures"
+import { createAuthenticatedCustomer } from "../../../../modules/helpers/create-authenticated-customer"
+import { createOrderSeeder } from "../../fixtures/order"
+
+jest.setTimeout(300000)
+
+medusaIntegrationTestRunner({
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    let order,
+      draftOrder,
+      seeder,
+      storeHeaders,
+      customer,
+      storeHeadersWithCustomer
+
+    beforeEach(async () => {
+      const container = getContainer()
+
+      await setupTaxStructure(container.resolve(ModuleRegistrationName.TAX))
+      await createAdminUser(dbConnection, adminHeaders, container)
+      const publishableKey = await generatePublishableKey(container)
+      storeHeaders = generateStoreHeaders({ publishableKey })
+
+      const result = await createAuthenticatedCustomer(api, storeHeaders, {
+        first_name: "tony",
+        last_name: "stark",
+        email: "[email protected]",
+      })
+
+      customer = result.customer
+      storeHeadersWithCustomer = {
+        headers: {
+          ...storeHeaders.headers,
+          authorization: `Bearer ${result.jwt}`,
+        },
+      }
+
+      seeder = await createOrderSeeder({
+        api,
+        container: getContainer(),
+        storeHeaderOverride: storeHeadersWithCustomer,
+      })
+      order = seeder.order
+      order = (await api.get(`/admin/orders/${order.id}`, adminHeaders)).data
+        .order
+
+      const payload = {
+        email: "[email protected]",
+        region_id: seeder.region.id,
+        status: "completed",
+        shipping_methods: [
+          {
+            shipping_option_id: seeder.shippingOption.id,
+            amount: 10,
+            name: "test",
+          },
+        ],
+      }
+
+      const draftOrderResposne = await api.post(
+        "/admin/draft-orders?fields=+is_draft_order",
+        payload,
+        adminHeaders
+      )
+
+      await api.post(
+        `/admin/orders/${draftOrderResposne.data.draft_order.id}/complete`,
+        {},
+        adminHeaders
+      )
+
+      draftOrder = draftOrderResposne.data.draft_order
+    })
+
+    describe("GET /store/orders", () => {
+      it("should successfully list non draft orders", async () => {
+        const response = await api.get(
+          `/store/orders`,
+          storeHeadersWithCustomer
+        )
+
+        expect(response.data.orders).toHaveLength(1)
+        expect(response.data.orders).toEqual([
+          expect.objectContaining({
+            id: order.id,
+          }),
+        ])
+      })
+
+      it("should throw an error when customer isn't authenticated", async () => {
+        const { response } = await api
+          .get(`/store/orders`, storeHeaders)
+          .catch((e) => e)
+
+        expect(response.status).toEqual(401)
+        expect(response.data.message).toEqual("Unauthorized")
+      })
+    })
+
+    describe("GET /store/orders/:id", () => {
+      it("should successfully fetch non draft order", async () => {
+        const response = await api.get(
+          `/store/orders/${order.id}`,
+          storeHeadersWithCustomer
+        )
+
+        expect(response.data.order).toEqual(
+          expect.objectContaining({
+            id: order.id,
+          })
+        )
+      })
+
+      // TODO: This should have thrown an error, but doesn't seem to.
+      it.skip("should throw an error when fetching draft order", async () => {
+        const response = await api
+          .get(
+            `/store/orders/${draftOrder.id}?fields=+is_draft_order`,
+            storeHeaders
+          )
+          .catch((e) => e)
+
+        expect(response.status).toEqual(404)
+        expect(response.data.message).toEqual(
+          `Order with id: ${draftOrder.id} was not found`
+        )
+      })
+    })
+  },
+})

packages/core/core-flows/src/order/workflows/get-order-detail.ts

@@ -20,6 +20,7 @@ export const getOrderDetailWorkflow = createWorkflow(
   getOrderDetailWorkflowId,
   (
     input: WorkflowData<{
+      filters?: { is_draft_order?: boolean; customer_id?: string }
       fields: string[]
       order_id: string
       version?: number
@@ -36,13 +37,14 @@ export const getOrderDetailWorkflow = createWorkflow(
       ])
     })
 
+    const variables = transform({ input }, ({ input }) => {
+      return { ...input.filters, id: input.order_id, version: input.version }
+    })
+
     const order: OrderDTO = useRemoteQueryStep({
       entry_point: "orders",
       fields,
-      variables: {
-        id: input.order_id,
-        version: input.version,
-      },
+      variables,
       list: false,
       throw_if_key_not_found: true,
     })

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

@@ -12,6 +12,9 @@ export const GET = async (
     input: {
       fields: req.remoteQueryConfig.fields,
       order_id: req.params.id,
+      filters: {
+        is_draft_order: false,
+      },
     },
   })
 

packages/medusa/src/api/store/orders/middlewares.ts

@@ -1,14 +1,14 @@
+import { validateAndTransformQuery } from "@medusajs/framework"
 import {
   MiddlewareRoute,
   validateAndTransformBody,
 } from "@medusajs/framework/http"
 import { authenticate } from "../../../utils/middlewares/authenticate-middleware"
-import { validateAndTransformQuery } from "@medusajs/framework"
 import * as QueryConfig from "./query-config"
 import {
+  StoreAcceptOrderTransfer,
   StoreGetOrderParams,
   StoreGetOrdersParams,
-  StoreAcceptOrderTransfer,
   StoreRequestOrderTransfer,
 } from "./validators"
 

packages/medusa/src/api/store/orders/route.ts

@@ -12,6 +12,7 @@ export const GET = async (
   const variables = {
     filters: {
       ...req.filterableFields,
+      is_draft_order: false,
       customer_id: req.auth_context.actor_id,
     },
     ...req.remoteQueryConfig.pagination,