Skip to main content
This addon enables Stripe payments on your Lunar storefront.

​
Installation

​
Require the composer package

composer require lunarphp/stripe

​
Publish the configuration

This will publish the configuration under config/lunar/stripe.php. 
php artisan vendor:publish --tag=lunar.stripe.config

​
Publish the views (optional)

Lunar Stripe comes with some helper components for you to use on your checkout, if you intend to edit the views they provide, you can publish them. 
php artisan vendor:publish --tag=lunar.stripe.components

​
Enable the driver

Set the driver in config/lunar/payments.php 
<?php

return [
    // ...
    'types' => [
        'card' => [
            // ...
            'driver' => 'stripe',
        ],
    ],
];

​
Add your Stripe credentials

Make sure you have the Stripe credentials set in config/services.php 
'stripe' => [
    'key' => env('STRIPE_SECRET'),
    'public_key' => env('STRIPE_PK'),
    'webhooks' => [
        'lunar' => env('LUNAR_STRIPE_WEBHOOK_SECRET'),
    ],
],
Keys can be found in your Stripe account https://dashboard.stripe.com/apikeys

​
Configuration

Below is a list of the available configuration options this package uses in config/lunar/stripe.php
KeyDefaultDescription
policyautomaticDetermines the policy for taking payments and whether you wish to capture the payment manually later or take payment straight away. Available options manual or automatic
sync_addressestrueWhen enabled, the Stripe addon will attempt to sync the billing and shipping addresses which have been stored against the payment intent on Stripe.

​
Backend Usage

​
Create a PaymentIntent

use \Lunar\Stripe\Facades\Stripe;

Stripe::createIntent(\Lunar\Models\Cart $cart, $options = []);
This method will create a Stripe PaymentIntent from a Cart and add the resulting ID to the meta for retrieval later. If a PaymentIntent already exists for a cart this will fetch it from Stripe and return that instead to avoid duplicate PaymentIntents being created. You can pass any additional parameters you need, by default the following are sent: 
[
    'amount' => 1099,
    'currency' => 'GBP',
    'automatic_payment_methods' => ['enabled' => true],
    'capture_method' => config('lunar.stripe.policy', 'automatic'),
    // If a shipping address exists on a cart
    // $shipping = $cart->shippingAddress
    'shipping' => [
        'name' => "{$shipping->first_name} {$shipping->last_name}",
        'phone' => $shipping->contact_phone,
        'address' => [
            'city' => $shipping->city,
            'country' => $shipping->country->iso2,
            'line1' => $shipping->line_one,
            'line2' => $shipping->line_two,
            'postal_code' => $shipping->postcode,
            'state' => $shipping->state,
        ],
    ]
]

$paymentIntentId = $cart->meta['payment_intent']; // The resulting ID from the method above.

$cart->meta->payment_intent;

​
Fetch an existing PaymentIntent

use \Lunar\Stripe\Facades\Stripe;

Stripe::fetchIntent($paymentIntentId);

​
Syncing an existing intent

If a payment intent has been created and there are changes to the cart, you will want to update the intent so it has the correct totals. 
use \Lunar\Stripe\Facades\Stripe;

Stripe::syncIntent(\Lunar\Models\Cart $cart);

​
Update an existing intent

For when you want to update certain properties on the PaymentIntent, without needing to recalculate the cart. See https://docs.stripe.com/api/payment_intents/update 
use \Lunar\Stripe\Facades\Stripe;

Stripe::updateIntent(\Lunar\Models\Cart $cart, [
    'shipping' => [/*..*/]
]);

​
Cancel an existing intent

If you need to cancel a PaymentIntent, you can do so. You will need to provide a valid reason, those of which can be found in the Stripe docs: https://docs.stripe.com/api/payment_intents/cancel. Lunar Stripe includes a PHP Enum to make this easier for you: 
use Lunar\Stripe\Enums\CancellationReason;

CancellationReason::ABANDONED;
CancellationReason::DUPLICATE;
CancellationReason::REQUESTED_BY_CUSTOMER;
CancellationReason::FRAUDULENT;

use Lunar\Stripe\Facades\Stripe;
use Lunar\Stripe\Enums\CancellationReason;

Stripe::cancelIntent(\Lunar\Models\Cart $cart, CancellationReason $reason);

​
Update the address on Stripe

So you don’t have to manually specify all the shipping address fields you can use the helper function to do it for you. 
use \Lunar\Stripe\Facades\Stripe;

Stripe::updateShippingAddress(\Lunar\Models\Cart $cart);

​
Charges

​
Retrieve a specific charge

use \Lunar\Stripe\Facades\Stripe;

Stripe::getCharge(string $chargeId);

​
Get all charges for a payment intent

use \Lunar\Stripe\Facades\Stripe;

Stripe::getCharges(string $paymentIntentId);

​
Webhooks

