@payloadcms/storage-r2 0.0.1-beta.0 → 3.58.0-internal.8775d75

package/src/fields/variantsFields.ts

@@ -1,56 +0,0 @@
-import type { Field } from 'payload'
-
-type Props = {
-  /**
-   * Slug of the variants collection, defaults to 'variants'.
-   */
-  variantsSlug?: string
-  /**
-   * Slug of the variant types collection, defaults to 'variantTypes'.
-   */
-  variantTypesSlug?: string
-}
-
-export const variantsFields: (props: Props) => Field[] = ({
-  variantsSlug = 'variants',
-  variantTypesSlug = 'variantTypes',
-}) => {
-  const fields: Field[] = [
-    {
-      name: 'enableVariants',
-      type: 'checkbox',
-      label: ({ t }) =>
-        // @ts-expect-error - translations are not typed in plugins yet
-        t('plugin-ecommerce:enableVariants'),
-    },
-    {
-      name: 'variantTypes',
-      type: 'relationship',
-      admin: {
-        condition: ({ enableVariants }) => Boolean(enableVariants),
-      },
-      hasMany: true,
-      label: ({ t }) =>
-        // @ts-expect-error - translations are not typed in plugins yet
-        t('plugin-ecommerce:variantTypes'),
-      relationTo: variantTypesSlug,
-    },
-    {
-      name: 'variants',
-      type: 'join',
-      admin: {
-        condition: ({ enableVariants }) => Boolean(enableVariants),
-        defaultColumns: ['title', 'options', 'inventory', 'prices'],
-        disableListColumn: true,
-      },
-      collection: variantsSlug,
-      label: ({ t }) =>
-        // @ts-expect-error - translations are not typed in plugins yet
-        t('plugin-ecommerce:availableVariants'),
-      maxDepth: 2,
-      on: 'product',
-    },
-  ]
-
-  return fields
-}

package/src/index.ts

