npm - @storecraft/payments-stripe - Versions diffs - 1.0.0 - Mend

@storecraft/payments-stripe 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md ADDED Viewed

@@ -0,0 +1,82 @@
+# Stripe payment gateway for **StoreCraft**
+[Stripe](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method) integration
+```bash
+npm i @storecraft/payments-stripe
+```
+## Howto
+```js
+import { Stripe } from '@storecraft/payments-stripe';
+import { Stripe as StripeCls } from 'stripe';
+const config = {
+  //`stripe` publishable key
+  publishable_key: 'pk_....',
+  // `stripe` private secret
+  secret: 'sk_.....',
+  // (Optional) `stripe` private `webhook` secret
+  webhook_endpoint_secret: 'whsec_.....',
+  // config options for `stripe`
+  stripe_config: {
+    httpClient: StripeCls.createFetchHttpClient()
+  },
+  // configure `intent` creation
+  stripe_intent_create_params: {
+    currency: 'usd',
+    automatic_payment_methods: {
+      enabled: true,
+    },
+    payment_method_options: {
+      card: {
+        // authorize and capture flow
+        capture_method: 'manual',
+      },
+    },
+  }
+}
+new Stripe(config);
+```
+## Developer info and test
+First, some resources from `stripe`
+- [Authorize and Capture Flow](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method)
+- [Webhooks](https://docs.stripe.com/webhooks)
+- [Credit Card Generator](https://developer.paypal.com/tools/sandbox/card-testing/#link-creditcardgenerator)
+## Test Webhooks
+First, consult [Stripe Webhooks Docs](https://docs.stripe.com/webhooks)
+Then, Install the `stripe` cli.
+```bash
+stripe listen --skip-verify --forward-to localhost:8000/api/payments/gateways/stripe/webhook
+```
+This will print the `webhook` **SECRET**
+```bash
+Ready! Your webhook signing secret is '{{WEBHOOK_SIGNING_SECRET}}' (^C to quit)
+```
+Copy the `WEBHOOK_SIGNING_SECRET` and put it in the `config` of the gateway.
+Now, start interacting, and test some payments.
+## todo:
+- Add tests
+```text
+Author: Tomer Shalev (tomer.shalev@gmail.com)
+```

package/adapter.html.js ADDED Viewed

@@ -0,0 +1,311 @@
+/**
+ *
+ * @description Official `Stripe` UI integration with `storecraft`.
+ *
+ * Test with dummy data with this generator
+ * https://docs.stripe.com/payments/quickstart
+ *
+ * Or use the following dummy details:
+ * https://docs.stripe.com/testing?testing-method=card-numbers
+ * - Card number: 4242424242424242
+ * - Expiry date: 12/2027
+ * - CVC code: 897
+ *
+ * @param {import("./types.public.js").Config} config
+ * @param {Partial<import("@storecraft/core/v-api").OrderData>} order_data
+ */
+export default function html_buy_ui(config, order_data) {
+  /** @type {import("./adapter.js").CheckoutCreateResult} */
+  const on_checkout_create = order_data?.payment_gateway?.on_checkout_create;
+  return `
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Accept a payment</title>
+    <meta name="description" content="A demo of a payment on Stripe" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <script src="https://js.stripe.com/v3/"></script>
+    <script defer>
+      // This is your test publishable API key.
+      const stripe = new Stripe("${config.publishable_key}");
+      let elements;
+      window.onload = function() {
+        initialize();
+        checkStatus();
+        document
+        .getElementById("payment-form")
+        .addEventListener("submit", handleSubmit);
+      }
+      // Fetches a payment intent and captures the client secret
+      async function initialize() {
+        const clientSecret = "${on_checkout_create.client_secret}";
+        const appearance = {
+          theme: 'stripe',
+        };
+        elements = stripe.elements({ appearance, clientSecret });
+        const paymentElementOptions = {
+          layout: "tabs",
+        };
+        const paymentElement = elements.create("payment", paymentElementOptions);
+        paymentElement.mount("#payment-element");
+      }
+      async function handleSubmit(e) {
+        e.preventDefault();
+        setLoading(true);
+        const { error } = await stripe.confirmPayment({
+          elements,
+          confirmParams: {
+            // Make sure to change this to your payment completion page
+            return_url: "https://storecraft.app/",
+          },
+        });
+        // This point will only be reached if there is an immediate error when
+        // confirming the payment. Otherwise, your customer will be redirected to
+        // your \`return_url\`. For some payment methods like iDEAL, your customer will
+        // be redirected to an intermediate site first to authorize the payment, then
+        // redirected to the \`return_url\`.
+        if (error.type === "card_error" || error.type === "validation_error") {
+          showMessage(error.message);
+        } else {
+          showMessage("An unexpected error occurred.");
+        }
+        setLoading(false);
+      }
+      // Fetches the payment intent status after payment submission
+      async function checkStatus() {
+        const clientSecret = new URLSearchParams(window.location.search).get(
+          "payment_intent_client_secret"
+        );
+        if (!clientSecret) {
+          return;
+        }
+        const { paymentIntent } = await stripe.retrievePaymentIntent(clientSecret);
+        switch (paymentIntent.status) {
+          case "succeeded":
+            showMessage("Payment succeeded!");
+            break;
+          case "processing":
+            showMessage("Your payment is processing.");
+            break;
+          case "requires_payment_method":
+            showMessage("Your payment was not successful, please try again.");
+            break;
+          default:
+            showMessage("Something went wrong.");
+            break;
+        }
+      }
+      // ------- UI helpers -------
+      function showMessage(messageText) {
+        const messageContainer = document.querySelector("#payment-message");
+        messageContainer.classList.remove("hidden");
+        messageContainer.textContent = messageText;
+        setTimeout(function () {
+          messageContainer.classList.add("hidden");
+          messageContainer.textContent = "";
+        }, 4000);
+      }
+      // Show a spinner on payment submission
+      function setLoading(isLoading) {
+        if (isLoading) {
+          // Disable the button and show a spinner
+          document.querySelector("#submit").disabled = true;
+          document.querySelector("#spinner").classList.remove("hidden");
+          document.querySelector("#button-text").classList.add("hidden");
+        } else {
+          document.querySelector("#submit").disabled = false;
+          document.querySelector("#spinner").classList.add("hidden");
+          document.querySelector("#button-text").classList.remove("hidden");
+        }
+      }
+    </script>
+    <style>
+      /* Variables */
+      * {
+        box-sizing: border-box;
+      }
+      body {
+        font-family: -apple-system, BlinkMacSystemFont, sans-serif;
+        font-size: 16px;
+        -webkit-font-smoothing: antialiased;
+        display: flex;
+        justify-content: center;
+        align-content: center;
+        height: 100vh;
+        width: 100vw;
+      }
+      form {
+        width: 30vw;
+        min-width: 500px;
+        align-self: center;
+        box-shadow: 0px 0px 0px 0.5px rgba(50, 50, 93, 0.1),
+          0px 2px 5px 0px rgba(50, 50, 93, 0.1), 0px 1px 1.5px 0px rgba(0, 0, 0, 0.07);
+        border-radius: 7px;
+        padding: 40px;
+      }
+      .hidden {
+        display: none;
+      }
+      #payment-message {
+        color: rgb(105, 115, 134);
+        font-size: 16px;
+        line-height: 20px;
+        padding-top: 12px;
+        text-align: center;
+      }
+      #payment-element {
+        margin-bottom: 24px;
+      }
+      /* Buttons and links */
+      button {
+        background: #5469d4;
+        font-family: Arial, sans-serif;
+        color: #ffffff;
+        border-radius: 4px;
+        border: 0;
+        padding: 12px 16px;
+        font-size: 16px;
+        font-weight: 600;
+        cursor: pointer;
+        display: block;
+        transition: all 0.2s ease;
+        box-shadow: 0px 4px 5.5px 0px rgba(0, 0, 0, 0.07);
+        width: 100%;
+      }
+      button:hover {
+        filter: contrast(115%);
+      }
+      button:disabled {
+        opacity: 0.5;
+        cursor: default;
+      }
+      /* spinner/processing state, errors */
+      .spinner,
+      .spinner:before,
+      .spinner:after {
+        border-radius: 50%;
+      }
+      .spinner {
+        color: #ffffff;
+        font-size: 22px;
+        text-indent: -99999px;
+        margin: 0px auto;
+        position: relative;
+        width: 20px;
+        height: 20px;
+        box-shadow: inset 0 0 0 2px;
+        -webkit-transform: translateZ(0);
+        -ms-transform: translateZ(0);
+        transform: translateZ(0);
+      }
+      .spinner:before,
+      .spinner:after {
+        position: absolute;
+        content: "";
+      }
+      .spinner:before {
+        width: 10.4px;
+        height: 20.4px;
+        background: #5469d4;
+        border-radius: 20.4px 0 0 20.4px;
+        top: -0.2px;
+        left: -0.2px;
+        -webkit-transform-origin: 10.4px 10.2px;
+        transform-origin: 10.4px 10.2px;
+        -webkit-animation: loading 2s infinite ease 1.5s;
+        animation: loading 2s infinite ease 1.5s;
+      }
+      .spinner:after {
+        width: 10.4px;
+        height: 10.2px;
+        background: #5469d4;
+        border-radius: 0 10.2px 10.2px 0;
+        top: -0.1px;
+        left: 10.2px;
+        -webkit-transform-origin: 0px 10.2px;
+        transform-origin: 0px 10.2px;
+        -webkit-animation: loading 2s infinite ease;
+        animation: loading 2s infinite ease;
+      }
+      @-webkit-keyframes loading {
+        0% {
+          -webkit-transform: rotate(0deg);
+          transform: rotate(0deg);
+        }
+        100% {
+          -webkit-transform: rotate(360deg);
+          transform: rotate(360deg);
+        }
+      }
+      @keyframes loading {
+        0% {
+          -webkit-transform: rotate(0deg);
+          transform: rotate(0deg);
+        }
+        100% {
+          -webkit-transform: rotate(360deg);
+          transform: rotate(360deg);
+        }
+      }
+      @media only screen and (max-width: 600px) {
+        form {
+          width: 80vw;
+          min-width: initial;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <!-- Display a payment form -->
+    <form id="payment-form">
+      <div id="payment-element">
+        <!--Stripe.js injects the Payment Element-->
+      </div>
+      <button id="submit">
+        <div class="spinner hidden" id="spinner"></div>
+        <span id="button-text">Pay now</span>
+      </button>
+      <div id="payment-message" class="hidden"></div>
+    </form>
+  </body>
+</html>
+    `
+}

package/adapter.js ADDED Viewed

@@ -0,0 +1,410 @@
+import { CheckoutStatusEnum, PaymentOptionsEnum } from '@storecraft/core/v-api/types.api.enums.js';
+import { StorecraftError } from '@storecraft/core/v-api/utils.func.js';
+import html_buy_ui from './adapter.html.js';
+import { Stripe as StripeCls } from 'stripe'
+/**
+ * @typedef {StripeCls.Response<StripeCls.PaymentIntent>} CheckoutCreateResult
+ * @typedef {import('@storecraft/core/v-api').PaymentGatewayStatus} PaymentGatewayStatus
+ * @typedef {import('@storecraft/core/v-api').CheckoutStatusEnum} CheckoutStatusOptions
+ * @typedef {import('@storecraft/core/v-api').OrderData} OrderData
+ * @typedef {import('./types.public.js').Config} Config
+ * @typedef {import('@storecraft/core/v-payments').payment_gateway<Config, CheckoutCreateResult>} payment_gateway
+ */
+/**
+ * @description in a {@link StripeCls.PaymentIntent}, is a `metadata` key-value
+ * storage where we store the `order_id` of the `storecraft` order.
+ */
+export const metadata_storecraft_order_id = 'storecraft_order_id'
+/**
+ * @implements {payment_gateway}
+ *
+ * @description **Stripe** gateway (https://docs.stripe.com/payments/place-a-hold-on-a-payment-method)
+ */
+export class Stripe {
+  /** @type {Config} */ #_config;
+  /**
+   *
+   * @param {Config} config
+   */
+  constructor(config) {
+    this.#_config = this.#validate_and_resolve_config(config);
+    this.stripe = new StripeCls(
+      this.#_config.secret_key, this.#_config.stripe_config ?? {}
+    );
+  }
+  /**
+   *
+   * @param {Config} config
+   */
+  #validate_and_resolve_config(config) {
+    config = {
+      stripe_config: {
+        httpClient: StripeCls.createFetchHttpClient()
+      },
+      stripe_intent_create_params: {
+        currency: 'usd',
+        automatic_payment_methods: {
+          enabled: true,
+        },
+        payment_method_options: {
+          card: {
+            capture_method: 'manual',
+          },
+        },
+      },
+      ...config,
+    }
+    const is_valid = config.publishable_key && config.secret_key;
+    if(!is_valid) {
+      throw new StorecraftError(
+        `Payment gateway ${this.info.name ?? 'unknown'} has invalid config !!!
+        Missing client_id or secret`
+      )
+    }
+    return config;
+  }
+  get info() {
+    return {
+      name: 'Stripe',
+      description: `Stripe powers online and in-person payment processing and financial solutions for businesses of all sizes.`,
+      url: 'https://docs.stripe.com/payments/place-a-hold-on-a-payment-method',
+      logo_url: 'https://images.ctfassets.net/fzn2n1nzq965/HTTOloNPhisV9P4hlMPNA/cacf1bb88b9fc492dfad34378d844280/Stripe_icon_-_square.svg?q=80&w=256'
+    }
+  }
+  get config() {
+    return this.#_config;
+  }
+  get actions() {
+    return [
+      {
+        handle: 'capture',
+        name: 'Capture',
+        description: 'Capture an authorized payment'
+      },
+      {
+        handle: 'cancel',
+        name: 'Cancel',
+        description: 'Cancel an a payment'
+      },
+      {
+        handle: 'refund',
+        name: 'Refund',
+        description: 'Refund a captured payment'
+      },
+    ]
+  }
+  /**
+   *
+   * @type {payment_gateway["invokeAction"]}
+   */
+  invokeAction(action_handle) {
+    switch (action_handle) {
+      case 'capture':
+        return this.capture.bind(this);
+      case 'cancel':
+        return this.cancel.bind(this);
+      case 'refund':
+        return this.refund.bind(this);
+      default:
+        break;
+    }
+  }
+  /**
+   * @description (Optional) buy link ui
+   *
+   * @param {Partial<OrderData>} order
+   *
+   * @return {Promise<string>} html
+   */
+  async onBuyLinkHtml(order) {
+    return html_buy_ui(
+      this.config, order
+    )
+  }
+  /**
+   * @description on checkout create `hook`
+   *
+   * @param {OrderData} order
+   *
+   * @return {Promise<CheckoutCreateResult>}
+   */
+  async onCheckoutCreate(order) {
+    const paymentIntent = await this.stripe.paymentIntents.create(
+      {
+        amount: Math.floor(order.pricing.total * 100),
+        ...this.config.stripe_intent_create_params,
+        metadata: {
+          [metadata_storecraft_order_id]: order.id
+        }
+      }
+    );
+    return paymentIntent;
+  }
+  /**
+   * @description On checkout complete hook. With stripe, this corresponds
+   * to synchronous payments flows, which is discouraged by `stripe`.
+   * They advocate async flows where confirmation happens async from
+   * client side into their servers, and then you are notified via a
+   * webhook.
+   *
+   * @param {CheckoutCreateResult} create_result
+   *
+   * @return {ReturnType<payment_gateway["onCheckoutComplete"]>}
+   */
+  async onCheckoutComplete(create_result) {
+    const intent = await this.stripe.paymentIntents.confirm(
+      create_result.id
+    );
+    let status;
+    switch(intent.status) {
+      case 'succeeded':
+        status = {
+          payment: PaymentOptionsEnum.captured,
+          checkout: CheckoutStatusEnum.complete
+        }
+        break;
+      case 'requires_capture':
+        status = {
+          payment: PaymentOptionsEnum.authorized,
+          checkout: CheckoutStatusEnum.complete
+        }
+        break;
+      case 'requires_confirmation':
+      case 'requires_action':
+        status = {
+          checkout: CheckoutStatusEnum.requires_action
+        }
+        break;
+      default:
+        status = {
+          checkout: CheckoutStatusEnum.failed
+        }
+        break;
+    }
+    return {
+      status,
+      onCheckoutComplete: intent
+    }
+  }
+  /**
+   * @description Fetch the order and analyze it's status
+   *
+   *
+   * @param {CheckoutCreateResult} create_result
+   *
+   *
+   * @returns {Promise<PaymentGatewayStatus>}
+   */
+  async status(create_result) {
+    const o = await this.retrieve_order(create_result);
+    const lc = /** @type {StripeCls.Charge} */ (o.latest_charge);
+    /** @param {number} a */
+    const fmt = a => (a/100).toFixed(2) + o.currency.toUpperCase();
+    /** @type {PaymentGatewayStatus} */
+    const stat = {
+      messages: [],
+      actions: this.actions
+    }
+    if(o) { // just an intent
+      const date = new Date(o.created).toUTCString();
+      stat.messages = [
+        `A payment intent of **${fmt(o.amount)}** was initiated at ${date}`,
+        `The status is \`${o.status}\` and the ID is \`${o.id}\``
+      ];
+    }
+    if(lc?.captured) {
+      stat.messages.push(
+        `**${fmt(lc.amount_captured)}** was \`CAPTURED\``,
+      );
+    }
+    if(lc?.refunded) {
+      const date = lc?.refunds?.data?.[0]?.created ? (new Date(lc?.refunds?.data?.[0]?.created).toUTCString()) : 'unknown time';
+      stat.messages.push(
+        `**${fmt(lc.amount_refunded)}** was \`REFUNDED\` at \`${date}\``,
+      );
+    }
+    if(o?.canceled_at) {
+      const date = new Date(o.canceled_at).toUTCString();
+      stat.messages.push(
+        ...[
+          `Intent was \`CANCELLED\` at \`${date}\`.`,
+          o.cancellation_reason && `Cancellation reason is ${o.cancellation_reason}`
+        ].filter(Boolean)
+      );
+    }
+    return stat;
+  }
+  /**
+   * @description [https://docs.stripe.com/webhooks](https://docs.stripe.com/webhooks)
+   * @param {import('@storecraft/core').ApiRequest} request
+   * @param {import('@storecraft/core').ApiResponse} response
+   *
+   * @type {payment_gateway["webhook"]}
+   */
+  async webhook(request, response) {
+    const sig = request.headers.get('Stripe-Signature');
+    let event;
+    try {
+      event = await this.stripe.webhooks.constructEventAsync(
+        request.rawBody, sig, this.config.webhook_endpoint_secret, undefined,
+        StripeCls.createSubtleCryptoProvider()
+      );
+    }
+    catch (err) {
+      response.status = 400;
+      response.end();
+      console.log(err.message);
+      return;
+    }
+    let order_id;
+    /** @type {StripeCls.PaymentIntent} */
+    let payment_intent;
+    let payment_status = PaymentOptionsEnum.unpaid;
+    // Handle the event
+    switch (event?.type) {
+      case 'payment_intent.succeeded':
+      case 'payment_intent.payment_failed':
+      case 'payment_intent.requires_action':
+      case 'payment_intent.amount_capturable_updated':
+      case 'payment_intent.canceled':
+        payment_intent = event.data.object;
+        order_id = payment_intent.metadata[metadata_storecraft_order_id];
+        if(payment_intent.status==='requires_capture')
+          payment_status = PaymentOptionsEnum.authorized;
+        else if(payment_intent.status==='canceled')
+          payment_status = PaymentOptionsEnum.unpaid;
+        else if(payment_intent.status==='processing')
+          payment_status = PaymentOptionsEnum.unpaid;
+        else if(payment_intent.status==='requires_action')
+          payment_status = PaymentOptionsEnum.unpaid;
+        else if(payment_intent.status==='succeeded')
+          payment_status = PaymentOptionsEnum.captured;
+        break;
+      case 'charge.refunded':
+      case 'charge.refund.updated':
+        payment_status = PaymentOptionsEnum.refunded;
+      default:
+        console.log(`Unhandled event type ${event.type}`);
+    }
+    console.log('CCCC')
+    // Return a response to acknowledge receipt of the event
+    response.sendJson({received: true});
+    console.log('DDDD')
+    return {
+      order_id,
+      status: {
+        payment: payment_status,
+        checkout: CheckoutStatusEnum.complete
+      }
+    }
+  }
+  /**
+   * @description Retrieve latest order payload
+   *
+   * @param {CheckoutCreateResult} create_result first create result, holds `Stripe` intent
+   *
+   */
+  retrieve_order = (create_result) => {
+    return this.stripe.paymentIntents.retrieve(
+      create_result.id,
+      {
+        expand: ['latest_charge']
+      }
+    )
+  }
+  // actions
+  /**
+   * @description todo: logic for if user wanted capture at approval
+   *
+   * @param {CheckoutCreateResult} create_result
+   */
+  async cancel(create_result) {
+    await this.stripe.paymentIntents.cancel(
+      create_result.id,
+      {
+        cancellation_reason: 'abandoned'
+      }
+    );
+    return this.status(create_result);
+  }
+  /**
+   * @description todo: logic for if user wanted capture at approval
+   *
+   * @param {CheckoutCreateResult} create_result
+   */
+  async capture(create_result) {
+    await this.stripe.paymentIntents.capture(
+      create_result.id,
+      {
+        amount_to_capture: create_result.amount
+      }
+    );
+    return this.status(create_result);
+  }
+  /**
+   * @description todo: logic for if user wanted capture at approval
+   *
+   * @param {CheckoutCreateResult} create_result
+   */
+  async refund(create_result) {
+    const refund = await this.stripe.refunds.create(
+      {
+        payment_intent: create_result.id,
+        amount: create_result.amount,
+      }
+    );
+    return this.status(create_result);
+  }
+}

package/index.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export * from './adapter.js'

package/package.json ADDED Viewed

@@ -0,0 +1,35 @@
+{
+  "name": "@storecraft/payments-stripe",
+  "version": "1.0.0",
+  "description": "Official Storecraft <-> Stripe integration",
+  "license": "MIT",
+  "author": "Tomer Shalev (https://github.com/store-craft)",
+  "homepage": "https://github.com/store-craft/storecraft",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/store-craft/storecraft.git",
+    "directory": "packages/payments-stripe"
+  },
+  "keywords": [
+    "commerce",
+    "dashboard",
+    "code",
+    "storecraft"
+  ],
+  "type": "module",
+  "main": "index.js",
+  "types": "./types.public.d.ts",
+  "scripts": {
+    "payments-stripe:test": "uvu -c",
+    "payments-stripe:publish": "npm publish --access public"
+  },
+  "dependencies": {
+    "stripe": "^16.6.0"
+  },
+  "devDependencies": {
+    "@storecraft/core": "^1.0.0",
+    "@types/node": "^20.11.0",
+    "dotenv": "^16.3.1",
+    "uvu": "^0.5.6"
+  }
+}

package/tests/storage.test.js ADDED Viewed

@@ -0,0 +1,11 @@
+import 'dotenv/config';
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+test('todo', async () => {
+  assert.ok(true, 'todo')
+});
+test.run();

package/tsconfig.json ADDED Viewed

@@ -0,0 +1,14 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true,
+    "checkJs": true,
+    "target": "ESNext",
+    "resolveJsonModule": true,
+    "moduleResolution": "NodeNext",
+    "module": "NodeNext",
+    "composite": true,
+  },
+  "include": ["*", "*/*", "src/*"]
+}

package/types.public.d.ts ADDED Viewed

@@ -0,0 +1,37 @@
+export * from './index.js';
+import type { Stripe } from 'stripe'
+/**
+ * @description gateway config
+ */
+export type Config = {
+  /**
+   * @description `stripe` publishable key
+   */
+  publishable_key: string;
+  /**
+   * @description `stripe` private secret
+   */
+  secret_key: string;
+  /**
+   * @description (Optional) `webhook` Endpoint private secret in case
+   * you are configuring webhook for async payments
+   * [https://docs.stripe.com/webhooks?verify=check-signatures-library](https://docs.stripe.com/webhooks?verify=check-signatures-library)
+   */
+  webhook_endpoint_secret?: string;
+  /**
+   * @description config options for `stripe`
+   */
+  stripe_config?: Stripe.StripeConfig;
+  /**
+   * @description configure `intent` creation
+   */
+  stripe_intent_create_params?: Omit<Stripe.PaymentIntentCreateParams, 'amount'>;
+}