The add-on provides an optional webhook you may add to Stripe. You can read the guide on how to do this on the Stripe website https://stripe.com/docs/webhooks/quickstart. The events you should listen to are payment_intent.payment_failed, payment_intent.succeeded. The path to the webhook will be http:://yoursite.com/stripe/webhook. You can customise the path for the webhook in config/lunar/stripe.php. You will also need to add the webhook signing secret to the services.php config file: 
<?php

return [
// ...
    'stripe' => [
        // ...
        'webhooks' => [
            'lunar' => '...'
        ],
    ],
];
If you do not wish to use the webhook, or would like to manually process an order as well, you are able to do so. 
$cart = CartSession::current();

// With a draft order...
$draftOrder = $cart->createOrder();
Payments::driver('stripe')->order($draftOrder)->withData([
    'payment_intent' => $draftOrder->meta['payment_intent'],
])->authorize();

// Using just the cart...
Payments::driver('stripe')->cart($cart)->withData([
    'payment_intent' => $cart->meta['payment_intent'],
])->authorize();

​
Storefront Examples

First we need to set up the backend API call to fetch or create the intent, this isn’t Vue specific but will likely be different if you’re using Livewire. 
use \Lunar\Stripe\Facades\Stripe;

Route::post('api/payment-intent', function () {
$cart = CartSession::current();

$cartData = CartData::from($cart);

if ($paymentIntent = $cartData->meta['payment_intent'] ?? false) {
    $intent = StripeFacade::fetchIntent($paymentIntent);
} else {
    $intent = StripeFacade::createIntent($cart);
}

if ($intent->amount != $cart->total->value) {
    StripeFacade::syncIntent($cart);
}

return $intent;
})->middleware('web');

​
Vuejs

This is just using Stripe’s payment elements, for more information check out the Stripe guides

​
Payment component

<script setup>
    const { VITE_STRIPE_PK } = import.meta.env

    const stripe = Stripe(VITE_STRIPE_PK)
    const stripeElements = ref({})

    const buildForm = async () => {
        const { data } = await axios.post("api/payment-intent")

        stripeElements.value = stripe.elements({
            clientSecret: data.client_secret,
        })

        const paymentElement = stripeElements.value.create("payment", {
            layout: "tabs",
            defaultValues: {
                billingDetails: {
                    name: `{$billingAddress.value.first_name} {$billingAddress.value?.last_name}`,
                    phone: billingAddress.value?.contact_phone,
                },
            },
            fields: {
                billingDetails: "never",
            },
        })

        paymentElement.mount("#payment-element")
    }

    onMounted(async () => {
        await buildForm()
    })

    // The address object can be either passed through as props or via a second API call, but it should likely come from the cart.

    const submit = async () => {
        try {
            const address = {...}

            const { error } = await stripe.confirmPayment({
                //`Elements` instance that was used to create the Payment Element
                elements: stripeElements.value,
                confirmParams: {
                    return_url: 'http://yoursite.com/checkout/complete',
                    payment_method_data: {
                        billing_details: {
                            name: `{$address.first_name} {$address.last_name}`,
                            email: address.contact_email,
                            phone: address.contact_phone,
                            address: {
                                city: address.city,
                                country: address.country.iso2,
                                line1: address.line_one,
                                line2: address.line_two,
                                postal_code: address.postcode,
                                state: address.state,
                            },
                        },
                    },
                },
            })
        } catch (e) {

        }
}
</script>

<template>
    <form @submit.prevent="submit">
    <div id="payment-element">
        <!--Stripe.js injects the Payment Element-->
    </div>
</form>
</template>

​
Extending

​
Webhook event params

In order to process the payment intent and link it to an order, we need the PaymentIntent ID and an optional Order ID. By default Lunar Stripe will look for the PaymentIntent ID via the Stripe Event and try and determine whether an existing order ID has been defined on the PaymentIntent meta. You can customise this behaviour by overriding the ProcessesEventParameters instance. 
// AppServiceProvider
use Lunar\Stripe\Concerns\ProcessesEventParameters;
use Lunar\Stripe\DataTransferObjects\EventParameters;

public function boot()
{
    $this->app->instance(ProcessesEventParameters::class, new class implements ProcessesEventParameters
    {
        public function handle(\Stripe\Event $event): EventParameters
        {
            $paymentIntentId = $event->data->object->id;
            // Setting $orderId to null will mean a new order is created.
            $orderId = null;

            return new EventParameters($paymentIntentId, $orderId);
        }
    });

​
Events

Below are the events which are dispatched under specific situations within the addon.

​
CartMissingForIntent

Dispatched when attempting to process a payment intent, but no matching Order or Cart model can be found. 
use Lunar\Stripe\Events\Webhook\CartMissingForIntent;

public function handle(CartMissingForIntent $event)
{
    echo $event->paymentIntentId;
}