tmp

packages/core/core-flows/src/payment-collection/workflows/create-payment-session.ts

@@ -1,4 +1,5 @@
 import { PaymentProviderContext, PaymentSessionDTO } from "@medusajs/types"
+import { PaymentSessionStatus } from "@medusajs/utils"
 import {
   WorkflowData,
   createWorkflow,
@@ -14,6 +15,7 @@ interface WorkflowInput {
   provider_id: string
   data?: Record<string, unknown>
   context?: PaymentProviderContext
+  amount?: number
 }
 
 export const createPaymentSessionsWorkflowId = "create-payment-sessions"
@@ -35,7 +37,11 @@ export const createPaymentSessionsWorkflow = createWorkflow(
           provider_id: data.input.provider_id,
           data: data.input.data,
           context: data.input.context,
-          amount: data.paymentCollection.amount,
+          amount:
+            data.input.amount ||
+            data.paymentCollection.amount -
+              data.paymentCollection.authorized_amount +
+              data.paymentCollection.refunded_amount,
           currency_code: data.paymentCollection.currency_code,
         }
       }
@@ -46,15 +52,14 @@ export const createPaymentSessionsWorkflow = createWorkflow(
       (data) => {
         return {
           ids:
-            data.paymentCollection?.payment_sessions?.map((ps) => ps.id) || [],
+            data.paymentCollection?.payment_sessions
+              ?.filter((ps) => ps.status !== PaymentSessionStatus.AUTHORIZED)
+              ?.map((ps) => ps.id) || [],
         }
       }
     )
 
-    // Note: We are deleting an existing active session before creating a new one
-    // for a payment collection as we don't support split payments at the moment.
-    // When we are ready to accept split payments, this along with other workflows
-    // need to be handled correctly
+    // Note: We are deleting all existing non-authorized session before creating a new one
     const [created] = parallelize(
       createPaymentSessionStep(paymentSessionInput),
       deletePaymentSessionsWorkflow.runAsStep({

packages/core/js-sdk/src/store/index.ts

@@ -313,6 +313,22 @@ export class Store {
         query,
       })
     },
+
+    addPaymentSession: async (
+      paymentCollectionId: string,
+      body: Record<string, any>,
+      query?: SelectParams,
+      headers?: ClientHeaders
+    ) => {
+      return this.client.fetch<{
+        payment_collection: HttpTypes.StorePaymentCollection
+      }>(`/store/payment-collections/${paymentCollectionId}/payment-sessions`, {
+        method: "POST",
+        headers,
+        body,
+        query,
+      })
+    },
   }
 
   public order = {

packages/core/types/src/payment/provider.ts

@@ -40,10 +40,20 @@ export type PaymentProviderContext = {
   email?: string
 
   /**
-   * The ID of payment session the provider payment is associated with.
+   * The associated payment session's ID.
    */
   session_id?: string
 
+  /**
+   * The associated cart's ID.
+   */
+  cart_id?: string
+
+  /**
+   * The associated order's ID.
+   */
+  order_id?: string
+
   /**
    * The customer associated with this payment.
    */
@@ -184,6 +194,16 @@ export type WebhookActionData = {
    */
   session_id: string
 
+  /**
+   * The associated cart's ID.
+   */
+  cart_id: string
+
+  /**
+   * The associated order's ID.
+   */
+  order_id: string
+
   /**
    * The amount to be captured or authorized (based on the action's type.)
    */

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

@@ -1,17 +1,18 @@
+import { getOrderDetailWorkflow } from "@medusajs/core-flows"
 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<StoreGetOrdersParamsType>,
   res: MedusaResponse
 ) => {
-  const order = await refetchOrder(
-    req.params.id,
-    req.scope,
-    req.remoteQueryConfig.fields
-  )
+  const { result } = await getOrderDetailWorkflow(req.scope).run({
+    input: {
+      fields: req.remoteQueryConfig.fields,
+      order_id: req.params.id,
+    },
+  })
 
-  res.json({ order })
+  res.json({ order: result })
 }

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

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

packages/medusa/src/api/store/payment-collections/validators.ts

@@ -14,6 +14,7 @@ export const StoreCreatePaymentSession = z
     provider_id: z.string(),
     context: z.record(z.unknown()).optional(),
     data: z.record(z.unknown()).optional(),
+    amount: z.number().optional(),
   })
   .strict()
 

packages/modules/payment/src/services/payment-module.ts

@@ -862,6 +862,15 @@ export default class PaymentModuleService
           {},
           sharedContext
         )
+
+        if (event.data.order_id && !event.data.cart_id) {
+          await this.authorizePaymentSession(
+            event.data.session_id,
+            {},
+            sharedContext
+          )
+        }
+
         if (payment && !payment.captured_at) {
           await this.capturePayment(
             { payment_id: payment.id, amount: event.data.amount },

packages/modules/providers/payment-stripe/src/core/stripe-base.ts

@@ -110,7 +110,8 @@ abstract class StripeBase extends AbstractPaymentProvider<StripeOptions> {
     input: CreatePaymentProviderSession
   ): Promise<PaymentProviderError | PaymentProviderSessionResponse> {
     const intentRequestData = this.getPaymentIntentOptions()
-    const { email, extra, session_id, customer } = input.context
+    const { email, extra, session_id, cart_id, order_id, customer } =
+      input.context
     const { currency_code, amount } = input
 
     const description = (extra?.payment_description ??
@@ -120,7 +121,11 @@ abstract class StripeBase extends AbstractPaymentProvider<StripeOptions> {
       description,
       amount: getSmallestUnit(amount, currency_code),
       currency: currency_code,
-      metadata: { session_id: session_id! },
+      metadata: {
+        session_id: session_id!,
+        cart_id: cart_id as string | null,
+        order_id: order_id as string | null,
+      },
       capture_method: this.options_.capture ? "automatic" : "manual",
       ...intentRequestData,
     }
@@ -330,6 +335,8 @@ abstract class StripeBase extends AbstractPaymentProvider<StripeOptions> {
           action: PaymentActions.AUTHORIZED,
           data: {
             session_id: intent.metadata.session_id,
+            cart_id: intent.metadata.cart_id,
+            order_id: intent.metadata.order_id,
             amount: getAmountFromSmallestUnit(
               intent.amount_capturable,
               currency
@@ -341,6 +348,8 @@ abstract class StripeBase extends AbstractPaymentProvider<StripeOptions> {
           action: PaymentActions.SUCCESSFUL,
           data: {
             session_id: intent.metadata.session_id,
+            cart_id: intent.metadata.cart_id,
+            order_id: intent.metadata.order_id,
             amount: getAmountFromSmallestUnit(intent.amount_received, currency),
           },
         }
@@ -349,6 +358,8 @@ abstract class StripeBase extends AbstractPaymentProvider<StripeOptions> {
           action: PaymentActions.FAILED,
           data: {
             session_id: intent.metadata.session_id,
+            cart_id: intent.metadata.cart_id,
+            order_id: intent.metadata.order_id,
             amount: getAmountFromSmallestUnit(intent.amount, currency),
           },
         }