@spree/docs 0.1.0

package/dist/api-reference/storefront/authentication.md

@@ -0,0 +1,88 @@
+---
+title: Authentication
+description: Learn how to authenticate requests to the Storefront API.
+---
+
+Storefront API requires authorization only for certain actions associated with user account (e.g. updating saved addresses) or manipulating cart and checkout.
+
+## For guest users
+
+### Using X-Spree-Order-Token header
+
+[Cart](/api-reference/storefront/cart) and [Checkout](/api-reference/storefront/checkout) endpoints paths also allow interactions without the bearer token to allow creating and managing guest checkouts.
+
+When you first create a cart via:
+
+```bash
+curl --request POST \
+  --url 'https://demo.spreecommerce.org/api/v2/storefront/cart?fields%5Bcart%5D=number%2Ctoken' \
+  --header 'Content-Type: application/vnd.api+json'
+```
+
+You'll receive a response containing an empty cart. This response also contains a `data.token` attribute.
+
+```json
+{
+  "data": {
+    "id": "114",
+    "type": "cart",
+    "attributes": {
+      "number": "R522550303",
+      "token": "NswjLVjZOw4OpEm1yWqlJg1713367317414"
+    },
+    "relationships": {}
+  }
+}
+```
+
+You can store this token in the frontend session (eg. Session Storage or a cookie) and pass it in a `X-Spree-Order-Token: {token}` header.
+
+## For signed in users
+
+For users who have an account in your store, you will need to generate oAuth tokens to authenticate requests to endpoints such as [Account](/api-reference/storefront/account), [Cart](/api-reference/storefront/cart) and [Checkout](/api-reference/storefront/checkout).
+
+### Generating OAuth token
+
+To obtain a token, execute the following curl command:
+
+```bash
+curl -X POST http://localhost:3000/spree_oauth/token \
+     --header "Content-Type: application/x-www-form-urlencoded" \
+     --data "grant_type=password&username=spree@example.com&password=spree123"
+```
+
+You should receive a JSON response with a `access_token` and a `refresh_token`, eg.
+
+```json
+{
+  "access_token": "CmVXoDp6f5Y51s2xFAAdSbdT5wcGZIuGKKr27zAkBvQ",
+  "token_type": "Bearer",
+  "expires_in": 7200,
+  "refresh_token": "g5xPzY51_QYyok-ZcH9f4_btBkT_RZ6pB7ugGRaMjQQ",
+  "created_at": 1713367848
+}
+```
+
+### Refreshing OAuth token
+
+OAuth tokens obtained via the previous step are valid only for a specific time (defined in `expires_in` attribute). 
+
+After that period, you can refresh the token by executing the following curl command:
+
+```bash
+curl -X POST http://localhost:3000/spree_oauth/token \
+     --header "Content-Type: application/x-www-form-urlencoded" \
+     --data "grant_type=refresh_token&refresh_token=g5xPzY51_QYyok-ZcH9f4_btBkT_RZ6pB7ugGRaMjQQ"
+```
+
+On a success, you'll receive a new bearer token to use when accessing the API, eg.
+
+```json
+{
+  "access_token": "JVMcaoCkxV4o2xofhAwf7ReeFEWUM94ZnVSKRITd3TQ",
+  "token_type": "Bearer",
+  "expires_in": 7200,
+  "refresh_token": "nMlyfxfA9U6xfSDnFhoZQzL4IOkDc-EkW1y66ZTf5Oc",
+  "created_at": 1713367950
+}
+```

package/dist/api-reference/tutorials/adyen-integration-guide-for-android.md

