@payloadcms/storage-r2 0.0.1-beta.0

package/src/orders/ordersCollection.ts

@@ -0,0 +1,157 @@
+import type { CollectionConfig, Field } from 'payload'
+
+import type { CurrenciesConfig, FieldsOverride } from '../types.js'
+
+import { amountField } from '../fields/amountField.js'
+import { cartItemsField } from '../fields/cartItemsField.js'
+import { currencyField } from '../fields/currencyField.js'
+
+type Props = {
+  /**
+   * Array of fields used for capturing the shipping address data.
+   */
+  addressFields?: Field[]
+  currenciesConfig?: CurrenciesConfig
+  /**
+   * Slug of the customers collection, defaults to 'users'.
+   */
+  customersSlug?: string
+  enableVariants?: boolean
+  overrides?: { fields?: FieldsOverride } & Partial<Omit<CollectionConfig, 'fields'>>
+  /**
+   * Slug of the products collection, defaults to 'products'.
+   */
+  productsSlug?: string
+  /**
+   * Slug of the transactions collection, defaults to 'transactions'.
+   */
+  transactionsSlug?: string
+  /**
+   * Slug of the variants collection, defaults to 'variants'.
+   */
+  variantsSlug?: string
+}
+
+export const ordersCollection: (props?: Props) => CollectionConfig = (props) => {
+  const {
+    addressFields,
+    currenciesConfig,
+    customersSlug = 'users',
+    enableVariants = false,
+    overrides,
+    productsSlug = 'products',
+    transactionsSlug = 'transactions',
+    variantsSlug = 'variants',
+  } = props || {}
+  const fieldsOverride = overrides?.fields
+
+  const defaultFields: Field[] = [
+    {
+      name: 'customer',
+      type: 'relationship',
+      label: ({ t }) =>
+        // @ts-expect-error - translations are not typed in plugins yet
+        t('plugin-ecommerce:customer'),
+      relationTo: customersSlug,
+    },
+    {
+      name: 'customerEmail',
+      type: 'email',
+      label: ({ t }) =>
+        // @ts-expect-error - translations are not typed in plugins yet
+        t('plugin-ecommerce:customerEmail'),
+    },
+    {
+      name: 'transactions',
+      type: 'relationship',
+      hasMany: true,
+      label: ({ t }) =>
+        // @ts-expect-error - translations are not typed in plugins yet
+        t('plugin-ecommerce:transactions'),
+      relationTo: transactionsSlug,
+    },
+    {
+      name: 'status',
+      type: 'select',
+      defaultValue: 'processing',
+      interfaceName: 'OrderStatus',
+      label: ({ t }) =>
+        // @ts-expect-error - translations are not typed in plugins yet
+        t('plugin-ecommerce:status'),
+      options: [
+        {
+          // @ts-expect-error - translations are not typed in plugins yet
+          label: ({ t }) => t('plugin-ecommerce:processing'),
+          value: 'processing',
+        },
+        {
+          // @ts-expect-error - translations are not typed in plugins yet
+          label: ({ t }) => t('plugin-ecommerce:completed'),
+          value: 'completed',
+        },
+        {
+          // @ts-expect-error - translations are not typed in plugins yet
+          label: ({ t }) => t('plugin-ecommerce:cancelled'),
+          value: 'cancelled',
+        },
+        {
+          // @ts-expect-error - translations are not typed in plugins yet
+          label: ({ t }) => t('plugin-ecommerce:refunded'),
+          value: 'refunded',
+        },
+      ],
+    },
+    ...(addressFields
+      ? [
+          {
+            name: 'shippingAddress',
+            type: 'group',
+            fields: addressFields,
+            label: ({ t }) =>
+              // @ts-expect-error - translations are not typed in plugins yet
+              t('plugin-ecommerce:shippingAddress'),
+          } as Field,
+        ]
+      : []),
+    ...(currenciesConfig
+      ? [amountField({ currenciesConfig }), currencyField({ currenciesConfig })]
+      : []),
+    cartItemsField({
+      enableVariants,
+      overrides: {
+        name: 'items',
+        label: ({ t }) =>
+          // @ts-expect-error - translations are not typed in plugins yet
+          t('plugin-ecommerce:items'),
+        labels: {
+          plural: ({ t }) =>
+            // @ts-expect-error - translations are not typed in plugins yet
+            t('plugin-ecommerce:items'),
+          singular: ({ t }) =>
+            // @ts-expect-error - translations are not typed in plugins yet
+            t('plugin-ecommerce:item'),
+        },
+      },
+      productsSlug,
+      variantsSlug,
+    }),
+  ]
+
+  const fields =
+    fieldsOverride && typeof fieldsOverride === 'function'
+      ? fieldsOverride({ defaultFields })
+      : defaultFields
+
+  const baseConfig: CollectionConfig = {
+    slug: 'orders',
+    timestamps: true,
+    ...overrides,
+    admin: {
+      useAsTitle: 'createdAt',
+      ...overrides?.admin,
+    },
+    fields,
+  }
+
+  return { ...baseConfig }
+}

