@payloadcms/storage-r2 0.0.1-beta.0

package/src/fields/amountField.ts

@@ -0,0 +1,43 @@
+import type { NumberField } from 'payload'
+
+import type { CurrenciesConfig, Currency } from '../types.js'
+
+type Props = {
+  currenciesConfig: CurrenciesConfig
+  /**
+   * Use this specific currency for the field.
+   */
+  currency?: Currency
+  overrides?: Partial<NumberField>
+}
+
+export const amountField: (props: Props) => NumberField = ({
+  currenciesConfig,
+  currency,
+  overrides,
+}) => {
+  // @ts-expect-error - issue with payload types
+  const field: NumberField = {
+    name: 'amount',
+    type: 'number',
+    label: ({ t }) =>
+      // @ts-expect-error - translations are not typed in plugins yet
+      t('plugin-ecommerce:amount'),
+    ...overrides,
+    admin: {
+      components: {
+        Field: {
+          clientProps: {
+            currenciesConfig,
+            currency,
+          },
+          path: '@payloadcms/plugin-ecommerce/ui#PriceInput',
+        },
+        ...overrides?.admin?.components,
+      },
+      ...overrides?.admin,
+    },
+  }
+
+  return field
+}

package/src/fields/cartItemsField.ts

@@ -0,0 +1,84 @@
+import type { ArrayField, Field } from 'payload'
+
+import type { CurrenciesConfig } from '../types.js'
+
+import { amountField } from './amountField.js'
+import { currencyField } from './currencyField.js'
+
+type Props = {
+  /**
+   * Include this in order to enable support for currencies per item in the cart.
+   */
+  currenciesConfig?: CurrenciesConfig
+  enableVariants?: boolean
+  /**
+   * Enables individual prices for each item in the cart.
+   * Defaults to false.
+   */
+  individualPrices?: boolean
+  overrides?: Partial<ArrayField>
+  /**
+   * Slug of the products collection, defaults to 'products'.
+   */
+  productsSlug?: string
+  /**
+   * Slug of the variants collection, defaults to 'variants'.
+   */
+  variantsSlug?: string
+}
+
+export const cartItemsField: (props?: Props) => ArrayField = (props) => {
+  const {
+    currenciesConfig,
+    enableVariants = false,
+    individualPrices,
+    overrides,
+    productsSlug = 'products',
+    variantsSlug = 'variants',
+  } = props || {}
+
+  const field: ArrayField = {
+    name: 'items',
+    type: 'array',
+    fields: [
+      {
+        name: 'product',
+        type: 'relationship',
+        label: ({ t }) =>
+          // @ts-expect-error - translations are not typed in plugins yet
+          t('plugin-ecommerce:product'),
+        relationTo: productsSlug,
+      },
+      ...(enableVariants
+        ? [
+            {
+              name: 'variant',
+              type: 'relationship',
+              label: ({ t }) =>
+                // @ts-expect-error - translations are not typed in plugins yet
+                t('plugin-ecommerce:variant'),
+              relationTo: variantsSlug,
+            } as Field,
+          ]
+        : []),
+      {
+        name: 'quantity',
+        type: 'number',
+        defaultValue: 1,
+        label: ({ t }) =>
+          // @ts-expect-error - translations are not typed in plugins yet
+          t('plugin-ecommerce:quantity'),
+        min: 1,
+        required: true,
+      },
+      ...(currenciesConfig && individualPrices ? [amountField({ currenciesConfig })] : []),
+      ...(currenciesConfig ? [currencyField({ currenciesConfig })] : []),
+    ],
+    label: ({ t }) =>
+      // @ts-expect-error - translations are not typed in plugins yet
+      t('plugin-ecommerce:cart'),
+    ...overrides,
+  }
+
+  return field
+}

package/src/fields/currencyField.ts

@@ -0,0 +1,39 @@
+import type { SelectField } from 'payload'
+
+import type { CurrenciesConfig } from '../types.js'
+
+type Props = {
+  currenciesConfig: CurrenciesConfig
+  overrides?: Partial<SelectField>
+}
+
+export const currencyField: (props: Props) => SelectField = ({ currenciesConfig, overrides }) => {
+  const options = currenciesConfig.supportedCurrencies.map((currency) => {
+    const label = currency.label ? `${currency.label} (${currency.code})` : currency.code
+
+    return {
+      label,
+      value: currency.code,
+    }
+  })
+
+  const defaultValue =
+    (currenciesConfig.defaultCurrency ?? currenciesConfig.supportedCurrencies.length === 1)
+      ? currenciesConfig.supportedCurrencies[0]?.code
+      : undefined
+
+  // @ts-expect-error - issue with payload types
+  const field: SelectField = {
+    name: 'currency',
+    type: 'select',
+    label: ({ t }) =>
+      // @ts-expect-error - translations are not typed in plugins yet
+      t('plugin-ecommerce:currency'),
+    ...(defaultValue && { defaultValue }),
+    options,
+    ...overrides,
+    admin: { readOnly: currenciesConfig.supportedCurrencies.length === 1, ...overrides?.admin },
+  }
+
+  return field
+}