@@ -0,0 +1,165 @@
+---
+title: Adyen Integration Guide for Android
+description: This guide provides step-by-step instructions for integrating Adyen Android Drop-in with spree_adyen using session flow and Drop-In component.
+---
+
+> **WARNING:** This guide is aimed at advanced users who want to create adyen integration for their custom android application.
+> You also need to install Spree Adyen extension before.
+
+## Note
+
+The list of available library versions can be found on [Official Adyen Documentation for Android integration](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow/?platform=Android&integration=Drop-in&version=5.13.1)
+Current newest version available at the moment of writing the tutorial is 5.13.1.
+This doc will be referring to the library version as YOUR_VERSION.
+
+## Resources
+
+- [Official Adyen Documentation for Android integration](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow/?platform=Android&integration=Drop-in&version=5.13.1)
+- Spree Adyen API docs - [create payment_session](/api-reference/storefront/adyen/create-an-adyen-payment-session) and [get payment_session](/api-reference/storefront/adyen/get-adyen-payment-session)
+- [Official Adyen example for Android integration](https://github.com/adyen-examples/adyen-android-online-payments)
+
+## Overview
+
+The integration consists of two main components:
+
+- **Spree Adyen**: Provides API for your client and receive payment result from Adyen
+- **Your Android client app**: Shows the Drop-in UI and handles payment flow
+
+## Step 1: Import the library
+
+Import the compatibility module:
+
+### Import the module with Jet Compose
+
+```bash
+implementation "com.adyen.checkout:drop-in-compose:YOUR_VERSION"
+```
+
+### Import without Jet Compose
+
+```bash
+implementation "com.adyen.checkout:drop-in:YOUR_VERSION"
+```
+
+## Step 2: Create a checkout session
+
+Create session using [this endpoint](/api-reference/storefront/adyen/create-an-adyen-payment-session).
+
+```kotlin
+val sessionModel = SessionModel.SERIALIZER.deserialize(sessionsResponseJSON)
+```
+
+sessionsResponseJSON should contain:
+- `sessionData` - available as `adyen_data` in payment_session API response
+- `id` - available as `adyen_id` in payment_session API response
+
+```kotlin
+val sessionModel = SessionModel.SERIALIZER.deserialize(sessionsResponseJSON)
+```
+
+## Step 3
+
+call `CheckoutSessionProvider.createSession` passing serialized session data (`sessionModel`) and `dropInConfiguration`
+
+dropInConfiguration example:
+
+```kotlin
+val checkoutConfiguration = CheckoutConfiguration(
+	    environment = environment,
+	    clientKey = clientKey,
+	    shopperLocale = shopperLocale, // Optional
+	) {
+	    // Optional: add Drop-in configuration.
+	    dropIn {
+	        setEnableRemovingStoredPaymentMethods(true)
+	    }
+	 
+	    // Optional: add or change default configuration for the card payment method.
+	    card {
+	        setHolderNameRequired(true)
+	        setShopperReference("...")
+	    }
+	 
+	    // Optional: change configuration for 3D Secure 2.
+	    adyen3DS2 {
+	        setThreeDSRequestorAppURL("...")
+	    }
+	}
+```
+see also: https://docs.adyen.com/online-payments/build-your-integration/sessions-flow/?platform=Web&integration=Drop-in&version=6.18.1#create-instance
+
+
+`environment` - enum: `live` or `test`
+`clientKey` - `client_key` from payment_sessions endpoint
+`shopperLocale` - shopper locale in ISO format
+
+
+```kotlin
+	// Create an object for the checkout session.
+	val result = CheckoutSessionProvider.createSession(sessionModel, dropInConfiguration)
+	 
+	// If the payment session is successful, handle the result.
+	// If the payment session encounters an error, handle the error.
+	when (result) {
+	    is CheckoutSessionResult.Success -> handleCheckoutSession(result.checkoutSession)
+	    is CheckoutSessionResult.Error -> handleError(result.exception)
+	}
+```
+
+## Step 4: Launch and show Drop-in
+
+```kotlin
+	override fun onDropInResult(sessionDropInResult: SessionDropInResult?) {
+	   when (sessionDropInResult) {
+	      // The payment finishes with a result.
+	      is SessionDropInResult.Finished -> handleResult(sessionDropInResult.result)
+	      // The shopper dismisses Drop-in.
+	      is SessionDropInResult.CancelledByUser ->
+	      // Drop-in encounters an error.
+	      is SessionDropInResult.Error -> handleError(sessionDropInResult.reason)
+	      // Drop-in encounters an unexpected state.
+	      null ->
+	   }
+	}
+```
+
+## Step 5: Create the Drop-in launcher
+
+DropIn.startPayment, passing:
+
+- `dropInLauncher` - The Drop-in launcher object
+- `checkoutSession` - result of `CheckoutSessionProvider.createSession`
+- `dropInConfiguration` - Your Drop-in configuration
+
+Example:
+
+```kotlin
+	import com.adyen.checkout.dropin.compose.startPayment
+	import com.adyen.checkout.dropin.compose.rememberLauncherForDropInResult
+	 
+	@Composable
+	private fun ComposableDropIn() {
+	    val dropInLauncher = rememberLauncherForDropInResult(sessionDropInCallback)
+	 
+	    DropIn.startPayment(dropInLauncher, checkoutSession, dropInConfiguration)
+	}
+```
+
+## Get payment outcome
+
+1. Wait for backend to process the payment
+2. Continue shopping experience
+
+### 1. Wait for backend to process the payment
+
+backend will change the state of `payment_session` to one of the following state
+
+- `pending` - chosen payment method can take a while to complete 
+- `completed` - payment resulted in success, order completed
+- `canceled` - payment canceled, payment is `void`
+- `refused` - payment failed
+
+### 2. Continue shopping experience
+
+if succeed - order is processed and completed
+if failed - payment can be retried using new payment session

package/dist/api-reference/tutorials/adyen-integration-guide-for-ios.md

@@ -0,0 +1,194 @@
+---
+title: Adyen Integration Guide for iOS
+description: This guide provides step-by-step instructions for integrating Adyen iOS Drop-in with spree_adyen using session flow and Drop-In component.
+---
+
+> **WARNING:** This guide is aimed at advanced users who want to create adyen integration for their custom iOS application.
+> You also need to install Spree Adyen extension before.
+
+## Requirements
+
+- Adyen test account
+- Set up `spree_adyen` spree extension
+
+### return_url
+
+spree_adyen needs to be configured with `return_url`.
+
+Return url tells where shopper should be redirect after the payment from outside your application (for example klarna or most of others buy now pay later systems).
+
+Use the custom URL for your app, like `my-app://adyen`. Url can contain custom query params however do not include any personally identifiable information (PII) of your customer. Maximum length of the url is 1024 characters.
+
+## Note
+
+The list of available library versions can be found on [Official Adyen Documentation for iOS integration](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow/?platform=iOS&integration=Drop-in&version=5.13.1)
+Current newest version available at the moment of writing the tutorial is 5.19.2.
+
+## Resources
+
+- [Official Adyen Documentation for iOS integration](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow/?platform=iOS&integration=Drop-in&version=5.19.2)
+- Spree Adyen API docs - [create payment_session](/api-reference/storefront/adyen/create-an-adyen-payment-session) and [get payment_session](/api-reference/storefront/adyen/get-adyen-payment-session)
+- [Official Adyen example for iOS integration](https://github.com/Adyen/adyen-ios/tree/develop/Demo)
+- Apple Developer documentation on [defining custom url scheme](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app)
+
+## Overview
+
+The integration consists of two main components:
+
+- **Spree Adyen**: Provides API for your client and receive payment result from Adyen
+- **Your iOS client app**: Shows the Drop-in UI and handles payment flow
+
+## Step 1: Install adyen with Swift Package Manager
+
+repository URL:
+```
+https://github.com/Adyen/adyen-ios
+```
+use at least version 5.0.0
+
+CocoaPods and Carthage instructions are available [here](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow/?platform=iOS&integration=Drop-in&version=5.19.2&tab=cocoapods_1_2#1-get-adyen-ios).
+
+## Step 2: Create the context
+
+Create the instance of APIContext that includes client key and environment setting.
+
+```swift
+// Set the client key and environment in an instance of APIContext.
+let apiContext = APIContext(clientKey: clientKey, environment: Environment.test) // Set the environment to a live one when going live.
+// Create the amount with the value in minor units and the currency code.
+let amount = Amount(value: 1000, currencyCode: "EUR")
+// Create the payment object with the amount and country code.
+let payment = Payment(amount: amount, countryCode: "NL")
+// Create an instance of AdyenContext, passing the instance of APIContext, and payment object.
+let adyenContext = AdyenContext(apiContext: apiContext, payment:payment)
+```
+
+`environment` - Environment.test or Environment.live
+`clientKey` - `client_key` from payment_sessions endpoint
+
+## Step 3: Create and set up session
+
+Create a session using [payment_session endpoint](/api-reference/storefront/adyen/create-an-adyen-payment-session).
+Then set a configuration using data from the response:
+
+```swift
+let configuration = AdyenSession.Configuration(sessionIdentifier: sessionId,
+                                                initialSessionData: data)
+```
+
+- `data` - available as `adyen_data` in payment_session API response
+- `sessionId` - available as `adyen_id` in payment_session API response
+
+With the configuration you initialize AdyenSession:
+
+```swift
+AdyenSession.initialize(with: configuration, delegate: self, presentationDelegate: self) { [weak self] result in
+        switch result {
+        case let .success(session):
+            //Store the session object.
+            self?.session = session
+        case let .failure(error):
+            //Handle the error.
+        }
+    }
+```
+
+## Step 4. Configure Drop-in
+
+```swift
+let dropInConfiguration = DropInComponent.Configuration()
+// Some payment methods have additional required or optional configuration.
+// For example, an optional configuration to show the cardholder name field for cards.
+dropInConfiguration.card.showsHolderNameField = true
+```
+
+## Step 5: Initialize the DropInComponent class
+
+```swift
+let dropInComponent = DropInComponent(paymentMethods: session.sessionContext.paymentMethods,
+                                      context: adyenContext,
+                                      configuration: dropInConfiguration)
+  
+// Keep the instance of Drop-in to so that it doesn't get destroyed after the function is executed.
+self.dropInComponent = dropInComponent
+  
+// Set the session as the delegate.
+dropInComponent.delegate = session
+// If you support gift cards, set the session as the partial payment delegate.
+dropInComponent.partialPaymentDelegate = session
+```
+
+## Step 6: Show Drop-in in your app
+
+```swift
+myCheckoutViewController.present(dropInComponent.viewController, animated: true)
+```
+
+If the `action` field is `redirect` you need to handle the redirect result.
+
+## Step 7. Handling the redirect result
+
+If the `action` field returns `redirect` the shopper is completing the payment outside of your application. You need to inform the Drop-in when the shopper returns to your app.
+
+Here an example for a Custom Url scheme:
+- implement the following in your `UIApplicationDelegate`:
+
+```swift
+func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
+    return RedirectComponent.applicationDidOpen(from: url)
+}
+```
+
+for Universal URL use this instead:
+```swift
+func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
+    guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
+            let incomingURL = userActivity.webpageURL else { return false }
+    return RedirectComponent.applicationDidOpen(from: incomingURL)
+}
+```
+
+## Step 8: Show the shopper result of the payment
+
+When the payment flow is finished, your instance of AdyenSession calls the didComplete method.
+Implement the following in your Drop-in configuration object.
+
+```swift
+func didComplete(with result: AdyenSessionResult, // The session result.
+                  component: Component, // The Drop-in component.
+                  session: AdyenSession) // Your instance of AdyenSession.
+```
+
+Use the resultCode to inform your shopper about the current payment status.
+Possible resultCode values:
+- `authorised` - payment authorised
+- `refused` - payment refused
+- `pending` - payment pending (for payments with asynchronous flow like iDEAL). When the shopper completes the payment webhook will process process the payment.
+- `cancelled` - payment canceled
+- `received` - some payments needs more time to be processed. When the status is available webhook will process the payment
+- `error` - an error occurred when processing the payment. The response contains more details with the error code
+  Your instance of AdyenSession calls the didFail method containing the error.
+  ```swift
+  func didFail(with error: Error, // The error object.
+               from component: Component, // The Drop-in component.
+               session: AdyenSession) // Your instance of AdyenSession.
+  ```
+
+## Step 8: Continue shopping experience
+
+1. Wait for backend to process the payment
+2. Continue shopping experience
+
+### 1. Wait for backend to process the payment
+
+backend after receiving webhook will change the state of `payment_session` to one of the following state:
+- `pending` - chosen payment method can take a while to complete
+- `completed` - payment resulted in success, order completed
+- `canceled` - payment canceled, payment is `void`
+- `refused` - payment failed
+
+### 2. Continue shopping experience
+
+if succeed - order is processed and completed
+
+if failed - payment can be retried using new payment session

package/dist/api-reference/tutorials/quick-checkout-with-stripe.md

@@ -0,0 +1,248 @@
+---
+title: Quick Checkout with Stripe and Storefront API
+description: This tutorial will show you how to add quick checkout to your headless/composable storefront using Stripe and Spree APIs.
+---
+
+> **WARNING:** This guide is aimed at advanced users who have some experience with Spree API and Stripe.
+> You also need to install [Spree Stripe](https://github.com/spree/spree_stripe) extension before.
+
+> **INFO:** If you're using the standard Spree Storefront, then you can skip this tutorial as quick checkout is already built in.
+
+## Prerequisites
+
+Assume that you have a cart made with line items in it already.
+
+Quick checkout works by handling 3 different events:
+- Address change
+- Shipping Method/Rate change
+- Confirmation
+
+How you should handle them depends on your platform/language:
+
+- For Web and JS, please review:
+  - [Express Checkout Element](https://docs.stripe.com/elements/express-checkout-element)
+  - We also recommend reviewing the [spree_stripe implementation in Stimulus.js](https://github.com/spree/spree_stripe/blob/main/app/javascript/spree_stripe/controllers/stripe_button_controller.js)
+
+- For iOS, please review:
+  - [StripeApplePay](https://docs.stripe.com/apple-pay)
+  - [STPApplePayContext](https://stripe.dev/stripe-ios/stripeapplepay/documentation/stripeapplepay/stpapplepaycontext#instance-methods)
+
+## Checkout Flow
+
+### Address change
+
+Here we need to send some basic information about the customer's shipping address, and we should move the order to the delivery step (don't forget to replace the placeholders with the customer's data):
+
+<details>
+<summary>Update the checkout</summary>
+
+```bash Update order [expandable]
+    curl -X PATCH <SHOP URL>/api/v2/storefront/checkout \
+      -H 'Authorization: Bearer <Token>' \
+      -H 'Content-Type: application/json' \
+      -d '{
+        "order": {
+          "ship_address_attributes": {
+            "quick_checkout": true,
+            "firstname": <First name>,
+            "lastname": <Last name>,
+            "city": <City>,
+            "zipcode": <Zip>,
+            "country_iso": <Country>,
+            "state_name": <State>
+          },
+          "bill_address_id": "CLEAR"
+        }
+      }'
+    ```
+
+    - **`quick_checkout`** (`bool`) — `true` indicating that the order is from quick checkout. It is required as the address details you will receive from Apple Pay or Google Pay are not complete and wouldn't be valid for the standard checkout.
+
+    - **`firstname`** (`string`) — Customer's first name, e.g. John
+
+    - **`lastname`** (`string`) — Customer's last name, e.g. Doe
+
+    - **`city`** (`string`) — Customer's city, e.g. Mountain View
+
+    - **`zipcode`** (`string`) — Customer's zip code, e.g. 94043
+
+    - **`country_iso`** (`string`) — Customer's country ISO, e.g. US
+
+    - **`state_name`** (`string`) — Customer's address state, e.g. CA (empty string is also accepted)
+
+    - **`bill_address_id`** (`string`) — Set it to `CLEAR` to clear the existing billing address (this prevents the order from accidentally advancing to the `payment` step).
+
+    [Full documentation](/api-reference/storefront/checkout/update-checkout)
+
+</details>
+
+<details>
+<summary>Move the order to the delivery step</summary>
+
+[Endpoint documentation](/api-reference/storefront/checkout-state/advance-checkout)
+
+```bash Advance order to the delivery step
+curl -X PATCH '<SHOP URL>/api/v2/storefront/checkout/advance?state=delivery&include=shipments.shipping_rates' \
+  -H 'Authorization: Bearer <Token>' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "quick_checkout": true,
+    "shipping_method_id": <Shipping Method ID>
+  }'
+```
+
+- **`quick_checkout`** (`bool`) — `true` indicating that the order is from quick checkout
+
+- **`shipping_method_id`** (`string`) — You don't have to send `shipping_method_id` if you don't have it yet, but if you received `Shipping Method/Rate changed` event, and you already have the selected shipping method, then you can send it.
+
+This will return you an order response, and you can update the payment element with a new total (you should use `total_minus_store_credits` for total) and shipping rates.
+
+</details>
+
+
+### Shipping Method/Rate change
+
+Here we need to send the selected shipping method to the backend and update the total in the payment element
+
+[Endpoint documentation](/api-reference/storefront/checkout-shipments/selects-shipping-method-for-shipments)
+
+```bash Select shipping method
+curl -X PATCH '<SHOP URL>/api/v2/storefront/checkout/select_shipping_method' \
+  -H 'Authorization: Bearer <Token>' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "shipping_method_id": <Shipping Method ID>
+  }'
+```
+
+- **`shipping_method_id`** (`string`) — Shipping method ID of the selected shipping rate
+
+Subsequently, update the payment element with a new total taken from the response's `total_minus_store_credits`
+
+### Confirming the payment
+
+Now you should make several more calls to the backend
+
+<details>
+<summary>Confirm that the order is ready for the payment</summary>
+
+```bash Validate order for payment
+    curl -X POST '<SHOP URL>/api/v2/storefront/checkout/validate_order_for_payment?skip_state=true' \
+      -H 'Authorization: Bearer <Token>'
+    ```
+    > **INFO:** `200` response code means that the order is ready for the payment.
+
+    [Endpoint documentation](/api-reference/storefront/checkout/validate-order-payment)
+
+</details>
+
+  <details>
+<summary>Update the address with more data</summary>
+
+You should have a lot more information about the customer (in previous events, Stripe probably will not provide you information such as customer address), so send them to the backend:
+
+  [Endpoint documentation](/api-reference/storefront/checkout/update-checkout)
+
+  ```bash Update the order [expandable]
+  curl -X PATCH <SHOP URL>/api/v2/storefront/checkout \
+    -H 'Authorization: Bearer <Token>' \
+    -H 'Content-Type: application/json' \
+    -d '{
+      "order": {
+        "email": <EMAIL>,
+        "ship_address_attributes": {
+          "quick_checkout": true,
+          "firstname": <First name>,
+          "lastname": <Last name>,
+          "address1": <Address>,
+          "address2": <Address 2>,
+          "city": <City>,
+          "zipcode": <Zip>,
+          "country_iso": <Country>,
+          "state_name": <State>,
+          "phone": <Phone>
+        }
+      },
+      "do_not_change_state": true
+    }'
+  ```
+  - **`email`** (`string`) — Customer's email, e.g. email@example.com
+
+  - **`quick_checkout`** (`bool`) — `true` indicating that the order is from quick checkout
+
+  - **`firstname`** (`string`) — Customer's first name, e.g. John
+
+  - **`lastname`** (`string`) — Customer's last name, e.g. Doe
+
+  - **`address1`** (`string`) — Customer's address, e.g. 123 Main St
+
+  - **`address2`** (`string`) — Customer's address 2, e.g., Apt. 1
+
+  - **`zipcode`** (`string`) — Customer's zip code, e.g. 94043
+
+  - **`country_iso`** (`string`) — Customer's country ISO, e.g. US
+
+  - **`state_name`** (`string`) — Customer's address state, e.g. CA (empty string is also accepted)
+
+  - **`phone`** (`string`) — Customer's phone number, e.g. +1234567890
+
+  - **`do_not_change_state`** (`bool`) — Set it to `true` so the order does not advance to the next state
+
+</details>
+
+
+  <details>
+<summary>Move the order to the payment step</summary>
+
+[Endpoint documentation](/api-reference/storefront/checkout-state/advance-checkout)
+  ```bash Move the order to the payment step
+  curl -X PATCH '<SHOP URL>/api/v2/storefront/checkout/advance?state=payment' \
+    -H 'Authorization: Bearer <Token>' \
+    -d '{
+      "shipping_method_id": <Shipping Method ID>
+    }'
+  ```
+  - **`shipping_method_id`** (`string`) — Shipping method ID of the selected shipping rate
+
+</details>
+
+
+Thereafter, you should confirm the payment intent using the Stripe library; this depends on your platform/language.
+
+> **WARNING:** `<PAYMENT INTENT ID>` should be Spree's internal payment intent ID, which you will receive when you create the payment intent. Do not confuse it with Stripe's payment intent ID.
+
+If you like to redirect the user to Spree's order summary page, then set the `return_url` when confirming the payment intent to `<SHOP URL>/stripe/payment_intents/<PAYMENT INTENT ID>`. This will check if the payment intent is confirmed, move the order to the complete state, and redirect the user to the order summary.
+
+If you like to make the order summary page by yourself, then after confirming the payment intent in Stripe, make this request:
+
+
+```bash Confirm payment intent
+curl -X POST <SHOP URL>/api/v2/storefront/stripe/payment_intents/<PAYMENT INTENT ID>/confirm \
+  -H 'Authorization: Bearer <Token>'
+```
+
+[Endpoint documentation](/api-reference/storefront/stripe/mark-the-payment-intent-as-confirmed-and-move-the-order-to-the-complete-state)
+
+This will also check if the payment intent is confirmed, and it will move the order to the complete state
+
+### User cancels the payment
+
+If at any point, the user cancels the payment (closes the quick checkout sheet/modal), you will need to handle this event and clear the shipping and billing address from the order as these addresses will not be valid and if someones decides to use standard checkout it could lead to errors.
+
+```bash Reset order addresses
+curl -X PATCH <SHOP URL>/api/v2/storefront/checkout \
+  -H 'Authorization: Bearer <Token>' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "order": {
+      "ship_address_id": "CLEAR",
+      "bill_address_id": "CLEAR"
+    }
+  }'
+```
+
+[Endpoint documentation](/api-reference/storefront/checkout/update-checkout)
+
+### All Done!
+
+Congrats! Now, your users should be able to pay for orders with quick checkout! Need support or want to give some feedback? You can join our [community](https://slack.spreecommerce.org/) or drop us an email at [hello@spreecommerce.org](mailto:hello@spreecommerce.org).