package/src/payments/adapters/stripe/confirmOrder.ts

@@ -0,0 +1,123 @@
+import Stripe from 'stripe'
+
+import type { PaymentAdapter } from '../../../types.js'
+import type { StripeAdapterArgs } from './index.js'
+
+type Props = {
+  apiVersion?: Stripe.StripeConfig['apiVersion']
+  appInfo?: Stripe.StripeConfig['appInfo']
+  secretKey: StripeAdapterArgs['secretKey']
+}
+
+export const confirmOrder: (props: Props) => NonNullable<PaymentAdapter>['confirmOrder'] =
+  (props) =>
+  async ({ data, ordersSlug = 'orders', req, transactionsSlug = 'transactions' }) => {
+    const payload = req.payload
+    const { apiVersion, appInfo, secretKey } = props || {}
+
+    const customerEmail = data.customerEmail
+    const user = req.user
+
+    const paymentIntentID = data.paymentIntentID as string
+
+    if (!secretKey) {
+      throw new Error('Stripe secret key is required')
+    }
+
+    if (!paymentIntentID) {
+      throw new Error('PaymentIntent ID is required')
+    }
+
+    const stripe = new Stripe(secretKey, {
+      // API version can only be the latest, stripe recommends ts ignoring it
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore - ignoring since possible versions are not type safe, only the latest version is recognised
+      apiVersion: apiVersion || '2025-03-31.basil',
+      appInfo: appInfo || {
+        name: 'Stripe Payload Plugin',
+        url: 'https://payloadcms.com',
+      },
+    })
+
+    try {
+      let customer = (
+        await stripe.customers.list({
+          email: customerEmail,
+        })
+      ).data[0]
+
+      if (!customer?.id) {
+        customer = await stripe.customers.create({
+          email: customerEmail,
+        })
+      }
+
+      // Find our existing transaction by the payment intent ID
+      const transactionsResults = await payload.find({
+        collection: transactionsSlug,
+        where: {
+          'stripe.paymentIntentID': {
+            equals: paymentIntentID,
+          },
+        },
+      })
+
+      const transaction = transactionsResults.docs[0]
+
+      if (!transactionsResults.totalDocs || !transaction) {
+        throw new Error('No transaction found for the provided PaymentIntent ID')
+      }
+
+      // Verify the payment intent exists and retrieve it
+      const paymentIntent = await stripe.paymentIntents.retrieve(paymentIntentID)
+
+      const cartID = paymentIntent.metadata.cartID
+      const cartItemsSnapshot = paymentIntent.metadata.cartItemsSnapshot
+        ? JSON.parse(paymentIntent.metadata.cartItemsSnapshot)
+        : undefined
+
+      const shippingAddress = paymentIntent.metadata.shippingAddress
+        ? JSON.parse(paymentIntent.metadata.shippingAddress)
+        : undefined
+
+      if (!cartID) {
+        throw new Error('Cart ID not found in the PaymentIntent metadata')
+      }
+
+      if (!cartItemsSnapshot || !Array.isArray(cartItemsSnapshot)) {
+        throw new Error('Cart items snapshot not found or invalid in the PaymentIntent metadata')
+      }
+
+      const order = await payload.create({
+        collection: ordersSlug,
+        data: {
+          amount: paymentIntent.amount,
+          currency: paymentIntent.currency.toUpperCase(),
+          ...(req.user ? { customer: req.user.id } : { customerEmail }),
+          items: cartItemsSnapshot,
+          shippingAddress,
+          status: 'processing',
+          transactions: [transaction.id],
+        },
+      })
+
+      await payload.update({
+        id: transaction.id,
+        collection: transactionsSlug,
+        data: {
+          order: order.id,
+          status: 'succeeded',
+        },
+      })
+
+      return {
+        message: 'Payment initiated successfully',
+        order,
+        orderID: order.id,
+      }
+    } catch (error) {
+      payload.logger.error(error, 'Error initiating payment with Stripe')
+
+      throw new Error(error instanceof Error ? error.message : 'Unknown error initiating payment')
+    }
+  }