@@ -1,275 +0,0 @@
-import type { Config, Endpoint } from 'payload'
-
-import { deepMergeSimple } from 'payload/shared'
-
-import type { EcommercePluginConfig, SanitizedEcommercePluginConfig } from './types.js'
-
-import { addressesCollection } from './addresses/addressesCollection.js'
-import { cartsCollection } from './carts/cartsCollection.js'
-import { confirmOrderHandler } from './endpoints/confirmOrder.js'
-import { initiatePaymentHandler } from './endpoints/initiatePayment.js'
-import { ordersCollection } from './orders/ordersCollection.js'
-import { productsCollection } from './products/productsCollection.js'
-import { transactionsCollection } from './transactions/transactionsCollection.js'
-import { translations } from './translations/index.js'
-import { getCollectionSlugMap } from './utilities/getCollectionSlugMap.js'
-import { sanitizePluginConfig } from './utilities/sanitizePluginConfig.js'
-import { variantOptionsCollection } from './variants/variantOptionsCollection.js'
-import { variantsCollection } from './variants/variantsCollection/index.js'
-import { variantTypesCollection } from './variants/variantTypesCollection.js'
-
-export const ecommercePlugin =
-  (pluginConfig?: EcommercePluginConfig) =>
-  (incomingConfig: Config): Config => {
-    if (!pluginConfig) {
-      return incomingConfig
-    }
-
-    const sanitizedPluginConfig = sanitizePluginConfig({ pluginConfig })
-    /**
-     * Used to keep track of the slugs of collections in case they are overridden by the user.
-     */
-    const collectionSlugMap = getCollectionSlugMap({ sanitizedPluginConfig })
-
-    // Ensure collections exists
-    if (!incomingConfig.collections) {
-      incomingConfig.collections = []
-    }
-
-    // Controls whether variants are enabled in the plugin. This is toggled to true under products config
-    let enableVariants = false
-
-    const currenciesConfig: Required<SanitizedEcommercePluginConfig['currencies']> =
-      sanitizedPluginConfig.currencies
-
-    let addressFields
-
-    if (sanitizedPluginConfig.addresses) {
-      const collectionOverrides =
-        typeof sanitizedPluginConfig.addresses === 'object'
-          ? sanitizedPluginConfig.addresses.collectionOverride
-          : undefined
-
-      addressFields = sanitizedPluginConfig.addresses.addressFields
-
-      const supportedCountries = sanitizedPluginConfig.addresses.supportedCountries
-
-      const addresses = addressesCollection({
-        addressFields,
-        customersSlug: collectionSlugMap.customers,
-        overrides: collectionOverrides,
-        supportedCountries,
-      })
-
-      incomingConfig.collections.push(addresses)
-    }
-
-    if (sanitizedPluginConfig.products) {
-      const productsConfig =
-        typeof sanitizedPluginConfig.products === 'boolean'
-          ? {
-              variants: true,
-            }
-          : sanitizedPluginConfig.products
-
-      enableVariants = Boolean(productsConfig.variants)
-
-      if (productsConfig.variants) {
-        const overrides =
-          typeof productsConfig.variants === 'boolean' ? undefined : productsConfig.variants
-
-        const variants = variantsCollection({
-          currenciesConfig,
-          inventory: sanitizedPluginConfig.inventory,
-          overrides: overrides?.variantsCollection,
-          productsSlug: collectionSlugMap.products,
-          variantOptionsSlug: collectionSlugMap.variantOptions,
-        })
-
-        const variantTypes = variantTypesCollection({
-          overrides: overrides?.variantTypesCollection,
-          variantOptionsSlug: collectionSlugMap.variantOptions,
-        })
-
-        const variantOptions = variantOptionsCollection({
-          overrides: overrides?.variantOptionsCollection,
-          variantTypesSlug: collectionSlugMap.variantTypes,
-        })
-
-        incomingConfig.collections.push(variants, variantTypes, variantOptions)
-      }
-
-      const products = productsCollection({
-        currenciesConfig,
-        enableVariants,
-        inventory: sanitizedPluginConfig.inventory,
-        variantsSlug: collectionSlugMap.variants,
-        variantTypesSlug: collectionSlugMap.variantTypes,
-        ...('productsCollection' in productsConfig && productsConfig.productsCollection
-          ? { overrides: productsConfig.productsCollection }
-          : {}),
-      })
-
-      incomingConfig.collections.push(products)
-
-      if (sanitizedPluginConfig.carts) {
-        const carts = cartsCollection({
-          currenciesConfig,
-          customersSlug: collectionSlugMap.customers,
-          enableVariants: Boolean(productsConfig.variants),
-          overrides:
-            sanitizedPluginConfig.carts === true
-              ? undefined
-              : sanitizedPluginConfig.carts.cartsCollection,
-          productsSlug: collectionSlugMap.products,
-          variantsSlug: collectionSlugMap.variants,
-        })
-
-        incomingConfig.collections.push(carts)
-      }
-    }
-
-    if (sanitizedPluginConfig.orders) {
-      const orders = ordersCollection({
-        addressFields,
-        currenciesConfig,
-        customersSlug: collectionSlugMap.customers,
-        enableVariants,
-        overrides:
-          sanitizedPluginConfig.orders === true
-            ? undefined
-            : sanitizedPluginConfig.orders.ordersCollection,
-        productsSlug: collectionSlugMap.products,
-        variantsSlug: collectionSlugMap.variants,
-      })
-      incomingConfig.collections.push(orders)
-    }
-
-    const paymentMethods = sanitizedPluginConfig.payments.paymentMethods
-
-    if (sanitizedPluginConfig.payments) {
-      if (paymentMethods.length) {
-        if (!Array.isArray(incomingConfig.endpoints)) {
-          incomingConfig.endpoints = []
-        }
-
-        const productsValidation =
-          (typeof sanitizedPluginConfig.products === 'object' &&
-            sanitizedPluginConfig.products.validation) ||
-          undefined
-
-        paymentMethods.forEach((paymentMethod) => {
-          const methodPath = `/payments/${paymentMethod.name}`
-          const endpoints: Endpoint[] = []
-
-          const initiatePayment: Endpoint = {
-            handler: initiatePaymentHandler({
-              currenciesConfig,
-              inventory: sanitizedPluginConfig.inventory,
-              paymentMethod,
-              productsSlug: collectionSlugMap.products,
-              productsValidation,
-              transactionsSlug: collectionSlugMap.transactions,
-              variantsSlug: collectionSlugMap.variants,
-            }),
-            method: 'post',
-            path: `${methodPath}/initiate`,
-          }
-
-          const confirmOrder: Endpoint = {
-            handler: confirmOrderHandler({
-              cartsSlug: collectionSlugMap.carts,
-              currenciesConfig,
-              ordersSlug: collectionSlugMap.orders,
-              paymentMethod,
-              productsValidation,
-              transactionsSlug: collectionSlugMap.transactions,
-            }),
-            method: 'post',
-            path: `${methodPath}/confirm-order`,
-          }
-
-          endpoints.push(initiatePayment, confirmOrder)
-
-          // Attach any additional endpoints defined in the payment method
-          if (paymentMethod.endpoints && paymentMethod.endpoints.length > 0) {
-            const methodEndpoints = paymentMethod.endpoints.map((endpoint) => {
-              const path = endpoint.path.startsWith('/') ? endpoint.path : `/${endpoint.path}`
-
-              return {
-                ...endpoint,
-                path: `${methodPath}${path}`,
-              }
-            })
-
-            endpoints.push(...methodEndpoints)
-          }
-
-          incomingConfig.endpoints!.push(...endpoints)
-        })
-      }
-    }
-
-    if (sanitizedPluginConfig.transactions) {
-      const transactions = transactionsCollection({
-        addressFields,
-        cartsSlug: collectionSlugMap.carts,
-        currenciesConfig,
-        customersSlug: collectionSlugMap.customers,
-        enableVariants,
-        ordersSlug: collectionSlugMap.orders,
-        paymentMethods,
-        productsSlug: collectionSlugMap.products,
-        variantsSlug: collectionSlugMap.variants,
-      })
-
-      incomingConfig.collections.push(transactions)
-    }
-
-    if (!incomingConfig.i18n) {
-      incomingConfig.i18n = {}
-    }
-
-    if (!incomingConfig.i18n?.translations) {
-      incomingConfig.i18n.translations = {}
-    }
-
-    incomingConfig.i18n.translations = deepMergeSimple(
-      translations,
-      incomingConfig.i18n?.translations,
-    )
-
-    // incomingConfig.typescript = {
-    //   ...incomingConfig.typescript,
-    //   schema: [
-    //     ({ jsonSchema }) => {
-    //       if (jsonSchema.definitions) {
-    //         const supportedCurrencies = pluginConfig.currencies?.supportedCurrencies || []
-    //         const defaultCurrency = pluginConfig.currencies?.defaultCurrency || 'USD'
-
-    //         // Generate JSON Schema4 for supported currencies
-
-    //         const currenciesSchema = {
-    //           type: 'array',
-    //           description: 'A list of supported currency codes.',
-    //           items: {
-    //             type: 'string',
-    //             enum: (supportedCurrencies || []).map((currency) => currency.code),
-    //           },
-    //           title: 'Supported Currencies',
-    //         }
-
-    //         console.log({ defs: jsonSchema.definitions })
-
-    //         jsonSchema.definitions.SupportedCurrencies = currenciesSchema
-    //       }
-
-    //       return jsonSchema
-    //     },
-    //   ],
-    // }
-
-    return {
-      ...incomingConfig,
-    }
-  }

package/src/orders/ordersCollection.ts

@@ -1,157 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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',
-  }
-}