package/src/fields/inventoryField.ts

@@ -0,0 +1,22 @@
+import type { NumberField } from 'payload'
+
+type Props = {
+  overrides?: Partial<NumberField>
+}
+
+export const inventoryField: (props?: Props) => NumberField = (props) => {
+  const { overrides } = props || {}
+
+  // @ts-expect-error - issue with payload types
+  const field: NumberField = {
+    name: 'inventory',
+    type: 'number',
+    defaultValue: 0,
+    // @ts-expect-error - translations are not typed in plugins yet
+    label: ({ t }) => t('plugin-ecommerce:inventory'),
+    min: 0,
+    ...(overrides || {}),
+  }
+
+  return field
+}

package/src/fields/pricesField.ts

@@ -0,0 +1,65 @@
+import type { GroupField } from 'payload'
+
+import type { CurrenciesConfig } from '../types.js'
+
+import { amountField } from './amountField.js'
+
+type Props = {
+  /**
+   * Use this to specify a path for the condition.
+   */
+  conditionalPath?: string
+  currenciesConfig: CurrenciesConfig
+}
+
+export const pricesField: (props: Props) => GroupField[] = ({
+  conditionalPath,
+  currenciesConfig,
+}) => {
+  const currencies = currenciesConfig.supportedCurrencies
+
+  const fields: GroupField[] = currencies.map((currency) => {
+    const name = `priceIn${currency.code}`
+    const label = `Price (${currency.code})`
+
+    const path = conditionalPath ? `${conditionalPath}.${name}Enabled` : `${name}Enabled`
+
+    return {
+      type: 'group',
+      fields: [
+        {
+          type: 'row',
+          fields: [
+            {
+              name: `${name}Enabled`,
+              type: 'checkbox',
+              admin: {
+                style: {
+                  alignSelf: 'baseline',
+                  flex: '0 0 auto',
+                },
+              },
+              label: ({ t }) =>
+                // @ts-expect-error - translations are not typed in plugins yet
+                t('plugin-ecommerce:enableCurrencyPrice', { currency: currency.code }),
+            },
+            amountField({
+              currenciesConfig,
+              currency,
+              overrides: {
+                name,
+                admin: {
+                  condition: (_, siblingData) => Boolean(siblingData?.[path]),
+                },
+                // @ts-expect-error - translations are not typed in plugins yet
+                label: ({ t }) => t('plugin-ecommerce:priceIn', { currency: currency.code }),
+              },
+            }),
+          ],
+        },
+      ],
+    }
+  })
+
+  return fields
+}

package/src/fields/statusField.ts

@@ -0,0 +1,57 @@
+import type { SelectField } from 'payload'
+
+export const statusOptions: SelectField['options'] = [
+  {
+    // @ts-expect-error - translations are not typed in plugins yet
+    label: ({ t }) => t('plugin-ecommerce:pending'),
+    value: 'pending',
+  },
+  {
+    // @ts-expect-error - translations are not typed in plugins yet
+    label: ({ t }) => t('plugin-ecommerce:succeeded'),
+    value: 'succeeded',
+  },
+  {
+    // @ts-expect-error - translations are not typed in plugins yet
+    label: ({ t }) => t('plugin-ecommerce:failed'),
+    value: 'failed',
+  },
+  {
+    // @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:expired'),
+    value: 'expired',
+  },
+  {
+    // @ts-expect-error - translations are not typed in plugins yet
+    label: ({ t }) => t('plugin-ecommerce:refunded'),
+    value: 'refunded',
+  },
+]
+
+type Props = {
+  overrides?: Partial<SelectField>
+}
+
+export const statusField: (props?: Props) => SelectField = (props) => {
+  const { overrides } = props || {}
+
+  // @ts-expect-error - issue with payload types
+  const field: SelectField = {
+    name: 'status',
+    type: 'select',
+    defaultValue: 'pending',
+    label: ({ t }) =>
+      // @ts-expect-error - translations are not typed in plugins yet
+      t('plugin-ecommerce:status'),
+    options: statusOptions,
+    required: true,
+    ...overrides,
+  }
+
+  return field
+}

package/src/fields/variantsFields.ts

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

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