package/src/payments/adapters/stripe/endpoints/webhooks.ts

@@ -0,0 +1,69 @@
+import type { Endpoint } from 'payload'
+
+import Stripe from 'stripe'
+
+import type { StripeAdapterArgs } from '../index.js'
+
+type Props = {
+  apiVersion?: Stripe.StripeConfig['apiVersion']
+  appInfo?: Stripe.StripeConfig['appInfo']
+  secretKey: StripeAdapterArgs['secretKey']
+  webhooks?: StripeAdapterArgs['webhooks']
+  webhookSecret: StripeAdapterArgs['webhookSecret']
+}
+
+export const webhooksEndpoint: (props: Props) => Endpoint = (props) => {
+  const { apiVersion, appInfo, secretKey, webhooks, webhookSecret } = props || {}
+
+  const handler: Endpoint['handler'] = async (req) => {
+    let returnStatus = 200
+
+    if (webhookSecret && secretKey && req.text) {
+      const stripe = new Stripe(secretKey, {
+        // API version can only be the latest, stripe recommends ts ignoring it
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - ignoring since possible versions are not type safe, only the latest version is recognised
+        apiVersion: apiVersion || '2025-03-31.basil',
+        appInfo: appInfo || {
+          name: 'Stripe Payload Plugin',
+          url: 'https://payloadcms.com',
+        },
+      })
+
+      const body = await req.text()
+      const stripeSignature = req.headers.get('stripe-signature')
+
+      if (stripeSignature) {
+        let event: Stripe.Event | undefined
+
+        try {
+          event = stripe.webhooks.constructEvent(body, stripeSignature, webhookSecret)
+        } catch (err: unknown) {
+          const msg: string = err instanceof Error ? err.message : JSON.stringify(err)
+          req.payload.logger.error(`Error constructing Stripe event: ${msg}`)
+          returnStatus = 400
+        }
+
+        if (typeof webhooks === 'object' && event) {
+          const webhookEventHandler = webhooks[event.type]
+
+          if (typeof webhookEventHandler === 'function') {
+            await webhookEventHandler({
+              event,
+              req,
+              stripe,
+            })
+          }
+        }
+      }
+    }
+
+    return Response.json({ received: true }, { status: returnStatus })
+  }
+
+  return {
+    handler,
+    method: 'post',
+    path: '/webhooks',
+  }
+}

package/src/payments/adapters/stripe/index.ts

@@ -0,0 +1,135 @@
+import type { Field, GroupField, PayloadRequest } from 'payload'
+import type { Stripe } from 'stripe'
+
+import type {
+  BasePaymentAdapterArgs,
+  BasePaymentAdapterClientArgs,
+  PaymentAdapter,
+  PaymentAdapterClient,
+} from '../../../types.js'
+
+import { confirmOrder } from './confirmOrder.js'
+import { webhooksEndpoint } from './endpoints/webhooks.js'
+import { initiatePayment } from './initiatePayment.js'
+
+type StripeWebhookHandler = (args: {
+  event: Stripe.Event
+  req: PayloadRequest
+  stripe: Stripe
+}) => Promise<void> | void
+
+type StripeWebhookHandlers = {
+  /**
+   * Description of the event (e.g., invoice.created or charge.refunded).
+   */
+  [webhookName: string]: StripeWebhookHandler
+}
+
+export type StripeAdapterArgs = {
+  /**
+   * This library's types only reflect the latest API version.
+   *
+   * We recommend upgrading your account's API Version to the latest version
+   * if you wish to use TypeScript with this library.
+   *
+   * If you wish to remain on your account's default API version,
+   * you may pass `null` or another version instead of the latest version,
+   * and add a `@ts-ignore` comment here and anywhere the types differ between API versions.
+   *
+   * @docs https://stripe.com/docs/api/versioning
+   */
+  apiVersion?: Stripe.StripeConfig['apiVersion']
+  appInfo?: Stripe.StripeConfig['appInfo']
+  publishableKey: string
+  secretKey: string
+  webhooks?: StripeWebhookHandlers
+  webhookSecret: string
+} & BasePaymentAdapterArgs
+
+export const stripeAdapter: (props: StripeAdapterArgs) => PaymentAdapter = (props) => {
+  const { apiVersion, appInfo, groupOverrides, secretKey, webhooks, webhookSecret } = props
+  const label = props?.label || 'Stripe'
+
+  const baseFields: Field[] = [
+    {
+      name: 'customerID',
+      type: 'text',
+      label: 'Stripe Customer ID',
+    },
+    {
+      name: 'paymentIntentID',
+      type: 'text',
+      label: 'Stripe PaymentIntent ID',
+    },
+  ]
+
+  const groupField: GroupField = {
+    name: 'stripe',
+    type: 'group',
+    ...groupOverrides,
+    admin: {
+      condition: (data) => {
+        const path = 'paymentMethod'
+
+        return data?.[path] === 'stripe'
+      },
+      ...groupOverrides?.admin,
+    },
+    fields:
+      groupOverrides?.fields && typeof groupOverrides?.fields === 'function'
+        ? groupOverrides.fields({ defaultFields: baseFields })
+        : baseFields,
+  }
+
+  return {
+    name: 'stripe',
+    confirmOrder: confirmOrder({
+      apiVersion,
+      appInfo,
+      secretKey,
+    }),
+    endpoints: [webhooksEndpoint({ apiVersion, appInfo, secretKey, webhooks, webhookSecret })],
+    group: groupField,
+    initiatePayment: initiatePayment({
+      apiVersion,
+      appInfo,
+      secretKey,
+    }),
+    label,
+  }
+}
+
+export type StripeAdapterClientArgs = {
+  /**
+   * This library's types only reflect the latest API version.
+   *
+   * We recommend upgrading your account's API Version to the latest version
+   * if you wish to use TypeScript with this library.
+   *
+   * If you wish to remain on your account's default API version,
+   * you may pass `null` or another version instead of the latest version,
+   * and add a `@ts-ignore` comment here and anywhere the types differ between API versions.
+   *
+   * @docs https://stripe.com/docs/api/versioning
+   */
+  apiVersion?: Stripe.StripeConfig['apiVersion']
+  appInfo?: Stripe.StripeConfig['appInfo']
+  publishableKey: string
+} & BasePaymentAdapterClientArgs
+
+export const stripeAdapterClient: (props: StripeAdapterClientArgs) => PaymentAdapterClient = (
+  props,
+) => {
+  return {
+    name: 'stripe',
+    confirmOrder: true,
+    initiatePayment: true,
+    label: 'Card',
+  }
+}
+
+export type InitiatePaymentReturnType = {
+  clientSecret: string
+  message: string
+  paymentIntentID: string
+}

package/src/payments/adapters/stripe/initiatePayment.ts

@@ -0,0 +1,131 @@
+import Stripe from 'stripe'
+
+import type { PaymentAdapter } from '../../../types.js'
+import type { InitiatePaymentReturnType, StripeAdapterArgs } from './index.js'
+
+type Props = {
+  apiVersion?: Stripe.StripeConfig['apiVersion']
+  appInfo?: Stripe.StripeConfig['appInfo']
+  secretKey: StripeAdapterArgs['secretKey']
+}
+
+export const initiatePayment: (props: Props) => NonNullable<PaymentAdapter>['initiatePayment'] =
+  (props) =>
+  async ({ data, req, transactionsSlug }) => {
+    const payload = req.payload
+    const { apiVersion, appInfo, secretKey } = props || {}
+
+    const customerEmail = data.customerEmail
+    const currency = data.currency
+    const cart = data.cart
+    const amount = cart.subtotal
+    const billingAddressFromData = data.billingAddress
+    const shippingAddressFromData = data.shippingAddress
+
+    if (!secretKey) {
+      throw new Error('Stripe secret key is required.')
+    }
+
+    if (!currency) {
+      throw new Error('Currency is required.')
+    }
+
+    if (!cart || !cart.items || cart.items.length === 0) {
+      throw new Error('Cart is empty or not provided.')
+    }
+
+    if (!customerEmail || typeof customerEmail !== 'string') {
+      throw new Error('A valid customer email is required to make a purchase.')
+    }
+
+    if (!amount || typeof amount !== 'number' || amount <= 0) {
+      throw new Error('A valid amount is required to initiate a payment.')
+    }
+
+    const stripe = new Stripe(secretKey, {
+      // API version can only be the latest, stripe recommends ts ignoring it
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore - ignoring since possible versions are not type safe, only the latest version is recognised
+      apiVersion: apiVersion || '2025-06-30.preview',
+      appInfo: appInfo || {
+        name: 'Stripe Payload Plugin',
+        url: 'https://payloadcms.com',
+      },
+    })
+
+    try {
+      let customer = (
+        await stripe.customers.list({
+          email: customerEmail,
+        })
+      ).data[0]
+
+      if (!customer?.id) {
+        customer = await stripe.customers.create({
+          email: customerEmail,
+        })
+      }
+
+      const flattenedCart = cart.items.map((item) => {
+        const productID = typeof item.product === 'object' ? item.product.id : item.product
+        const variantID = item.variant
+          ? typeof item.variant === 'object'
+            ? item.variant.id
+            : item.variant
+          : undefined
+
+        return {
+          product: productID,
+          quantity: item.quantity,
+          variant: variantID,
+        }
+      })
+
+      const shippingAddressAsString = JSON.stringify(shippingAddressFromData)
+
+      const paymentIntent = await stripe.paymentIntents.create({
+        amount,
+        automatic_payment_methods: {
+          enabled: true,
+        },
+        currency,
+        customer: customer.id,
+        metadata: {
+          cartID: cart.id,
+          cartItemsSnapshot: JSON.stringify(flattenedCart),
+          shippingAddress: shippingAddressAsString,
+        },
+      })
+
+      // Create a transaction for the payment intent in the database
+      const transaction = await payload.create({
+        collection: transactionsSlug,
+        data: {
+          ...(req.user ? { customer: req.user.id } : { customerEmail }),
+          amount: paymentIntent.amount,
+          billingAddress: billingAddressFromData,
+          cart: cart.id,
+          currency: paymentIntent.currency.toUpperCase(),
+          items: flattenedCart,
+          paymentMethod: 'stripe',
+          status: 'pending',
+          stripe: {
+            customerID: customer.id,
+            paymentIntentID: paymentIntent.id,
+          },
+        },
+      })
+
+      const returnData: InitiatePaymentReturnType = {
+        clientSecret: paymentIntent.client_secret || '',
+        message: 'Payment initiated successfully',
+        paymentIntentID: paymentIntent.id,
+      }
+
+      return returnData
+    } catch (error) {
+      payload.logger.error(error, 'Error initiating payment with Stripe')
+
+      throw new Error(error instanceof Error ? error.message : 'Unknown error initiating payment')
+    }
+  }

package/src/products/productsCollection.ts

@@ -0,0 +1,78 @@
+import type { CollectionConfig, Field } from 'payload'
+
+import type { CurrenciesConfig, FieldsOverride, InventoryConfig } from '../types.js'
+
+import { inventoryField } from '../fields/inventoryField.js'
+import { pricesField } from '../fields/pricesField.js'
+import { variantsFields } from '../fields/variantsFields.js'
+
+type Props = {
+  currenciesConfig: CurrenciesConfig
+  enableVariants?: boolean
+  /**
+   * Adds in an inventory field to the product and its variants. This is useful for tracking inventory levels.
+   * Defaults to true.
+   */
+  inventory?: boolean | InventoryConfig
+  overrides?: { fields?: FieldsOverride } & Partial<Omit<CollectionConfig, 'fields'>>
+  /**
+   * Slug of the variants collection, defaults to 'variants'.
+   */
+  variantsSlug?: string
+  /**
+   * Slug of the variant types collection, defaults to 'variantTypes'.
+   */
+  variantTypesSlug?: string
+}
+
+export const productsCollection: (props: Props) => CollectionConfig = (props) => {
+  const {
+    currenciesConfig,
+    enableVariants = false,
+    inventory = true,
+    overrides,
+    variantsSlug = 'variants',
+    variantTypesSlug = 'variantTypes',
+  } = props || {}
+  const fieldsOverride = overrides?.fields
+
+  const defaultFields: Field[] = [
+    ...(inventory
+      ? [
+          inventoryField({
+            overrides: {
+              admin: {
+                condition: ({ enableVariants }) => !enableVariants,
+              },
+            },
+          }),
+        ]
+      : []),
+  ]
+
+  const baseFields = [
+    ...defaultFields,
+    ...(enableVariants ? variantsFields({ variantsSlug, variantTypesSlug }) : []),
+    ...(currenciesConfig ? [...pricesField({ currenciesConfig })] : []),
+  ]
+
+  const fields =
+    fieldsOverride && typeof fieldsOverride === 'function'
+      ? fieldsOverride({ defaultFields: baseFields })
+      : baseFields
+
+  const baseConfig: CollectionConfig = {
+    slug: 'products',
+    ...overrides,
+    admin: {
+      defaultColumns: [
+        ...(currenciesConfig ? ['prices'] : []),
+        ...(enableVariants ? ['variants'] : []),
+      ],
+      ...overrides?.admin,
+    },
+    fields,
+  }
+
+  return { ...baseConfig }
+}