chore(release): v3.0.0-beta.129 [skip ci]

Co-authored-by: Jarrod Flesch <jarrodmflesch@gmail.com>

.git-blame-ignore-revs

@@ -28,3 +28,6 @@ fb7d1be2f3325d076b7c967b1730afcef37922c2
 
 # Prettier and lint remaining db packages
 7fd736ea5b2e9fc4ef936e9dc9e5e3d722f6d8bf
+
+# Bump all eslint deps, lint and format
+03291472d6e427ff94e61fca0616cca7796a3a95

.github/workflows/main.yml

@@ -525,6 +525,7 @@ jobs:
   publish-canary:
     name: Publish Canary
     runs-on: ubuntu-latest
+    if: ${{ needs.all-green.result == 'success' && github.ref_name == 'beta' }}
     needs:
       - all-green
 
@@ -533,4 +534,3 @@ jobs:
       - run: |
           echo github.ref: ${{ github.ref }}
           echo isBeta: ${{ github.ref == 'refs/heads/beta' }}
-          echo isMain: ${{ github.ref == 'refs/heads/main' }}

README.md

@@ -52,10 +52,6 @@ Jumpstart your next project by starting with a pre-made template. These are prod
 
 Build any kind of website, blog, or portfolio from small to enterprise. Comes with a fully functional front-end built with RSCs and Tailwind.
 
-### [🛒 E-Commerce](https://github.com/payloadcms/payload/tree/beta/templates/ecommerce)
-
-Eliminate the need to combine Shopify and a CMS, and instead do it all with Payload + Stripe. Comes with a beautiful, fully functional front-end complete with shopping cart, checkout, orders, and much more.
-
 We're constantly adding more templates to our [Templates Directory](https://github.com/payloadcms/payload/tree/beta/templates). If you maintain your own template, consider adding the `payload-template` topic to your GitHub repository for others to find.
 
 - [Official Templates](https://github.com/payloadcms/payload/tree/beta/templates)

app/(payload)/layout.tsx

@@ -1,8 +1,10 @@
 /* THIS FILE WAS GENERATED AUTOMATICALLY BY PAYLOAD. */
 /* DO NOT MODIFY IT BECAUSE IT COULD BE REWRITTEN AT ANY TIME. */
-import configPromise from '@payload-config'
-import { RootLayout } from '@payloadcms/next/layouts'
 // import '@payloadcms/ui/styles.css' // Uncomment this line if `@payloadcms/ui` in `tsconfig.json` points to `/ui/dist` instead of `/ui/src`
+import type { ServerFunctionClient } from 'payload'
+
+import config from '@payload-config'
+import { handleServerFunctions, RootLayout } from '@payloadcms/next/layouts'
 import React from 'react'
 
 import { importMap } from './admin/importMap.js'
@@ -12,8 +14,17 @@ type Args = {
   children: React.ReactNode
 }
 
+const serverFunction: ServerFunctionClient = async function (args) {
+  'use server'
+  return handleServerFunctions({
+    ...args,
+    config,
+    importMap,
+  })
+}
+
 const Layout = ({ children }: Args) => (
-  <RootLayout config={configPromise} importMap={importMap}>
+  <RootLayout config={config} importMap={importMap} serverFunction={serverFunction}>
     {children}
   </RootLayout>
 )

docs/admin/components.mdx

@@ -6,7 +6,7 @@ desc: Fully customize your Admin Panel by swapping in your own React components.
 keywords: admin, components, custom, documentation, Content Management System, cms, headless, javascript, node, react, nextjs
 ---
 
-The Payload [Admin Panel](./overview) is designed to be as minimal and straightforward as possible to allow for both easy customization and full control over the UI. In order for Payload to support this level of customization, Payload provides a pattern for you to supply your own React components through your [Payload Config](../configuration/overview).
+The Payload [Admin Panel](./overview) is designed to be as minimal and straightforward as possible to allow for easy customization and full control over the UI. In order for Payload to support this level of customization, Payload provides a pattern for you to supply your own React components through your [Payload Config](../configuration/overview).
 
 All Custom Components in Payload are [React Server Components](https://react.dev/reference/rsc/server-components) by default, with the exception of [Custom Providers](#custom-providers). This enables the use of the [Local API](../local-api/overview) directly on the front-end. Custom Components are available for nearly every part of the Admin Panel for extreme granularity and control.
 
@@ -22,47 +22,41 @@ There are four main types of Custom Components in Payload:
 - [Global Components](./globals#components)
 - [Field Components](./fields)
 
-To swap in your own Custom Component, consult the list of available components. Determine the scope that corresponds to what you are trying to accomplish, then [author your React component(s)](#building-custom-components) accordingly.
+To swap in your own Custom Component, first consult the list of available components, determine the scope that corresponds to what you are trying to accomplish, then [author your React component(s)](#building-custom-components) accordingly.
 
+## Defining Custom Components
 
-## Defining Custom Components in the Payload Config
+As Payload compiles the Admin Panel, it checks your config for Custom Components. When detected, Payload either replaces its own default component with yours, or if none exists by default, renders yours outright. While are many places where Custom Components are supported in Payload, each is defined in the same way using [Component Paths](#component-paths).
 
-In the Payload Config, you can define custom React Components to enhance the admin interface. However, these components should not be imported directly into the server-only Payload Config to avoid including client-side code. Instead, you specify the path to the component. Here’s how you can do it:
+To add a Custom Component, point to its file path in your Payload Config:
 
-
-src/components/Logout.tsx
-```tsx
-'use client'
-import React from 'react'
-
-export const MyComponent = () => {
-  return (
-    <button>Click me!</button>
-  )
-}
-```
-
-payload.config.ts:
 ```ts
 import { buildConfig } from 'payload'
 
 const config = buildConfig({
   // ...
-  admin: { // highlight-line
+  admin: {
     components: {
       logout: {
-        Button: '/src/components/Logout#MyComponent'
+        Button: '/src/components/Logout#MyComponent' // highlight-line
       }
     }
   },
 })
 ```
 
-In the path `/src/components/Logout#MyComponent`, `/src/components/Logout` is the file path, and `MyComponent` is the named export. If the component is the default export, the export name can be omitted. Path and export name are separated by a `#`.
+<Banner type="success">
+  <strong>Note:</strong>
+  All Custom Components can be either Server Components or Client Components, depending on the presence of the `use client` directive at the top of the file.
+</Banner>
 
-### Configuring the Base Directory
+### Component Paths
 
-Component paths, by default, are relative to your working directory - this is usually where your Next.js config lies. To simplify component paths, you have the option to configure the *base directory* using the `admin.baseDir.baseDir` property:
+In order to ensure the Payload Config is fully Node.js compatible and as lightweight as possible, components are not directly imported into your config. Instead, they are identified by their file path for the Admin Panel to resolve on its own.
+
+Component Paths, by default, are relative to your project's base directory. This is either your current working directory, or the directory specified in `config.admin.baseDir`. To simplify Component Paths, you can also configure the base directory using the `admin.importMap.baseDir` property.
+
+Components using named exports are identified either by appending `#` followed by the export name, or using the `exportName` property. If the component is the default export, this can be omitted.
 
 ```ts
 import { buildConfig } from 'payload'
@@ -73,137 +67,72 @@ const dirname = path.dirname(filename)
 
 const config = buildConfig({
   // ...
-  admin: { // highlight-line
-     importMap: {
-      baseDir: path.resolve(dirname, 'src'),
+  admin: {
+    importMap: {
+      baseDir: path.resolve(dirname, 'src'), // highlight-line
     },
     components: {
       logout: {
-        Button: '/components/Logout#MyComponent'
+        Button: '/components/Logout#MyComponent' // highlight-line
       }
     }
   },
 })
 ```
 
-In this example, we set the base directory to the `src` directory - thus we can omit the `/src/` part of our component path string.
+In this example, we set the base directory to the `src` directory, and omit the `/src/` part of our component path string.
 
-### Passing Props
+### Config Options
 
-Each React Component in the Payload Config is typed as `PayloadComponent`. This usually is a string, but can also be an object containing the following properties:
+While Custom Components are usually defined as a string, you can also pass in an object with additional options:
 
-| Property      | Description                                                                                                                   |
-|---------------|-------------------------------------------------------------------------------------------------------------------------------|
-| `clientProps` | Props to be passed to the React Component if it's a Client Component                                                          |
-| `exportName`  | Instead of declaring named exports using `#` in the component path, you can also omit them from `path` and pass them in here. |
-| `path`        | Path to the React Component. Named exports can be appended to the end of the path, separated by a `#`                         |
-| `serverProps` | Props to be passed to the React Component if it's a Server Component                                                          |
-
-To pass in props from the config, you can use the `clientProps` and/or `serverProps` properties. This alleviates the need to use an HOC (Higher-Order-Component) to declare a React Component with props passed in.
-
-Here is an example:
-
-src/components/Logout.tsx
-```tsx
-'use client'
-import React from 'react'
-
-export const MyComponent = ({ text }: { text: string }) => {
-  return (
-    <button>Click me! {text}</button>
-  )
-}
-```
-
-payload.config.ts:
 ```ts
 import { buildConfig } from 'payload'
 
 const config = buildConfig({
   // ...
-  admin: { // highlight-line
+  admin: {
     components: {
       logout: {
+        // highlight-start
         Button: {
           path: '/src/components/Logout',
-          clientProps: {
-            text: 'Some Text.'
-          },
-          exportName: 'MyComponent'
+          exportName: 'MyComponent',
         }
+        // highlight-end
       }
     }
   },
 })
 ```
 
-### Import Maps
+The following options are available:
 
-It's essential to understand how `PayloadComponent` paths function behind the scenes. Directly importing React Components into your Payload Config using import statements can introduce client-only modules like CSS into your server-only config. This could error when attempting to load the Payload Config in server-only environments and unnecessarily increase the size of the Payload Config, which should remain streamlined and efficient for server use.
+| Property      | Description                                                                                                                   |
+|---------------|-------------------------------------------------------------------------------------------------------------------------------|
+| **`clientProps`** | Props to be passed to the Custom Components if it's a Client Component. [More details](#custom-props).                         |
+| **`exportName`**  | Instead of declaring named exports using `#` in the component path, you can also omit them from `path` and pass them in here. |
+| **`path`**        | File path to the Custom Component. Named exports can be appended to the end of the path, separated by a `#`.                         |
+| **`serverProps`** | Props to be passed to the Custom Component if it's a Server Component. [More details](#custom-props).                         |
 
-Instead, we utilize component paths to reference React Components. This method enhances the Payload Config with actual React Component imports on the client side, without affecting server-side usage. A script is deployed to scan the Payload Config, collecting all component paths and creating an `importMap.js`. This file, located in app/(payload)/admin/importMap.js, must be statically imported by your Next.js root page and layout. The script imports all the React Components from the specified paths into a Map, associating them with their respective paths (the ones you defined).
+For more details on how to build Custom Components, see [Building Custom Components](#building-custom-components).
 
-When constructing the `ClientConfig`, Payload uses the component paths as keys to fetch the corresponding React Component imports from the Import Map. It then substitutes the `PayloadComponent` with a `MappedComponent`. A `MappedComponent` includes the React Component and additional metadata, such as whether it's a server or a client component and which props it should receive. These components are then rendered through the `<RenderComponent />` component within the Payload Admin Panel.
+### Import Map
 
-Import maps are regenerated whenever you modify any element related to component paths. This regeneration occurs at startup and whenever Hot Module Replacement (HMR) runs. If the import maps fail to regenerate during HMR, you can restart your application and execute the `payload generate:importmap` command to manually create a new import map. If you encounter any errors running this command, see the [Troubleshooting](../local-api/outside-nextjs#troubleshooting) section.
+In order for Payload to make use of [Component Paths](#component-paths), an "Import Map" is automatically generated at `app/(payload)/admin/importMap.js`. This file contains every Custom Component in your config, keyed to their respective paths. When Payload needs to lookup a component, it uses this file to find the correct import.
 
-### Component paths in external packages
+The Import Map is automatically regenerated at startup and whenever Hot Module Replacement (HMR) runs, or you can run `payload generate:importmap` to manually regenerate it.
 
-Component paths are resolved relative to your project's base directory, which is either your current working directory or the directory specified in `config.admin.baseDir`. When using custom components from external packages, you can't use relative paths. Instead, use an import path that's accessible as if you were writing an import statement in your project's base directory.
+#### Custom Imports
 
-For example, to export a field with a custom component from an external package named `my-external-package`:
+If needed, custom items can be appended onto the Import Map. This is mostly only relevant for plugin authors who need to add a custom import that is not referenced in a known location.
+
+To add a custom import to the Import Map, use the `admin.dependencies` property in your [Payload Config](../getting-started/overview):
 
 ```ts
-import type { Field } from 'payload'
-export const MyCustomField: Field = {
-  type: 'text',
-  name: 'MyField',
-  admin: {
-    components: {
-      Field: 'my-external-package/client#MyFieldComponent'
-    }
-  }
-}
-```
+import { buildConfig } from 'payload'
 
-Despite `MyFieldComponent` living in `src/components/MyFieldComponent.tsx` in `my-external-package`, this will not be accessible from the consuming project. Instead, we recommend exporting all custom components from one file in the external package. For example, you can define a `src/client.ts file in `my-external-package`:
-
-```ts
-'use client'
-export { MyFieldComponent } from './components/MyFieldComponent'
-```
-
-Then, update the package.json of `my-external-package:
-
-```json
-{
-...
-  "exports": {
-    "./client": {
-        "import": "./dist/client.js",
-        "types": "./dist/client.d.ts",
-        "default": "./dist/client.js"
-    }
-  }
-}
-```
-
-This setup allows you to specify the component path as `my-external-package/client#MyFieldComponent` as seen above. The import map will generate:
-
-```ts
-import { MyFieldComponent } from 'my-external-package/client'
-```
-
-which is a valid way to access MyFieldComponent that can be resolved by the consuming project.
-
-### Custom Components from unknown locations
-
-By default, any component paths from known locations are added to the import map. However, if you need to add any components from unknown locations to the import map, you can do so by adding them to the `admin.dependencies` array in your Payload Config. This is mostly only relevant for plugin authors and not for regular Payload users.
-
-Example:
-
-```ts
-export default {
+export default buildConfig({
   // ...
   admin: {
     // ...
@@ -220,24 +149,6 @@ export default {
 }
 ```
 
-This way, `TestComponent` is added to the import map, no matter if it's referenced in a known location or not. On the client, you can then use the component like this:
-
-```tsx
-'use client'
-
-import { RenderComponent, useConfig } from '@payloadcms/ui'
-import React from 'react'
-
-export const CustomView = () => {
-  const { config } = useConfig()
-  return (
-    <div>
-      <RenderComponent mappedComponent={config.admin.dependencies?.myTestComponent} />
-    </div>
-  )
-}
-```
-
 ## Root Components
 
 Root Components are those that effect the [Admin Panel](./overview) generally, such as the logo or the main nav.
@@ -331,6 +242,8 @@ export const useMyCustomContext = () => useContext(MyCustomContext)
 
 All Custom Components in Payload are [React Server Components](https://react.dev/reference/rsc/server-components) by default, with the exception of [Custom Providers](#custom-providers). This enables the use of the [Local API](../local-api/overview) directly on the front-end, among other things.
 
+### Default Props
+
 To make building Custom Components as easy as possible, Payload automatically provides common props, such as the [`payload`](../local-api/overview) class and the [`i18n`](../configuration/i18n) object. This means that when building Custom Components within the Admin Panel, you do not have to get these yourself.
 
 Here is an example:
@@ -359,12 +272,46 @@ Each Custom Component receives the following props by default:
 | `payload`                 | The [Payload](../local-api/overview) class.                                                           |
 | `i18n`                    | The [i18n](../configuration/i18n) object.                                                                           |
 
-Custom Components also receive various other props that are specific to the context in which the Custom Component is being rendered. For example, [Custom Views](./views) receive the `user` prop. For a full list of available props, consult the documentation related to the specific component you are working with.
-
-<Banner type="success">
-  See [Root Components](#root-components), [Collection Components](#collection-components), [Global Components](#global-components), or [Field Components](#custom-field-components) for a complete list of all available components.
+<Banner type="warning">
+  <strong>Reminder:</strong>
+  All Custom Components also receive various other props that are specific component being rendered. See [Root Components](#root-components), [Collection Components](#collection-components), [Global Components](#global-components), or [Field Components](#custom-field-components) for a complete list of all default props per component.
 </Banner>
 
+### Custom Props
+
+To pass in custom props from the config, you can use either the `clientProps` or `serverProps` properties depending on whether your prop is [serializable](https://react.dev/reference/rsc/use-client#serializable-types), and whether your component is a Server or Client Component.
+
+```ts
+import { buildConfig } from 'payload'
+
+const config = buildConfig({
+  // ...
+  admin: { // highlight-line
+    components: {
+      logout: {
+        Button: {
+          path: '/src/components/Logout#MyComponent',
+          clientProps: {
+            myCustomProp: 'Hello, World!' // highlight-line
+          },
+        }
+      }
+    }
+  },
+})
+```
+
+```tsx
+'use client'
+import React from 'react'
+
+export const MyComponent = ({ myCustomProp }: { myCustomProp: string }) => {
+  return (
+    <button>{myCustomProp}</button>
+  )
+}
+```
+
 ### Client Components
 
 When [Building Custom Components](#building-custom-components), it's still possible to use client-side code such as `useState` or the `window` object. To do this, simply add the `use client` directive at the top of your file. Payload will automatically detect and remove all default, [non-serializable props](https://react.dev/reference/rsc/use-client#serializable-types) before rendering your component.

docs/admin/fields.mdx

@@ -228,7 +228,6 @@ The following additional properties are also provided to the `field` prop:
 
 | Property         | Description                                                                                                                                                                                                                      |
 | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **`_isPresentational`** | A boolean indicating that the field is purely visual and does not directly affect data or change data shape, i.e. the [UI Field](../fields/ui). |
 | **`_path`** | A string representing the direct, dynamic path to the field at runtime, i.e. `myGroup.myArray[0].myField`. |
 | **`_schemaPath`** | A string representing the direct, static path to the [Field Config](../fields/overview), i.e. `myGroup.myArray.myField` |
 

docs/admin/overview.mdx

@@ -195,7 +195,7 @@ app/
 
 <Banner type="warning">
   <strong>Note:</strong>
-  If you set Root-level Routes _before_ auto-generating the Admin Panel, your [Project Structure](#project-structure) will already be set up correctly.
+  If you set Root-level Routes _before_ auto-generating the Admin Panel via `create-payload-app`, your [Project Structure](#project-structure) will already be set up correctly.
 </Banner>
 
 ### Admin-level Routes

docs/admin/views.mdx

@@ -15,7 +15,7 @@ There are four types of views within the Admin Panel:
 - [Global Views](#global-views)
 - [Document Views](#document-views)
 
-To swap in your own Custom Views, consult the list of available components. Determine the scope that corresponds to what you are trying to accomplish, then [author your React component(s)](#building-custom-views) accordingly.
+To swap in your own Custom View, first consult the list of available components, determine the scope that corresponds to what you are trying to accomplish, then [author your React component(s)](#building-custom-views) accordingly.
 
 ## Root Views
 

docs/fields/array.mdx

@@ -6,7 +6,7 @@ desc: Array Fields are intended for sets of repeating fields, that you define. L
 keywords: array, fields, config, configuration, documentation, Content Management System, cms, headless, javascript, node, react, nextjs
 ---
 
-The Array Field is used when you need to have a set of "repeating" [Fields](./overview). It stores an array of objects containing fields that you define. These fields can be of any type, including other arrays to achieve infinitely nested structures.
+The Array Field is used when you need to have a set of "repeating" [Fields](./overview). It stores an array of objects containing fields that you define. These fields can be of any type, including other arrays, to achieve infinitely nested data structures.
 
 Arrays are useful for many different types of content from simple to complex, such as:
 

docs/fields/json.mdx

@@ -7,7 +7,7 @@ desc: The JSON field type will store any string in the Database. Learn how to us
 keywords: json, jsonSchema, schema, validation, fields, config, configuration, documentation, Content Management System, cms, headless, javascript, node, react, nextjs
 ---
 
-The JSON Field saves actual JSON in the database, which differs from the Code field that saves the value as a string in the database.
+The JSON Field saves raw JSON to the database and provides the [Admin Panel](../admin/overview) with a code editor styled interface. This is different from the [Code Field](./code) which saves the value as a string in the database.
 
 <LightDarkImage
   srcLight="https://payloadcms.com/images/docs/fields/json.png"

docs/fields/overview.mdx

@@ -93,6 +93,7 @@ Presentational Fields do not store data in the database. Instead, they are used
 Here are the available Presentational Fields:
 
 - [Collapsible](/docs/fields/collapsible) - nests fields within a collapsible component
+- [Join](/docs/fields/join) - achieves two-way data binding between fields
 - [Row](/docs/fields/row) - aligns fields horizontally
 - [Tabs (Unnamed)](/docs/fields/tabs) - nests fields within a tabbed layout
 - [UI](/docs/fields/ui) - blank field for custom UI components
@@ -123,7 +124,7 @@ export const MyField: Field = {
 
 ### Field Names
 
-All [Data Fields](#data-fields) require a `name` property. This is the key that will be used to store and retrieve the field's value in the database. This property must be unique within the Collection, Global, or nested group that it is defined in.
+All [Data Fields](#data-fields) require a `name` property. This is the key that will be used to store and retrieve the field's value in the database. This property must be unique amongst this field's siblings.
 
 To set a field's name, use the `name` property in your Field Config:
 
@@ -205,7 +206,7 @@ export const MyField: Field = {
 }
 ```
 
-Default values can be defined as a static value or a function that returns a value. When a `defaultValue` is defined statically, Payload's DB adapters will apply it to the database schema or models.
+Default values can be defined as a static value or a function that returns a value. When a `defaultValue` is defined statically, Payload's [Database Adapters](../database/overview) will apply it to the database schema or models.
 
 Functions can be written to make use of the following argument properties:
 
@@ -264,7 +265,7 @@ The following arguments are provided to the `validate` function:
 
 #### Validation Context
 
-The `ctx` argument contains full document data, sibling field data, the current operation, and other useful information such as currently authenticated in user:
+The `ctx` argument contains full document data, sibling field data, the current operation, and other useful information such as currently authenticated user:
 
 ```ts
 import type { Field } from 'payload'
@@ -358,7 +359,7 @@ For full details on Admin Options, see the [Field Admin Options](../admin/fields
 
 All [Collections](../configuration/collections) automatically generate their own ID field. If needed, you can override this behavior by providing an explicit ID field to your config. This field should either be required or have a hook to generate the ID dynamically.
 
-To define a custom ID field, add a new field with the `name` property set to `id`:
+To define a custom ID field, add a top-level field with the `name` property set to `id`:
 
 ```ts
 import type { CollectionConfig } from 'payload'

docs/getting-started/installation.mdx

@@ -35,6 +35,10 @@ Adding Payload to an existing Next.js app is super straightforward. You can eith
 
 If you don't have a Next.js app already, but you still want to start a project from a blank Next.js app, you can create a new Next.js app using `npx create-next-app` - and then just follow the steps below to install Payload.
 
+<Banner type="info">
+  <strong>Note:</strong> Next.js version 15 or higher is required for Payload.
+</Banner>
+
 #### 1. Install the relevant packages
 
 First, you'll want to add the required Payload packages to your project and can do so by running the command below:

docs/jobs-queue/jobs.mdx

@@ -0,0 +1,46 @@
+---
+title: Jobs
+label: Jobs
+order: 40
+desc: A Job is a set of work that is offloaded from your APIs and will be processed at a later date.
+keywords: jobs queue, application framework, typescript, node, react, nextjs
+---
+
+Now that we have covered Tasks and Workflows, we can tie them together with a concept called a Job.
+
+<Banner type="default">
+  Whereas you define Workflows and Tasks, which control your business logic, a <strong>Job</strong> is an individual instance of either a Task or a Workflow which contains many tasks.
+</Banner>
+
+For example, let's say we have a Workflow or Task that describes the logic to sync information from Payload to a third-party system. This is how you'd declare how to sync that info, but it wouldn't do anything on its own. In order to run that task or workflow, you'd create a Job that references the corresponding Task or Workflow.
+
+Jobs are stored in the Payload database in the `payload-jobs` collection, and you can decide to keep a running list of all jobs, or configure Payload to delete the job when it has been successfully executed.
+
+#### Queuing a new job
+
+In order to queue a job, you can use the `payload.jobs.queue` function.
+
+Here's how you'd queue a new Job, which will run a `createPostAndUpdate` workflow:
+
+```ts
+const createdJob = await payload.jobs.queue({
+  // Pass the name of the workflow
+  workflow: 'createPostAndUpdate',
+  // The input type will be automatically typed
+  // according to the input you've defined for this workflow
+  input: {
+    title: 'my title',
+  },
+})
+```
+
+In addition to being able to queue new Jobs based on Workflows, you can also queue a job for a single Task:
+
+```ts
+const createdJob = await payload.jobs.queue({
+  task: 'createPost',
+  input: {
+    title: 'my title',
+  },
+})
+```

docs/jobs-queue/overview.mdx

@@ -6,458 +6,65 @@ desc: Payload provides all you need to run job queues, which are helpful to offl
 keywords: jobs queue, application framework, typescript, node, react, nextjs
 ---
 
-Payload's Jobs Queue gives you a simple, yet powerful way to offload large or future tasks to separate compute resources.
+Payload's Jobs Queue gives you a simple, yet powerful way to offload large or future tasks to separate compute resources which is a very powerful feature of many application frameworks.
 
-For example, when building applications with Payload, you might run into a case where you need to perform some complex logic in a Payload [Hook](/docs/hooks/overview) but you don't want that hook to "block" or slow down the response returned from the Payload API.
+### Example use cases
 
-Instead of running long or expensive logic in a Hook, you can instead create a Job and add it to a Queue. It can then be picked up by a separate worker which periodically checks the queue for new jobs, and then executes each job accordingly. This way, your Payload API responses can remain as fast as possible, and you can still perform logic as necessary without blocking or affecting your users' experience.
+**Non-blocking workloads**
 
-Jobs are also handy for delegating certain actions to take place in the future, such as scheduling a post to be published at a later date. In this example, you could create a Job that will automatically publish a post at a certain time.
+You might need to perform some complex, slow-running logic in a Payload [Hook](/docs/hooks/overview) but you don't want that hook to "block" or slow down the response returned from the Payload API. Instead of running this logic directly in a hook, which would block your API response from returning until the expensive work is completed, you can queue a new Job and let it run at a later date.
 
-#### How it works
+Examples:
 
-There are a few concepts that you should become familiarized with before using Payload's Jobs Queue - [Tasks](#tasks), [Workflows](#workflows), [Jobs](#jobs), and finally [Queues](#queues).
+- Create vector embeddings from your documents, and keep them in sync as your documents change
+- Send data to a third-party API on document change
+- Trigger emails based on customer actions
 
-## Tasks
+**Scheduled actions**
 
-<Banner type="default">
-  A <strong>"Task"</strong> is a function definition that performs business logic and whose input and output are both strongly typed.
-</Banner>
+If you need to schedule an action to be run or processed at a certain date in the future, you can queue a job with the `waitUntil` property set. This will make it so the job is not "picked up" until that `waitUntil` date has passed.
 
-You can register Tasks on the Payload config, and then create Jobs or Workflows that use them. Think of Tasks like tidy, isolated "functions that do one specific thing".
+Examples:
 
-Payload Tasks can be configured to automatically retried if they fail, which makes them valuable for "durable" workflows like AI applications where LLMs can return non-deterministic results, and might need to be retried.
+- Process scheduled posts, where the scheduled date is at a time set in the future
+- Unpublish posts at a given time
+- Send a reminder email to a customer after X days of signing up for a trial
 
-Tasks can either be defined within the `jobs.tasks` array in your payload config, or they can be defined inline within a workflow.
+**Periodic sync or similar scheduled action**
 
-### Defining tasks in the config
+Some applications may need to perform a regularly scheduled operation of some type. Jobs are perfect for this because you can execute their logic using `cron`, scheduled nightly, every twelve hours, or some similar time period. 
 
-Simply add a task to the `jobs.tasks` array in your Payload config. A task consists of the following fields:
+Examples:
 
-| Option                      | Description                                                                      |
-| --------------------------- | -------------------------------------------------------------------------------- |
-| `slug` | Define a slug-based name for this job. This slug needs to be unique among both tasks and workflows.|
-| `handler`   | The function that should be responsible for running the job. You can either pass a string-based path to the job function file, or the job function itself. If you are using large dependencies within your job, you might prefer to pass the string path because that will avoid bundling large dependencies in your Next.js app.         |
-| `inputSchema` | Define the input field schema - payload will generate a type for this schema. |
-| `interfaceName` | You can use interfaceName to change the name of the interface that is generated for this task. By default, this is "Task" + the capitalized task slug. |
-| `outputSchema` | Define the output field schema - payload will generate a type for this schema. |
-| `label` | Define a human-friendly label for this task. |
-| `onFail` | Function to be executed if the task fails. |
-| `onSuccess` | Function to be executed if the task succeeds. |
-| `retries` | Specify the number of times that this step should be retried if it fails. |
+- You'd like to send emails to all customers on a regular, scheduled basis
+- Periodically trigger a rebuild of your frontend at night
+- Sync resources to or from a third-party API during non-peak times
 
-The logic for the Task is defined in the `handler` - which can be defined as a function, or a path to a function. The `handler` will run once a worker picks picks up a Job that includes this task.
+**Offloading complex operations**
 
-It should return an object with an `output` key, which should contain the output of the task as you've defined.
+You may run into the need to perform computationally expensive functions which might slow down your main Payload API server(s). The Jobs Queue allows you to offload these tasks a separate compute resource rather than slowing down the server(s) that run your Payload APIs. With Payload Task definitions, you can even keep large dependencies out of your main Next.js bundle by dynamically importing them only when they are used. This keeps your Next.js + Payload compilation fast and ensures large dependencies do not get bundled into your Payload production build.
 
-Example:
+Examples:
 
-```ts
-export default buildConfig({
-  // ...
-  jobs: {
-    tasks: [
-      {
-        // Configure this task to automatically retry
-        // up to two times
-        retries: 2,
+- You need to create (and then keep in sync) vector embeddings of your documents as they change, but you use an open source model to generate embeddings
+- You have a PDF generator that needs to dynamically build and send PDF versions of documents to customers
+- You need to use a headless browser to perform some type of logic
+- You need to perform a series of actions, each of which depends on a prior action and should be run in as "durable" of a fashion as possible 
 
-        // This is a unique identifier for the task
+### How it works
 
-        slug: 'createPost',
+There are a few concepts that you should become familiarized with before using Payload's Jobs Queue. We recommend learning what each of these does in order to fully understand how to leverage the power of Payload's Jobs Queue.
 
-        // These are the arguments that your Task will accept
-        inputSchema: [
-          {
-            name: 'title',
-            type: 'text',
-            required: true,
-          },
-        ],
+1. [Tasks](/docs/beta/jobs-queue/tasks)
+1. [Workflows](/docs/beta/jobs-queue/workflows)
+1. [Jobs](/docs/beta/jobs-queue/jobs)
+1. [Queues](/docs/beta/jobs-queue/queues)
 
-        // These are the properties that the function should output
-        outputSchema: [
-          {
-            name: 'postID',
-            type: 'text',
-            required: true,
-          },
-        ],
+All of these pieces work together in order to allow you to offload long-running, expensive, or future scheduled work from your main APIs. 
 
-        // This is the function that is run when the task is invoked
-        handler: async ({ input, job, req }) => {
-          const newPost = await req.payload.create({
-            collection: 'post',
-            req,
-            data: {
-              title: input.title,
-            },
-          })
-          return {
-            output: {
-              postID: newPost.id,
-            },
-          }
-        },
-      } as TaskConfig<'createPost'>,
-    ]
-  }
-})
-```
+Here's a quick overview:
 
-In addition to defining handlers as functions directly provided to your Payload config, you can also pass an _absolute path_ to where the handler is defined. If your task has large dependencies, and you are planning on executing your jobs in a separate process that has access to the filesystem, this could be a handy way to make sure that your Payload + Next.js app remains quick to compile and has minimal dependencies.
-
-In general, this is an advanced use case. Here's how this would look:
-
-`payload.config.ts:`
-
-```ts
-import { fileURLToPath } from 'node:url'
-import path from 'path'
-
-const filename = fileURLToPath(import.meta.url)
-const dirname = path.dirname(filename)
-
-export default buildConfig({
-  jobs: {
-    tasks: [
-      {
-        // ...
-        // The #createPostHandler is a named export within the `createPost.ts` file
-        handler: path.resolve(dirname, 'src/tasks/createPost.ts') + '#createPostHandler',
-      }
-    ]
-  }
-})
-```
-
-Then, the `createPost` file itself:
-
-`src/tasks/createPost.ts:`
-
-```ts
-import type { TaskHandler } from 'payload'
-
-export const createPostHandler: TaskHandler<'createPost'> = async ({ input, job, req }) => {
-  const newPost = await req.payload.create({
-    collection: 'post',
-    req,
-    data: {
-      title: input.title,
-    },
-  })
-  return {
-    output: {
-      postID: newPost.id,
-    },
-  }
-}
-```
-
-## Workflows
-
-<Banner type="default">
-  A <strong>"Workflow"</strong> is an optional way to <em>combine multiple tasks together</em> in a way that can be gracefully retried from the point of failure.
-</Banner>
-
-They're most helpful when you have multiple tasks in a row, and you want to configure each task to be able to be retried if they fail.
-
-If a task within a workflow fails, the Workflow will automatically "pick back up" on the task where it failed and **not re-execute any prior tasks that have already been executed**.
-
-#### Defining a workflow
-
-The most important aspect of a Workflow is the `handler`, where you can declare when and how the tasks should run by simply calling the `runTask` function. If any task within the workflow, fails, the entire `handler` function will re-run.
-
-However, importantly, tasks that have successfully been completed will simply re-return the cached and saved output without running again. The Workflow will pick back up where it failed and only task from the failure point onward will be re-executed.
-
-To define a JS-based workflow, simply add a workflow to the `jobs.wokflows` array in your Payload config. A workflow consists of the following fields:
-
-| Option                      | Description                                                                      |
-| --------------------------- | -------------------------------------------------------------------------------- |
-| `slug` | Define a slug-based name for this workflow. This slug needs to be unique among both tasks and workflows.|
-| `handler`   | The function that should be responsible for running the workflow. You can either pass a string-based path to the workflow function file, or workflow job function itself. If you are using large dependencies within your workflow, you might prefer to pass the string path because that will avoid bundling large dependencies in your Next.js app.         |
-| `inputSchema` | Define the input field schema - payload will generate a type for this schema. |
-| `interfaceName` | You can use interfaceName to change the name of the interface that is generated for this workflow. By default, this is "Workflow" + the capitalized workflow slug. |
-| `label` | Define a human-friendly label for this workflow. |
-| `queue` | Optionally, define the queue name that this workflow should be tied to. Defaults to "default". |
-
-Example:
-
-```ts
-export default buildConfig({
-  // ...
-  jobs: {
-    tasks: [
-      // ...
-    ]
-    workflows: [
-      {
-        slug: 'createPostAndUpdate',
-
-        // The arguments that the workflow will accept
-        inputSchema: [
-          {
-            name: 'title',
-            type: 'text',
-            required: true,
-          },
-        ],
-
-        // The handler that defines the "control flow" of the workflow
-        // Notice how it calls `runTask` to execute tasks
-        handler: async ({ job, runTask }) => {
-
-          // This workflow first runs a task called `createPost`
-          const output = await runTask({
-            task: 'createPost',
-
-            // You need to define a unique ID for this task invocation
-            // that will always be the same if this workflow fails
-            // and is re-executed in the future
-            id: '1',
-            input: {
-              title: job.input.title,
-            },
-          })
-
-          // Once the prior task completes, it will run a task
-          // called `updatePost`
-          await runTask({
-            task: 'updatePost',
-            id: '2',
-            input: {
-              post: job.taskStatus.createPost['1'].output.postID, // or output.postID
-              title: job.input.title + '2',
-            },
-          })
-        },
-      } as WorkflowConfig<'updatePost'>
-    ]
-  }
-})
-```
-
-#### Running tasks inline
-
-In the above example, our workflow was executing tasks that we already had defined in our Payload config. But, you can also run tasks without predefining them.
-
-To do this, you can use the `runTaskInline` function.
-
-The drawbacks of this approach are that tasks cannot be re-used across workflows as easily, and the **task data stored in the job** will not be typed. In the following example, the inline task data will be stored on the job under `job.taskStatus.inline['2']` but completely untyped, as types for dynamic tasks like these cannot be generated beforehand.
-
-Example:
-
-```ts
-export default buildConfig({
-  // ...
-  jobs: {
-    tasks: [
-      // ...
-    ]
-    workflows: [
-      {
-        slug: 'createPostAndUpdate',
-        inputSchema: [
-          {
-            name: 'title',
-            type: 'text',
-            required: true,
-          },
-        ],
-        handler: async ({ job, runTask }) => {
-          // Here, we run a predefined task.
-          // The `createPost` handler arguments and return type
-          // are both strongly typed
-          const output = await runTask({
-            task: 'createPost',
-            id: '1',
-            input: {
-              title: job.input.title,
-            },
-          })
-
-
-          // Here, this task is not defined in the Payload config
-          // and is "inline". Its output will be stored on the Job in the database
-          // however its arguments will be untyped.
-          const { newPost } = await runTaskInline({
-            task: async ({ req }) => {
-              const newPost = await req.payload.update({
-                collection: 'post',
-                id: '2',
-                req,
-                retries: 3,
-                data: {
-                  title: 'updated!',
-                },
-              })
-              return {
-                output: {
-                  newPost
-                },
-              }
-            },
-            id: '2',
-          })
-        },
-      } as WorkflowConfig<'updatePost'>
-    ]
-  }
-})
-```
-
-## Jobs
-
-Now that we have covered Tasks and Workflows, we can tie them together with a concept called a Job.
-
-<Banner type="default">
-  Whereas you define Workflows and Tasks, which control your business logic, a <strong>Job</strong> is an individual instance of either a Task or a Workflow which contains many tasks.
-</Banner>
-
-For example, let's say we have a Workflow or Task that describes the logic to sync information from Payload to a third-party system. This is how you'd declare how to sync that info, but it wouldn't do anything on its own. In order to run that task or workflow, you'd create a Job that references the corresponding Task or Workflow.
-
-Jobs are stored in the Payload database in the `payload-jobs` collection, and you can decide to keep a running list of all jobs, or configure Payload to delete the job when it has been successfully executed.
-
-#### Queuing a new job
-
-In order to queue a job, you can use the `payload.jobs.queue` function.
-
-Here's how you'd queue a new Job, which will run a `createPostAndUpdate` workflow:
-
-```ts
-const createdJob = await payload.jobs.queue({
-  // Pass the name of the workflow
-  workflow: 'createPostAndUpdate',
-  // The input type will be automatically typed
-  // according to the input you've defined for this workflow
-  input: {
-    title: 'my title',
-  },
-})
-```
-
-In addition to being able to queue new Jobs based on Workflows, you can also queue a job for a single Task:
-
-```ts
-const createdJob = await payload.jobs.queue({
-  task: 'createPost',
-  input: {
-    title: 'my title',
-  },
-})
-```
-
-## Queues
-
-Now let's talk about how to _run these jobs_. Right now, all we've covered is how to queue up jobs to run, but so far, we aren't actually running any jobs. This is the final piece of the puzzle.
-
-<Banner type="default">
-  A <strong>Queue</strong> is a list of jobs that should be executed in order of when they were added.
-</Banner>
-
-When you go to run jobs, Payload will query for any jobs that are added to the queue and then run them. By default, all queued jobs are added to the `default` queue.
-
-**But, imagine if you wanted to have some jobs that run nightly, and other jobs which should run every five minutes.**
-
-By specifying the `queue` name when you queue a new job using `payload.jobs.queue()`, you can queue certain jobs with `queue: 'nightly'`, and other jobs can be left as the default queue.
-
-Then, you could configure two different runner strategies:
-
-1. A `cron` that runs nightly, querying for jobs added to the `nightly` queue
-2. Another that runs any jobs that were added to the `default` queue every ~5 minutes or so
-
-## Executing jobs
-
-As mentioned above, you can queue jobs, but the jobs won't run unless a worker picks up your jobs and runs them. This can be done in two ways:
-
-#### Endpoint
-
-You can execute jobs by making a fetch request to the `/api/payload-jobs/run` endpoint:
-
-```ts
-// Here, we're saying we want to run only 100 jobs for this invocation
-// and we want to pull jobs from the `nightly` queue:
-await fetch('/api/payload-jobs/run?limit=100&queue=nightly', {
-  method: 'GET',
-  headers: {
-    'Authorization': `Bearer ${token}`,
-  },
-});
-```
-
-This endpoint is automatically mounted for you and is helpful in conjunction with serverless platforms like Vercel, where you might want to use Vercel Cron to invoke a serverless function that executes your jobs.
-
-**Vercel Cron Example**
-
-If you're deploying on Vercel, you can add a `vercel.json` file in the root of your project that configures Vercel Cron to invoke the `run` endpoint on a cron schedule.
-
-Here's an example of what this file will look like:
-
-```json
-{
-  "crons": [
-    {
-      "path": "/api/payload-jobs/run",
-      "schedule": "*/5 * * * *"
-    }
-  ]
-}
-```
-
-The configuration above schedules the endpoint `/api/payload-jobs/run` to be invoked every 5 minutes.
-
-The last step will be to secure your `run` endpoint so that only the proper users can invoke the runner.
-
-To do this, you can set an environment variable on your Vercel project called `CRON_SECRET`, which should be a random string—ideally 16 characters or longer.
-
-Then, you can modify the `access` function for running jobs by ensuring that only Vercel can invoke your runner.
-
-```ts
-export default buildConfig({
-  // Other configurations...
-  jobs: {
-    access: {
-      run: ({ req }: { req: PayloadRequest }): boolean => {
-        // Allow logged in users to execute this endpoint (default)
-        if (req.user) return true
-
-        // If there is no logged in user, then check
-        // for the Vercel Cron secret to be present as an
-        // Authorization header:
-        const authHeader = req.headers.get('authorization');
-        return authHeader === `Bearer ${process.env.CRON_SECRET}`;
-      },
-    },
-    // Other job configurations...
-  }
-})
-```
-
-This works because Vercel automatically makes the `CRON_SECRET` environment variable available to the endpoint as the `Authorization` header when triggered by the Vercel Cron, ensuring that the jobs can be run securely.
-
-After the project is deployed to Vercel, the Vercel Cron job will automatically trigger the `/api/payload-jobs/run` endpoint in the specified schedule, running the queued jobs in the background.
-
-#### Local API
-
-If you want to process jobs programmatically from your server-side code, you can use the Local API:
-
-```ts
-const results = await payload.jobs.run()
-
-// You can customize the queue name and limit by passing them as arguments:
-await payload.jobs.run({ queue: 'nightly', limit: 100 })
-```
-
-#### Bin script
-
-Finally, you can process jobs via the bin script that comes with Payload out of the box.
-
-```sh
-npx payload jobs:run --queue default --limit 10
-```
-
-In addition, the bin script allows you to pass a `--cron` flag to the `jobs:run` command to run the jobs on a scheduled, cron basis:
-
-```sh
-npx payload jobs:run --cron "*/5 * * * *"
-```
+- A Task is a specific function that performs business logic
+- Workflows are groupings of specific tasks which should be run in-order, and can be retried from a specific point of failure
+- A Job is an instance of a single task or workflow which will be executed
+- A Queue is a way to segment your jobs into different "groups" - for example, some to run nightly, and others to run every 10 minutes 

docs/jobs-queue/queues.mdx

@@ -0,0 +1,120 @@
+---
+title: Queues
+label: Queues
+order: 50
+desc: A Queue is a specific group of jobs which can be executed in the order that they were added.
+keywords: jobs queue, application framework, typescript, node, react, nextjs
+---
+
+Queues are the final aspect of Payload's Jobs Queue and deal with how to _run your jobs_. Up to this point, all we've covered is how to queue up jobs to run, but so far, we aren't actually running any jobs.
+
+<Banner type="default">
+  A <strong>Queue</strong> is a grouping of jobs that should be executed in order of when they were added.
+</Banner>
+
+When you go to run jobs, Payload will query for any jobs that are added to the queue and then run them. By default, all queued jobs are added to the `default` queue.
+
+**But, imagine if you wanted to have some jobs that run nightly, and other jobs which should run every five minutes.**
+
+By specifying the `queue` name when you queue a new job using `payload.jobs.queue()`, you can queue certain jobs with `queue: 'nightly'`, and other jobs can be left as the default queue.
+
+Then, you could configure two different runner strategies:
+
+1. A `cron` that runs nightly, querying for jobs added to the `nightly` queue
+2. Another that runs any jobs that were added to the `default` queue every ~5 minutes or so
+
+## Executing jobs
+
+As mentioned above, you can queue jobs, but the jobs won't run unless a worker picks up your jobs and runs them. This can be done in two ways:
+
+#### Endpoint
+
+You can execute jobs by making a fetch request to the `/api/payload-jobs/run` endpoint:
+
+```ts
+// Here, we're saying we want to run only 100 jobs for this invocation
+// and we want to pull jobs from the `nightly` queue:
+await fetch('/api/payload-jobs/run?limit=100&queue=nightly', {
+  method: 'GET',
+  headers: {
+    'Authorization': `Bearer ${token}`,
+  },
+});
+```
+
+This endpoint is automatically mounted for you and is helpful in conjunction with serverless platforms like Vercel, where you might want to use Vercel Cron to invoke a serverless function that executes your jobs.
+
+**Vercel Cron Example**
+
+If you're deploying on Vercel, you can add a `vercel.json` file in the root of your project that configures Vercel Cron to invoke the `run` endpoint on a cron schedule.
+
+Here's an example of what this file will look like:
+
+```json
+{
+  "crons": [
+    {
+      "path": "/api/payload-jobs/run",
+      "schedule": "*/5 * * * *"
+    }
+  ]
+}
+```
+
+The configuration above schedules the endpoint `/api/payload-jobs/run` to be invoked every 5 minutes.
+
+The last step will be to secure your `run` endpoint so that only the proper users can invoke the runner.
+
+To do this, you can set an environment variable on your Vercel project called `CRON_SECRET`, which should be a random string—ideally 16 characters or longer.
+
+Then, you can modify the `access` function for running jobs by ensuring that only Vercel can invoke your runner.
+
+```ts
+export default buildConfig({
+  // Other configurations...
+  jobs: {
+    access: {
+      run: ({ req }: { req: PayloadRequest }): boolean => {
+        // Allow logged in users to execute this endpoint (default)
+        if (req.user) return true
+
+        // If there is no logged in user, then check
+        // for the Vercel Cron secret to be present as an
+        // Authorization header:
+        const authHeader = req.headers.get('authorization');
+        return authHeader === `Bearer ${process.env.CRON_SECRET}`;
+      },
+    },
+    // Other job configurations...
+  }
+})
+```
+
+This works because Vercel automatically makes the `CRON_SECRET` environment variable available to the endpoint as the `Authorization` header when triggered by the Vercel Cron, ensuring that the jobs can be run securely.
+
+After the project is deployed to Vercel, the Vercel Cron job will automatically trigger the `/api/payload-jobs/run` endpoint in the specified schedule, running the queued jobs in the background.
+
+#### Local API
+
+If you want to process jobs programmatically from your server-side code, you can use the Local API:
+
+```ts
+const results = await payload.jobs.run()
+
+// You can customize the queue name and limit by passing them as arguments:
+await payload.jobs.run({ queue: 'nightly', limit: 100 })
+```
+
+#### Bin script
+
+Finally, you can process jobs via the bin script that comes with Payload out of the box.
+
+```sh
+npx payload jobs:run --queue default --limit 10
+```
+
+In addition, the bin script allows you to pass a `--cron` flag to the `jobs:run` command to run the jobs on a scheduled, cron basis:
+
+```sh
+npx payload jobs:run --cron "*/5 * * * *"
+```

docs/jobs-queue/tasks.mdx

@@ -0,0 +1,141 @@
+---
+title: Tasks
+label: Tasks
+order: 20
+desc: A Task is a distinct function declaration that can be run within Payload's Jobs Queue. 
+keywords: jobs queue, application framework, typescript, node, react, nextjs
+---
+
+<Banner type="default">
+  A <strong>"Task"</strong> is a function definition that performs business logic and whose input and output are both strongly typed.
+</Banner>
+
+You can register Tasks on the Payload config, and then create [Jobs](/docs/beta/jobs-queue/jobs) or [Workflows](/docs/beta/jobs-queue/workflows) that use them. Think of Tasks like tidy, isolated "functions that do one specific thing".
+
+Payload Tasks can be configured to automatically retried if they fail, which makes them valuable for "durable" workflows like AI applications where LLMs can return non-deterministic results, and might need to be retried.
+
+Tasks can either be defined within the `jobs.tasks` array in your payload config, or they can be defined inline within a workflow.
+
+### Defining tasks in the config
+
+Simply add a task to the `jobs.tasks` array in your Payload config. A task consists of the following fields:
+
+| Option                      | Description                                                                      |
+| --------------------------- | -------------------------------------------------------------------------------- |
+| `slug` | Define a slug-based name for this job. This slug needs to be unique among both tasks and workflows.|
+| `handler`   | The function that should be responsible for running the job. You can either pass a string-based path to the job function file, or the job function itself. If you are using large dependencies within your job, you might prefer to pass the string path because that will avoid bundling large dependencies in your Next.js app.         |
+| `inputSchema` | Define the input field schema - payload will generate a type for this schema. |
+| `interfaceName` | You can use interfaceName to change the name of the interface that is generated for this task. By default, this is "Task" + the capitalized task slug. |
+| `outputSchema` | Define the output field schema - payload will generate a type for this schema. |
+| `label` | Define a human-friendly label for this task. |
+| `onFail` | Function to be executed if the task fails. |
+| `onSuccess` | Function to be executed if the task succeeds. |
+| `retries` | Specify the number of times that this step should be retried if it fails. |
+
+The logic for the Task is defined in the `handler` - which can be defined as a function, or a path to a function. The `handler` will run once a worker picks picks up a Job that includes this task.
+
+It should return an object with an `output` key, which should contain the output of the task as you've defined.
+
+Example:
+
+```ts
+export default buildConfig({
+  // ...
+  jobs: {
+    tasks: [
+      {
+        // Configure this task to automatically retry
+        // up to two times
+        retries: 2,
+
+        // This is a unique identifier for the task
+
+        slug: 'createPost',
+
+        // These are the arguments that your Task will accept
+        inputSchema: [
+          {
+            name: 'title',
+            type: 'text',
+            required: true,
+          },
+        ],
+
+        // These are the properties that the function should output
+        outputSchema: [
+          {
+            name: 'postID',
+            type: 'text',
+            required: true,
+          },
+        ],
+
+        // This is the function that is run when the task is invoked
+        handler: async ({ input, job, req }) => {
+          const newPost = await req.payload.create({
+            collection: 'post',
+            req,
+            data: {
+              title: input.title,
+            },
+          })
+          return {
+            output: {
+              postID: newPost.id,
+            },
+          }
+        },
+      } as TaskConfig<'createPost'>,
+    ]
+  }
+})
+```
+
+In addition to defining handlers as functions directly provided to your Payload config, you can also pass an _absolute path_ to where the handler is defined. If your task has large dependencies, and you are planning on executing your jobs in a separate process that has access to the filesystem, this could be a handy way to make sure that your Payload + Next.js app remains quick to compile and has minimal dependencies.
+
+In general, this is an advanced use case. Here's how this would look:
+
+`payload.config.ts:`
+
+```ts
+import { fileURLToPath } from 'node:url'
+import path from 'path'
+
+const filename = fileURLToPath(import.meta.url)
+const dirname = path.dirname(filename)
+
+export default buildConfig({
+  jobs: {
+    tasks: [
+      {
+        // ...
+        // The #createPostHandler is a named export within the `createPost.ts` file
+        handler: path.resolve(dirname, 'src/tasks/createPost.ts') + '#createPostHandler',
+      }
+    ]
+  }
+})
+```
+
+Then, the `createPost` file itself:
+
+`src/tasks/createPost.ts:`
+
+```ts
+import type { TaskHandler } from 'payload'
+
+export const createPostHandler: TaskHandler<'createPost'> = async ({ input, job, req }) => {
+  const newPost = await req.payload.create({
+    collection: 'post',
+    req,
+    data: {
+      title: input.title,
+    },
+  })
+  return {
+    output: {
+      postID: newPost.id,
+    },
+  }
+}
+```

docs/jobs-queue/workflows.mdx

@@ -0,0 +1,150 @@
+---
+title: Workflows
+label: Workflows
+order: 30
+desc: A Task is a distinct function declaration that can be run within Payload's Jobs Queue. 
+keywords: jobs queue, application framework, typescript, node, react, nextjs
+---
+
+<Banner type="default">
+  A <strong>"Workflow"</strong> is an optional way to <em>combine multiple tasks together</em> in a way that can be gracefully retried from the point of failure.
+</Banner>
+
+They're most helpful when you have multiple tasks in a row, and you want to configure each task to be able to be retried if they fail.
+
+If a task within a workflow fails, the Workflow will automatically "pick back up" on the task where it failed and **not re-execute any prior tasks that have already been executed**.
+
+#### Defining a workflow
+
+The most important aspect of a Workflow is the `handler`, where you can declare when and how the tasks should run by simply calling the `runTask` function. If any task within the workflow, fails, the entire `handler` function will re-run.
+
+However, importantly, tasks that have successfully been completed will simply re-return the cached and saved output without running again. The Workflow will pick back up where it failed and only task from the failure point onward will be re-executed.
+
+To define a JS-based workflow, simply add a workflow to the `jobs.wokflows` array in your Payload config. A workflow consists of the following fields:
+
+| Option                      | Description                                                                      |
+| --------------------------- | -------------------------------------------------------------------------------- |
+| `slug` | Define a slug-based name for this workflow. This slug needs to be unique among both tasks and workflows.|
+| `handler`   | The function that should be responsible for running the workflow. You can either pass a string-based path to the workflow function file, or workflow job function itself. If you are using large dependencies within your workflow, you might prefer to pass the string path because that will avoid bundling large dependencies in your Next.js app.         |
+| `inputSchema` | Define the input field schema - payload will generate a type for this schema. |
+| `interfaceName` | You can use interfaceName to change the name of the interface that is generated for this workflow. By default, this is "Workflow" + the capitalized workflow slug. |
+| `label` | Define a human-friendly label for this workflow. |
+| `queue` | Optionally, define the queue name that this workflow should be tied to. Defaults to "default". |
+
+Example:
+
+```ts
+export default buildConfig({
+  // ...
+  jobs: {
+    tasks: [
+      // ...
+    ]
+    workflows: [
+      {
+        slug: 'createPostAndUpdate',
+
+        // The arguments that the workflow will accept
+        inputSchema: [
+          {
+            name: 'title',
+            type: 'text',
+            required: true,
+          },
+        ],
+
+        // The handler that defines the "control flow" of the workflow
+        // Notice how it uses the `tasks` argument to execute your predefined tasks.
+        // These are strongly typed!
+        handler: async ({ job, tasks }) => {
+
+          // This workflow first runs a task called `createPost`.
+
+          // You need to define a unique ID for this task invocation
+          // that will always be the same if this workflow fails
+          // and is re-executed in the future. Here, we hard-code it to '1'
+          const output = await tasks.createPost('1', {
+            input: {
+              title: job.input.title,
+            },
+          })
+
+          // Once the prior task completes, it will run a task
+          // called `updatePost`
+          await tasks.updatePost('2', {
+            input: {
+              post: job.taskStatus.createPost['1'].output.postID, // or output.postID
+              title: job.input.title + '2',
+            },
+          })
+        },
+      } as WorkflowConfig<'updatePost'>
+    ]
+  }
+})
+```
+
+#### Running tasks inline
+
+In the above example, our workflow was executing tasks that we already had defined in our Payload config. But, you can also run tasks without predefining them.
+
+To do this, you can use the `inlineTask` function.
+
+The drawbacks of this approach are that tasks cannot be re-used across workflows as easily, and the **task data stored in the job** will not be typed. In the following example, the inline task data will be stored on the job under `job.taskStatus.inline['2']` but completely untyped, as types for dynamic tasks like these cannot be generated beforehand.
+
+Example:
+
+```ts
+export default buildConfig({
+  // ...
+  jobs: {
+    tasks: [
+      // ...
+    ]
+    workflows: [
+      {
+        slug: 'createPostAndUpdate',
+        inputSchema: [
+          {
+            name: 'title',
+            type: 'text',
+            required: true,
+          },
+        ],
+        handler: async ({ job, tasks, inlineTask }) => {
+          // Here, we run a predefined task.
+          // The `createPost` handler arguments and return type
+          // are both strongly typed
+          const output = await tasks.createPost('1', {
+            input: {
+              title: job.input.title,
+            },
+          })
+
+          // Here, this task is not defined in the Payload config
+          // and is "inline". Its output will be stored on the Job in the database
+          // however its arguments will be untyped.
+          const { newPost } = await inlineTask('2', {
+            task: async ({ req }) => {
+              const newPost = await req.payload.update({
+                collection: 'post',
+                id: '2',
+                req,
+                retries: 3,
+                data: {
+                  title: 'updated!',
+                },
+              })
+              return {
+                output: {
+                  newPost
+                },
+              }
+            },
+          })
+        },
+      } as WorkflowConfig<'updatePost'>
+    ]
+  }
+})
+```

docs/lexical/converters.mdx

@@ -370,7 +370,12 @@ const yourEditorState: SerializedEditorState // <= your current editor state her
 
 // Import editor state into your headless editor
 try {
-  headlessEditor.setEditorState(headlessEditor.parseEditorState(yourEditorState)) // This should commit the editor state immediately
+  headlessEditor.update(
+    () => {
+      headlessEditor.setEditorState(headlessEditor.parseEditorState(yourEditorState))
+    },
+    { discrete: true },  // This should commit the editor state immediately
+  )
 } catch (e) {
   logger.error({ err: e }, 'ERROR parsing editor state')
 }
@@ -382,8 +387,6 @@ headlessEditor.getEditorState().read(() => {
 })
 ```
 
-The `.setEditorState()` function immediately updates your editor state. Thus, there's no need for the `discrete: true` flag when reading the state afterward.
-
 ## Lexical => Plain Text
 
 Export content from the Lexical editor into plain text using these steps:
@@ -401,8 +404,13 @@ const yourEditorState: SerializedEditorState // <= your current editor state her
 
 // Import editor state into your headless editor
 try {
-  headlessEditor.setEditorState(headlessEditor.parseEditorState(yourEditorState)) // This should commit the editor state immediately
-} catch (e) {
+    headlessEditor.update(
+    () => {
+      headlessEditor.setEditorState(headlessEditor.parseEditorState(yourEditorState))
+    },
+    { discrete: true },  // This should commit the editor state immediately
+  )
+  } catch (e) {
   logger.error({ err: e }, 'ERROR parsing editor state')
 }
 

docs/queries/overview.mdx

@@ -151,7 +151,7 @@ With the [REST API](../rest-api/overview), you can use the full power of Payload
 
 To understand the syntax, you need to understand that complex URL search strings are parsed into a JSON object. This one isn't too bad, but more complex queries get unavoidably more difficult to write.
 
-For this reason, we recommend to use the extremely helpful and ubiquitous [`qs`](https://www.npmjs.com/package/qs) package to parse your JSON / object-formatted queries into query strings:
+For this reason, we recommend to use the extremely helpful and ubiquitous [`qs-esm`](https://www.npmjs.com/package/qs-esm) package to parse your JSON / object-formatted queries into query strings:
 
 ```ts
 import { stringify } from 'qs-esm'

docs/queries/select.mdx

@@ -6,11 +6,13 @@ desc: Payload select determines which fields are selected to the result.
 keywords: query, documents, pagination, documentation, Content Management System, cms, headless, javascript, node, react, nextjs
 ---
 
-You may not need the full data from your Local API / REST queries, but only some specific fields. The select fields API can help you to optimize those cases.
+By default, Payload's APIs will return _all fields_ for a given collection or global. But, you may not need all of that data for all of your queries. Sometimes, you might want just a few fields from the response, which can speed up the Payload API and reduce the amount of JSON that is sent to you from the API.
+
+This is where Payload's `select` feature comes in. Here, you can define exactly which fields you'd like to retrieve from the API.
 
 ## Local API
 
-To specify select in the [Local API](../local-api/overview), you can use the `select` option in your query:
+To specify `select` in the [Local API](../local-api/overview), you can use the `select` option in your query:
 
 ```ts
 // Include mode
@@ -51,7 +53,7 @@ const getPosts = async () => {
 
 <Banner type="warning">
   <strong>Important:</strong>
-  To perform querying with `select` efficiently, it works on the database level. Because of that, your `beforeRead` and `afterRead` hooks may not receive the full `doc`.
+  To perform querying with `select` efficiently, Payload implements your `select` query on the database level. Because of that, your `beforeRead` and `afterRead` hooks may not receive the full `doc`.
 </Banner>
 
 
@@ -67,7 +69,7 @@ fetch('https://localhost:3000/api/posts?select[color]=true&select[group][number]
 
 To understand the syntax, you need to understand that complex URL search strings are parsed into a JSON object. This one isn't too bad, but more complex queries get unavoidably more difficult to write.
 
-For this reason, we recommend to use the extremely helpful and ubiquitous [`qs`](https://www.npmjs.com/package/qs) package to parse your JSON / object-formatted queries into query strings:
+For this reason, we recommend to use the extremely helpful and ubiquitous [`qs-esm`](https://www.npmjs.com/package/qs-esm) package to parse your JSON / object-formatted queries into query strings:
 
 ```ts
 import { stringify } from 'qs-esm'
@@ -100,11 +102,17 @@ const getPosts = async () => {
 </Banner>
 
 
-## `defaultPopulate` collection config property
+## defaultPopulate collection config property
 
 The `defaultPopulate` property allows you specify which fields to select when populating the collection from another document.
 This is especially useful for links where only the `slug` is needed instead of the entire document.
 
+With this feature, you can dramatically reduce the amount of JSON that is populated from [Relationship](/docs/beta/fields/relationship) or [Upload](/docs/beta/fields/upload) fields.
+
+For example, in your content model, you might have a `Link` field which links out to a different page. When you go to retrieve these links, you really only need the `slug` of the page. 
+
+Loading all of the page content, its related links, and everything else is going to be overkill and will bog down your Payload APIs. Instead, you can define the `defaultPopulate` property on your `Pages` collection, so that when Payload "populates" a related Page, it only selects the `slug` field and therefore returns significantly less JSON:
+
 ```ts
 import type { CollectionConfig } from 'payload'
 
@@ -129,17 +137,20 @@ export const Pages: CollectionConfig<'pages'> = {
 }
 ```
 
-## `populate`
+## populate
 
-You can override `defaultPopulate` with the `populate` property in the Local and REST API
+Setting `defaultPopulate` will enforce that each time Payload performs a "population" of a related document, only the fields specified will be queried and returned. However, you can override `defaultPopulate` with the `populate` property in the Local and REST API:
+
+**Local API:**
 
-Local API:
 ```ts
 const getPosts = async () => {
   const posts = await payload.find({
     collection: 'posts',
     populate: {
       // Select only `text` from populated docs in the "pages" collection
+      // Now, no matter what the `defaultPopulate` is set to on the "pages" collection,
+      // it will be overridden, and the `text` field will be returned instead.
       pages: {
         text: true,
       }, // highlight-line
@@ -150,7 +161,8 @@ const getPosts = async () => {
 }
 ```
 
-REST API:
+**REST API:**
+
 ```ts
 fetch('https://localhost:3000/api/posts?populate[pages][text]=true') // highlight-line
   .then((res) => res.json())

docs/upload/overview.mdx

@@ -140,6 +140,23 @@ export default buildConfig({
 })
 ```
 
+### Custom filename via hooks
+
+You can customize the filename before it's uploaded to the server by using a `beforeOperation` hook.
+
+```ts
+beforeOperation: [
+  ({ req, operation }) => {
+    if ((operation === 'create' || operation === 'update') && req.file) {
+      req.file.name = 'test.jpg'
+    }
+  },
+],
+```
+
+The `req.file` object will have additional information about the file, such as mimeType and extension, and you also have full access to the file data itself.
+The filename from here will also be threaded to image sizes if they're enabled.
+
 ## Image Sizes
 
 If you specify an array of `imageSizes` to your `upload` config, Payload will automatically crop and resize your uploads to fit each of the sizes specified by your config.

examples/custom-components/src/app/(payload)/layout.tsx

@@ -1,6 +1,6 @@
 /* THIS FILE WAS GENERATED AUTOMATICALLY BY PAYLOAD. */
 /* DO NOT MODIFY IT BECAUSE IT COULD BE REWRITTEN AT ANY TIME. */
-import configPromise from '@payload-config'
+import config from '@payload-config'
 import '@payloadcms/next/css'
 import { RootLayout } from '@payloadcms/next/layouts'
 import React from 'react'
@@ -13,7 +13,7 @@ type Args = {
 }
 
 const Layout = ({ children }: Args) => (
-  <RootLayout config={configPromise} importMap={importMap}>
+  <RootLayout config={config} importMap={importMap}>
     {children}
   </RootLayout>
 )

examples/hierarchy/src/app/(payload)/layout.tsx

@@ -1,8 +1,8 @@
 /* THIS FILE WAS GENERATED AUTOMATICALLY BY PAYLOAD. */
+/* DO NOT MODIFY IT BECAUSE IT COULD BE REWRITTEN AT ANY TIME. */
 import configPromise from '@payload-config'
 import '@payloadcms/next/css'
 import { RootLayout } from '@payloadcms/next/layouts'
-/* DO NOT MODIFY IT BECAUSE IT COULD BE REWRITTEN AT ANY TIME. */
 import React from 'react'
 
 import './custom.scss'

examples/multi-tenant/src/app/(payload)/layout.tsx

@@ -1,6 +1,6 @@
 /* THIS FILE WAS GENERATED AUTOMATICALLY BY PAYLOAD. */
 /* DO NOT MODIFY IT BECAUSE IT COULD BE REWRITTEN AT ANY TIME. */
-import configPromise from '@payload-config'
+import config from '@payload-config'
 import '@payloadcms/next/css'
 import { RootLayout } from '@payloadcms/next/layouts'
 import React from 'react'
@@ -13,7 +13,7 @@ type Args = {
 }
 
 const Layout = ({ children }: Args) => (
-  <RootLayout config={configPromise} importMap={importMap}>
+  <RootLayout config={config} importMap={importMap}>
     {children}
   </RootLayout>
 )

license.md

@@ -1,6 +1,6 @@
-(The MIT License)
+MIT License
 
-Copyright (c) 2018-2022 Payload CMS, LLC <info@payloadcms.com>
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

next.config.mjs

@@ -19,6 +19,11 @@ const config = withBundleAnalyzer(
     typescript: {
       ignoreBuildErrors: true,
     },
+    experimental: {
+      serverActions: {
+        bodySizeLimit: '5mb',
+      },
+    },
     env: {
       PAYLOAD_CORE_DEV: 'true',
       ROOT_DIR: path.resolve(dirname),

package.json

@@ -1,6 +1,6 @@
 {
   "name": "payload-monorepo",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "private": true,
   "type": "module",
   "scripts": {
@@ -58,6 +58,8 @@
     "dev:generate-importmap": "pnpm runts ./test/generateImportMap.ts",
     "dev:generate-types": "pnpm runts ./test/generateTypes.ts",
     "dev:postgres": "cross-env PAYLOAD_DATABASE=postgres pnpm runts ./test/dev.ts",
+    "dev:prod": "cross-env NODE_OPTIONS=--no-deprecation tsx ./test/dev.ts --prod",
+    "dev:prod:memorydb": "cross-env NODE_OPTIONS=--no-deprecation tsx ./test/dev.ts --prod --start-memory-db",
     "dev:vercel-postgres": "cross-env PAYLOAD_DATABASE=vercel-postgres pnpm runts ./test/dev.ts",
     "devsafe": "node ./scripts/delete-recursively.js '**/.next' && pnpm dev",
     "docker:restart": "pnpm docker:stop --remove-orphans && pnpm docker:start",
@@ -65,12 +67,12 @@
     "docker:stop": "docker compose -f packages/plugin-cloud-storage/docker-compose.yml down",
     "force:build": "pnpm run build:core:force",
     "lint": "turbo run lint --concurrency 1 --continue",
-    "lint-staged": "lint-staged",
+    "lint-staged": "node ./scripts/run-lint-staged.js",
     "lint:fix": "turbo run lint:fix --concurrency 1 --continue",
     "obliterate-playwright-cache-macos": "rm -rf ~/Library/Caches/ms-playwright && find /System/Volumes/Data/private/var/folders -type d -name 'playwright*' -exec rm -rf {} +",
     "prepare": "husky",
-    "prepare-run-test-against-prod": "pnpm bf && rm -rf test/packed && rm -rf test/node_modules && rm -f test/pnpm-lock.yaml && pnpm run script:pack --all --no-build --dest test/packed && pnpm runts test/setupProd.ts && cd test && pnpm i --ignore-workspace && cd ..",
-    "prepare-run-test-against-prod:ci": "rm -rf test/node_modules && rm -f test/pnpm-lock.yaml && pnpm run script:pack --all --no-build --dest test/packed && pnpm runts test/setupProd.ts && cd test && pnpm i --ignore-workspace && cd ..",
+    "prepare-run-test-against-prod": "pnpm bf && rm -rf test/packed && rm -rf test/node_modules && rm -rf app && rm -f test/pnpm-lock.yaml && pnpm run script:pack --all --no-build --dest test/packed && pnpm runts test/setupProd.ts && cd test && pnpm i --ignore-workspace && cd ..",
+    "prepare-run-test-against-prod:ci": "rm -rf test/node_modules && rm -rf app && rm -f test/pnpm-lock.yaml && pnpm run script:pack --all --no-build --dest test/packed && pnpm runts test/setupProd.ts && cd test && pnpm i --ignore-workspace && cd ..",
     "reinstall": "pnpm clean:all && pnpm install",
     "release:alpha": "pnpm runts ./scripts/release.ts --bump prerelease --tag alpha",
     "release:beta": "pnpm runts ./scripts/release.ts --bump prerelease --tag beta",

packages/create-payload-app/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/create-payload-app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-payload-app",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "homepage": "https://payloadcms.com",
   "repository": {
     "type": "git",
@@ -8,6 +8,14 @@
     "directory": "packages/create-payload-app"
   },
   "license": "MIT",
+  "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     "./types": {

packages/create-payload-app/src/lib/create-project.ts

@@ -78,15 +78,14 @@ export async function createProject(args: {
     )
     await fse.copy(localTemplate, projectDir)
   } else if ('url' in template) {
-    let templateUrl = template.url
     if (cliArgs['--template-branch']) {
-      templateUrl = `${template.url}#${cliArgs['--template-branch']}`
-      debug(`Using template url: ${templateUrl}`)
+      template.url = `${template.url.split('#')?.[0]}#${cliArgs['--template-branch']}`
     }
+
     await downloadTemplate({
-      name: template.name,
-      branch: 'beta',
+      debug: cliArgs['--debug'],
       projectDir,
+      template,
     })
   }
 

packages/create-payload-app/src/lib/download-template.ts

@@ -2,27 +2,35 @@ import { Readable } from 'node:stream'
 import { pipeline } from 'node:stream/promises'
 import { x } from 'tar'
 
+import type { ProjectTemplate } from '../types.js'
+
+import { debug as debugLog } from '../utils/log.js'
+
 export async function downloadTemplate({
-  name,
-  branch,
+  debug,
   projectDir,
+  template,
 }: {
-  branch: string
-  /**
-   * The name of the template to download
-   * Must be dir /templates/<name>
-   */
-  name: string
+  debug?: boolean
   projectDir: string
+  template: ProjectTemplate
 }) {
-  const url = `https://codeload.github.com/payloadcms/payload/tar.gz/${branch}`
-  const filter = `payload-${branch}/templates/${name}/`
+  const branchOrTag = template.url.split('#')?.[1] || 'beta'
+  const url = `https://codeload.github.com/payloadcms/payload/tar.gz/${branchOrTag}`
+  const filter = `payload-${branchOrTag.replace(/^v/, '')}/templates/${template.name}/`
+
+  if (debug) {
+    debugLog(`Using template url: ${template.url}`)
+    debugLog(`Codeload url: ${url}`)
+    debugLog(`Filter: ${filter}`)
+  }
+
   await pipeline(
     await downloadTarStream(url),
     x({
       cwd: projectDir,
       filter: (p) => p.includes(filter),
-      strip: 2 + name.split('/').length,
+      strip: 2 + template.name.split('/').length,
     }),
   )
 }

packages/create-payload-app/src/lib/init-next.ts

@@ -32,13 +32,13 @@ type InitNextArgs = {
 } & Pick<CliArgs, '--debug'>
 
 type InitNextResult =
+  | { isSrcDir: boolean; nextAppDir?: string; reason: string; success: false }
   | {
       isSrcDir: boolean
       nextAppDir: string
       payloadConfigPath: string
       success: true
     }
-  | { isSrcDir: boolean; nextAppDir?: string; reason: string; success: false }
 
 export async function initNext(args: InitNextArgs): Promise<InitNextResult> {
   const { dbType: dbType, packageManager, projectDir } = args

packages/create-payload-app/src/lib/install-packages.ts

@@ -15,15 +15,9 @@ export async function installPackages(args: {
   let stderr = ''
 
   switch (packageManager) {
-    case 'npm': {
-      ;({ exitCode, stderr } = await execa('npm', ['install', '--save', ...packagesToInstall], {
-        cwd: projectDir,
-      }))
-      break
-    }
-    case 'yarn':
+    case 'bun':
     case 'pnpm':
-    case 'bun': {
+    case 'yarn': {
       if (packageManager === 'bun') {
         warning('Bun support is untested.')
       }
@@ -32,6 +26,12 @@ export async function installPackages(args: {
       }))
       break
     }
+    case 'npm': {
+      ;({ exitCode, stderr } = await execa('npm', ['install', '--save', ...packagesToInstall], {
+        cwd: projectDir,
+      }))
+      break
+    }
   }
 
   if (exitCode !== 0) {

packages/create-payload-app/src/lib/templates.ts

@@ -14,6 +14,7 @@ export function validateTemplate(templateName: string): boolean {
 }
 
 export function getValidTemplates(): ProjectTemplate[] {
+  // Starters _must_ be a valid template name from the templates/ directory
   return [
     {
       name: 'blank',
@@ -28,37 +29,11 @@ export function getValidTemplates(): ProjectTemplate[] {
       url: `https://github.com/payloadcms/payload/templates/website#v${PACKAGE_VERSION}`,
     },
 
-    // Remove these until they have been updated for 3.0
-
-    // {
-    //   name: 'blank',
-    //   type: 'starter',
-    //   description: 'Blank Template',
-    //   url: 'https://github.com/payloadcms/payload/templates/blank',
-    // },
-    // {
-    //   name: 'ecommerce',
-    //   type: 'starter',
-    //   description: 'E-commerce Template',
-    //   url: 'https://github.com/payloadcms/payload/templates/ecommerce',
-    // },
     // {
     //   name: 'plugin',
     //   type: 'plugin',
     //   description: 'Template for creating a Payload plugin',
-    //   url: 'https://github.com/payloadcms/payload-plugin-template#beta',
-    // },
-    // {
-    //   name: 'payload-demo',
-    //   type: 'starter',
-    //   description: 'Payload demo site at https://demo.payloadcms.com',
-    //   url: 'https://github.com/payloadcms/public-demo',
-    // },
-    // {
-    //   name: 'payload-website',
-    //   type: 'starter',
-    //   description: 'Payload website CMS at https://payloadcms.com',
-    //   url: 'https://github.com/payloadcms/website-cms',
+    //   url: 'https://github.com/payloadcms/plugin-template#beta',
     // },
   ]
 }

packages/create-payload-app/src/main.ts

@@ -205,7 +205,7 @@ export class Main {
       }
 
       if (debugFlag) {
-        debug(`Using templates from git tag: ${PACKAGE_VERSION}`)
+        debug(`Using templates from git tag: v${PACKAGE_VERSION}`)
       }
 
       const validTemplates = getValidTemplates()
@@ -217,6 +217,16 @@ export class Main {
       }
 
       switch (template.type) {
+        case 'plugin': {
+          await createProject({
+            cliArgs: this.args,
+            packageManager,
+            projectDir,
+            projectName,
+            template,
+          })
+          break
+        }
         case 'starter': {
           const dbDetails = await selectDb(this.args, projectName)
           const payloadSecret = generateSecret()
@@ -238,16 +248,6 @@ export class Main {
           })
           break
         }
-        case 'plugin': {
-          await createProject({
-            cliArgs: this.args,
-            packageManager,
-            projectDir,
-            projectName,
-            template,
-          })
-          break
-        }
       }
 
       info('Payload project successfully created!')

packages/create-payload-app/src/utils/copy-recursive-sync.ts

@@ -6,13 +6,16 @@ import path from 'path'
  *
  * @internal
  */
-export function copyRecursiveSync(src: string, dest: string) {
+export function copyRecursiveSync(src: string, dest: string, ignoreRegex?: string[]): void {
   const exists = fs.existsSync(src)
   const stats = exists && fs.statSync(src)
   const isDirectory = exists && stats !== false && stats.isDirectory()
   if (isDirectory) {
     fs.mkdirSync(dest, { recursive: true })
     fs.readdirSync(src).forEach((childItemName) => {
+      if (ignoreRegex && ignoreRegex.some((regex) => new RegExp(regex).test(childItemName))) {
+        return
+      }
       copyRecursiveSync(path.join(src, childItemName), path.join(dest, childItemName))
     })
   } else {

packages/db-mongodb/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/db-mongodb/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/db-mongodb",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "description": "The officially supported MongoDB database adapter for Payload",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -10,6 +10,13 @@
   },
   "license": "MIT",
   "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     ".": {

packages/db-mongodb/src/connect.ts

@@ -57,6 +57,21 @@ export const connect: Connect = async function connect(
       }
     }
 
+    if (this.ensureIndexes) {
+      await Promise.all(
+        this.payload.config.collections.map(async (coll) => {
+          await new Promise((resolve, reject) => {
+            this.collections[coll.slug]?.ensureIndexes(function (err) {
+              if (err) {
+                reject(err)
+              }
+              resolve(true)
+            })
+          })
+        }),
+      )
+    }
+
     if (process.env.NODE_ENV === 'production' && this.prodMigrations) {
       await this.migrate({ migrations: this.prodMigrations })
     }

packages/db-mongodb/src/countGlobalVersions.ts

@@ -0,0 +1,48 @@
+import type { QueryOptions } from 'mongoose'
+import type { CountGlobalVersions, PayloadRequest } from 'payload'
+
+import { flattenWhereToOperators } from 'payload'
+
+import type { MongooseAdapter } from './index.js'
+
+import { withSession } from './withSession.js'
+
+export const countGlobalVersions: CountGlobalVersions = async function countGlobalVersions(
+  this: MongooseAdapter,
+  { global, locale, req = {} as PayloadRequest, where },
+) {
+  const Model = this.versions[global]
+  const options: QueryOptions = await withSession(this, req)
+
+  let hasNearConstraint = false
+
+  if (where) {
+    const constraints = flattenWhereToOperators(where)
+    hasNearConstraint = constraints.some((prop) => Object.keys(prop).some((key) => key === 'near'))
+  }
+
+  const query = await Model.buildQuery({
+    locale,
+    payload: this.payload,
+    where,
+  })
+
+  // useEstimatedCount is faster, but not accurate, as it ignores any filters. It is thus set to true if there are no filters.
+  const useEstimatedCount = hasNearConstraint || !query || Object.keys(query).length === 0
+
+  if (!useEstimatedCount && Object.keys(query).length === 0 && this.disableIndexHints !== true) {
+    // Improve the performance of the countDocuments query which is used if useEstimatedCount is set to false by adding
+    // a hint. By default, if no hint is provided, MongoDB does not use an indexed field to count the returned documents,
+    // which makes queries very slow. This only happens when no query (filter) is provided. If one is provided, it uses
+    // the correct indexed field
+    options.hint = {
+      _id: 1,
+    }
+  }
+
+  const result = await Model.countDocuments(query, options)
+
+  return {
+    totalDocs: result,
+  }
+}

packages/db-mongodb/src/countVersions.ts

@@ -0,0 +1,48 @@
+import type { QueryOptions } from 'mongoose'
+import type { CountVersions, PayloadRequest } from 'payload'
+
+import { flattenWhereToOperators } from 'payload'
+
+import type { MongooseAdapter } from './index.js'
+
+import { withSession } from './withSession.js'
+
+export const countVersions: CountVersions = async function countVersions(
+  this: MongooseAdapter,
+  { collection, locale, req = {} as PayloadRequest, where },
+) {
+  const Model = this.versions[collection]
+  const options: QueryOptions = await withSession(this, req)
+
+  let hasNearConstraint = false
+
+  if (where) {
+    const constraints = flattenWhereToOperators(where)
+    hasNearConstraint = constraints.some((prop) => Object.keys(prop).some((key) => key === 'near'))
+  }
+
+  const query = await Model.buildQuery({
+    locale,
+    payload: this.payload,
+    where,
+  })
+
+  // useEstimatedCount is faster, but not accurate, as it ignores any filters. It is thus set to true if there are no filters.
+  const useEstimatedCount = hasNearConstraint || !query || Object.keys(query).length === 0
+
+  if (!useEstimatedCount && Object.keys(query).length === 0 && this.disableIndexHints !== true) {
+    // Improve the performance of the countDocuments query which is used if useEstimatedCount is set to false by adding
+    // a hint. By default, if no hint is provided, MongoDB does not use an indexed field to count the returned documents,
+    // which makes queries very slow. This only happens when no query (filter) is provided. If one is provided, it uses
+    // the correct indexed field
+    options.hint = {
+      _id: 1,
+    }
+  }
+
+  const result = await Model.countDocuments(query, options)
+
+  return {
+    totalDocs: result,
+  }
+}

packages/db-mongodb/src/index.ts

@@ -12,6 +12,8 @@ import type { CollectionModel, GlobalModel, MigrateDownArgs, MigrateUpArgs } fro
 
 import { connect } from './connect.js'
 import { count } from './count.js'
+import { countGlobalVersions } from './countGlobalVersions.js'
+import { countVersions } from './countVersions.js'
 import { create } from './create.js'
 import { createGlobal } from './createGlobal.js'
 import { createGlobalVersion } from './createGlobalVersion.js'
@@ -72,8 +74,14 @@ export interface Args {
     /** Set false to disable $facet aggregation in non-supporting databases, Defaults to true */
     useFacet?: boolean
   } & ConnectOptions
+
   /** Set to true to disable hinting to MongoDB to use 'id' as index. This is currently done when counting documents for pagination. Disabling this optimization might fix some problems with AWS DocumentDB. Defaults to false */
   disableIndexHints?: boolean
+  /**
+   * Set to `true` to ensure that indexes are ready before completing connection.
+   * NOTE: not recommended for production. This can slow down the initialization of Payload.
+   */
+  ensureIndexes?: boolean
   migrationDir?: string
   /**
    * typed as any to avoid dependency
@@ -94,6 +102,7 @@ export type MongooseAdapter = {
     [slug: string]: CollectionModel
   }
   connection: Connection
+  ensureIndexes: boolean
   globals: GlobalModel
   mongoMemoryServer: MongoMemoryReplSet
   prodMigrations?: {
@@ -116,6 +125,7 @@ declare module 'payload' {
       [slug: string]: CollectionModel
     }
     connection: Connection
+    ensureIndexes: boolean
     globals: GlobalModel
     mongoMemoryServer: MongoMemoryReplSet
     prodMigrations?: {
@@ -136,6 +146,7 @@ export function mongooseAdapter({
   autoPluralization = true,
   connectOptions,
   disableIndexHints = false,
+  ensureIndexes,
   migrationDir: migrationDirArg,
   mongoMemoryServer,
   prodMigrations,
@@ -154,8 +165,8 @@ export function mongooseAdapter({
       collections: {},
       connection: undefined,
       connectOptions: connectOptions || {},
-      count,
       disableIndexHints,
+      ensureIndexes,
       globals: undefined,
       mongoMemoryServer,
       sessions: {},
@@ -166,6 +177,9 @@ export function mongooseAdapter({
       beginTransaction: transactionOptions === false ? defaultBeginTransaction() : beginTransaction,
       commitTransaction,
       connect,
+      count,
+      countGlobalVersions,
+      countVersions,
       create,
       createGlobal,
       createGlobalVersion,

packages/db-mongodb/src/init.ts

@@ -45,25 +45,28 @@ export const init: Init = function init(this: MongooseAdapter) {
         versionSchema.plugin(mongooseAggregatePaginate)
       }
 
-      const model = mongoose.model(
+      const versionCollectionName =
+        this.autoPluralization === true && !collection.dbName ? undefined : versionModelName
+
+      this.versions[collection.slug] = mongoose.model(
         versionModelName,
         versionSchema,
-        this.autoPluralization === true ? undefined : versionModelName,
+        versionCollectionName,
       ) as CollectionModel
-
-      this.versions[collection.slug] = model
     }
 
-    const model = mongoose.model(
-      getDBName({ config: collection }),
+    const modelName = getDBName({ config: collection })
+    const collectionName =
+      this.autoPluralization === true && !collection.dbName ? undefined : modelName
+
+    this.collections[collection.slug] = mongoose.model(
+      modelName,
       schema,
-      this.autoPluralization === true ? undefined : collection.slug,
+      collectionName,
     ) as CollectionModel
-    this.collections[collection.slug] = model
   })
 
-  const model = buildGlobalModel(this.payload.config)
-  this.globals = model
+  this.globals = buildGlobalModel(this.payload.config)
 
   this.payload.config.globals.forEach((global) => {
     if (global.versions) {
@@ -85,12 +88,11 @@ export const init: Init = function init(this: MongooseAdapter) {
         .plugin<any, PaginateOptions>(paginate, { useEstimatedCount: true })
         .plugin(getBuildQueryPlugin({ versionsFields: versionGlobalFields }))
 
-      const versionsModel = mongoose.model(
+      this.versions[global.slug] = mongoose.model(
         versionModelName,
         versionSchema,
         versionModelName,
       ) as CollectionModel
-      this.versions[global.slug] = versionsModel
     }
   })
 }

packages/db-mongodb/src/queries/buildSearchParams.ts

@@ -89,11 +89,7 @@ export async function buildSearchParam({
   const [{ field, path }] = paths
 
   if (path) {
-    const {
-      operator: formattedOperator,
-      rawQuery,
-      val: formattedValue,
-    } = sanitizeQueryValue({
+    const sanitizedQueryValue = sanitizeQueryValue({
       field,
       hasCustomID,
       operator,
@@ -101,6 +97,12 @@ export async function buildSearchParam({
       val,
     })
 
+    if (!sanitizedQueryValue) {
+      return undefined
+    }
+
+    const { operator: formattedOperator, rawQuery, val: formattedValue } = sanitizedQueryValue
+
     if (rawQuery) {
       return { value: rawQuery }
     }

packages/db-mongodb/src/utilities/buildJoinAggregation.ts

@@ -1,8 +1,6 @@
 import type { PipelineStage } from 'mongoose'
 import type { CollectionSlug, JoinQuery, SanitizedCollectionConfig, Where } from 'payload'
 
-import { combineQueries } from 'payload'
-
 import type { MongooseAdapter } from '../index.js'
 
 import { buildSortParam } from '../queries/buildSortParam.js'
@@ -60,11 +58,11 @@ export const buildJoinAggregation = async ({
     for (const join of joinConfig[slug]) {
       const joinModel = adapter.collections[join.field.collection]
 
-      if (projection && !projection[join.schemaPath]) {
+      if (projection && !projection[join.joinPath]) {
         continue
       }
 
-      if (joins?.[join.schemaPath] === false) {
+      if (joins?.[join.joinPath] === false) {
         continue
       }
 
@@ -72,7 +70,7 @@ export const buildJoinAggregation = async ({
         limit: limitJoin = join.field.defaultLimit ?? 10,
         sort: sortJoin = join.field.defaultSort || collectionConfig.defaultSort,
         where: whereJoin,
-      } = joins?.[join.schemaPath] || {}
+      } = joins?.[join.joinPath] || {}
 
       const sort = buildSortParam({
         config: adapter.payload.config,
@@ -105,7 +103,7 @@ export const buildJoinAggregation = async ({
 
       if (adapter.payload.config.localization && locale === 'all') {
         adapter.payload.config.localization.localeCodes.forEach((code) => {
-          const as = `${versions ? `version.${join.schemaPath}` : join.schemaPath}${code}`
+          const as = `${versions ? `version.${join.joinPath}` : join.joinPath}${code}`
 
           aggregate.push(
             {
@@ -146,7 +144,7 @@ export const buildJoinAggregation = async ({
       } else {
         const localeSuffix =
           join.field.localized && adapter.payload.config.localization && locale ? `.${locale}` : ''
-        const as = `${versions ? `version.${join.schemaPath}` : join.schemaPath}${localeSuffix}`
+        const as = `${versions ? `version.${join.joinPath}` : join.joinPath}${localeSuffix}`
 
         aggregate.push(
           {

packages/db-mongodb/src/utilities/buildProjectionFromSelect.ts

@@ -104,34 +104,10 @@ const traverseFields = ({
     }
 
     switch (field.type) {
-      case 'collapsible':
-      case 'row':
-        traverseFields({
-          adapter,
-          databaseSchemaPath,
-          fields: field.fields,
-          projection,
-          select,
-          selectMode,
-          withinLocalizedField,
-        })
-        break
-
-      case 'tabs':
-        traverseFields({
-          adapter,
-          databaseSchemaPath,
-          fields: field.tabs.map((tab) => ({ ...tab, type: 'tab' })),
-          projection,
-          select,
-          selectMode,
-          withinLocalizedField,
-        })
-        break
-
+      case 'array':
       case 'group':
-      case 'tab':
-      case 'array': {
+
+      case 'tab': {
         let fieldSelect: SelectType
 
         if (field.type === 'tab' && !tabHasName(field)) {
@@ -206,6 +182,30 @@ const traverseFields = ({
 
         break
       }
+      case 'collapsible':
+      case 'row':
+        traverseFields({
+          adapter,
+          databaseSchemaPath,
+          fields: field.fields,
+          projection,
+          select,
+          selectMode,
+          withinLocalizedField,
+        })
+        break
+
+      case 'tabs':
+        traverseFields({
+          adapter,
+          databaseSchemaPath,
+          fields: field.tabs.map((tab) => ({ ...tab, type: 'tab' })),
+          projection,
+          select,
+          selectMode,
+          withinLocalizedField,
+        })
+        break
 
       default:
         break

packages/db-mongodb/src/utilities/handleError.ts

@@ -19,8 +19,8 @@ export const handleError = ({
         collection,
         errors: [
           {
-            field: Object.keys(error.keyValue)[0],
             message: req.t('error:valueMustBeUnique'),
+            path: Object.keys(error.keyValue)[0],
           },
         ],
         global,

packages/db-postgres/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/db-postgres/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/db-postgres",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "description": "The officially supported Postgres database adapter for Payload",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -10,6 +10,13 @@
   },
   "license": "MIT",
   "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     ".": {

packages/db-postgres/src/index.ts

@@ -4,6 +4,8 @@ import {
   beginTransaction,
   commitTransaction,
   count,
+  countGlobalVersions,
+  countVersions,
   create,
   createGlobal,
   createGlobalVersion,
@@ -33,7 +35,6 @@ import {
   updateVersion,
 } from '@payloadcms/drizzle'
 import {
-  convertPathToJSONTraversal,
   countDistinct,
   createDatabase,
   createExtensions,
@@ -123,9 +124,10 @@ export function postgresAdapter(args: Args): DatabaseAdapterObj<PostgresAdapter>
         args.transactionOptions === false ? defaultBeginTransaction() : beginTransaction,
       commitTransaction,
       connect,
-      convertPathToJSONTraversal,
       count,
       countDistinct,
+      countGlobalVersions,
+      countVersions,
       create,
       createGlobal,
       createGlobalVersion,

packages/db-postgres/src/predefinedMigrations/v2-v3/fetchAndResave/traverseFields.ts

@@ -13,44 +13,6 @@ type Args = {
 export const traverseFields = ({ doc, fields, locale, path, rows }: Args) => {
   fields.forEach((field) => {
     switch (field.type) {
-      case 'group': {
-        const newPath = `${path ? `${path}.` : ''}${field.name}`
-        const newDoc = doc?.[field.name]
-
-        if (typeof newDoc === 'object' && newDoc !== null) {
-          if (field.localized) {
-            Object.entries(newDoc).forEach(([locale, localeDoc]) => {
-              return traverseFields({
-                doc: localeDoc,
-                fields: field.fields,
-                locale,
-                path: newPath,
-                rows,
-              })
-            })
-          } else {
-            return traverseFields({
-              doc: newDoc as Record<string, unknown>,
-              fields: field.fields,
-              path: newPath,
-              rows,
-            })
-          }
-        }
-
-        break
-      }
-
-      case 'row':
-      case 'collapsible': {
-        return traverseFields({
-          doc,
-          fields: field.fields,
-          path,
-          rows,
-        })
-      }
-
       case 'array': {
         const rowData = doc?.[field.name]
 
@@ -124,45 +86,47 @@ export const traverseFields = ({ doc, fields, locale, path, rows }: Args) => {
 
         break
       }
-
-      case 'tabs': {
-        return field.tabs.forEach((tab) => {
-          if (tabHasName(tab)) {
-            const newDoc = doc?.[tab.name]
-            const newPath = `${path ? `${path}.` : ''}${tab.name}`
-
-            if (typeof newDoc === 'object' && newDoc !== null) {
-              if (tab.localized) {
-                Object.entries(newDoc).forEach(([locale, localeDoc]) => {
-                  return traverseFields({
-                    doc: localeDoc,
-                    fields: tab.fields,
-                    locale,
-                    path: newPath,
-                    rows,
-                  })
-                })
-              } else {
-                return traverseFields({
-                  doc: newDoc as Record<string, unknown>,
-                  fields: tab.fields,
-                  path: newPath,
-                  rows,
-                })
-              }
-            }
-          } else {
-            traverseFields({
-              doc,
-              fields: tab.fields,
-              path,
-              rows,
-            })
-          }
+      case 'collapsible':
+      // falls through
+      case 'row': {
+        return traverseFields({
+          doc,
+          fields: field.fields,
+          path,
+          rows,
         })
       }
 
+      case 'group': {
+        const newPath = `${path ? `${path}.` : ''}${field.name}`
+        const newDoc = doc?.[field.name]
+
+        if (typeof newDoc === 'object' && newDoc !== null) {
+          if (field.localized) {
+            Object.entries(newDoc).forEach(([locale, localeDoc]) => {
+              return traverseFields({
+                doc: localeDoc,
+                fields: field.fields,
+                locale,
+                path: newPath,
+                rows,
+              })
+            })
+          } else {
+            return traverseFields({
+              doc: newDoc as Record<string, unknown>,
+              fields: field.fields,
+              path: newPath,
+              rows,
+            })
+          }
+        }
+
+        break
+      }
+
       case 'relationship':
+      // falls through
       case 'upload': {
         if (typeof field.relationTo === 'string') {
           if (field.type === 'upload' || !field.hasMany) {
@@ -211,6 +175,43 @@ export const traverseFields = ({ doc, fields, locale, path, rows }: Args) => {
             }
           }
         }
+        break
+      }
+      case 'tabs': {
+        return field.tabs.forEach((tab) => {
+          if (tabHasName(tab)) {
+            const newDoc = doc?.[tab.name]
+            const newPath = `${path ? `${path}.` : ''}${tab.name}`
+
+            if (typeof newDoc === 'object' && newDoc !== null) {
+              if (tab.localized) {
+                Object.entries(newDoc).forEach(([locale, localeDoc]) => {
+                  return traverseFields({
+                    doc: localeDoc,
+                    fields: tab.fields,
+                    locale,
+                    path: newPath,
+                    rows,
+                  })
+                })
+              } else {
+                return traverseFields({
+                  doc: newDoc as Record<string, unknown>,
+                  fields: tab.fields,
+                  path: newPath,
+                  rows,
+                })
+              }
+            }
+          } else {
+            traverseFields({
+              doc,
+              fields: tab.fields,
+              path,
+              rows,
+            })
+          }
+        })
       }
     }
   })

packages/db-postgres/src/predefinedMigrations/v2-v3/traverseFields.ts

@@ -27,30 +27,6 @@ type Args = {
 export const traverseFields = (args: Args) => {
   args.fields.forEach((field) => {
     switch (field.type) {
-      case 'group': {
-        let newTableName = `${args.newTableName}_${toSnakeCase(field.name)}`
-
-        if (field.localized && args.payload.config.localization) {
-          newTableName += args.adapter.localesSuffix
-        }
-
-        return traverseFields({
-          ...args,
-          columnPrefix: `${args.columnPrefix}${toSnakeCase(field.name)}_`,
-          fields: field.fields,
-          newTableName,
-          path: `${args.path ? `${args.path}.` : ''}${field.name}`,
-        })
-      }
-
-      case 'row':
-      case 'collapsible': {
-        return traverseFields({
-          ...args,
-          fields: field.fields,
-        })
-      }
-
       case 'array': {
         const newTableName = args.adapter.tableNameMap.get(
           `${args.newTableName}_${toSnakeCase(field.name)}`,
@@ -82,7 +58,42 @@ export const traverseFields = (args: Args) => {
           })
         })
       }
+      case 'collapsible':
 
+      case 'row': {
+        return traverseFields({
+          ...args,
+          fields: field.fields,
+        })
+      }
+
+      case 'group': {
+        let newTableName = `${args.newTableName}_${toSnakeCase(field.name)}`
+
+        if (field.localized && args.payload.config.localization) {
+          newTableName += args.adapter.localesSuffix
+        }
+
+        return traverseFields({
+          ...args,
+          columnPrefix: `${args.columnPrefix}${toSnakeCase(field.name)}_`,
+          fields: field.fields,
+          newTableName,
+          path: `${args.path ? `${args.path}.` : ''}${field.name}`,
+        })
+      }
+
+      case 'relationship':
+
+      case 'upload': {
+        if (typeof field.relationTo === 'string') {
+          if (field.type === 'upload' || !field.hasMany) {
+            args.pathsToQuery.add(`${args.path ? `${args.path}.` : ''}${field.name}`)
+          }
+        }
+
+        return null
+      }
       case 'tabs': {
         return field.tabs.forEach((tab) => {
           if (tabHasName(tab)) {
@@ -101,17 +112,6 @@ export const traverseFields = (args: Args) => {
           })
         })
       }
-
-      case 'relationship':
-      case 'upload': {
-        if (typeof field.relationTo === 'string') {
-          if (field.type === 'upload' || !field.hasMany) {
-            args.pathsToQuery.add(`${args.path ? `${args.path}.` : ''}${field.name}`)
-          }
-        }
-
-        return null
-      }
     }
   })
 }

packages/db-sqlite/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/db-sqlite/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/db-sqlite",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "description": "The officially supported SQLite database adapter for Payload",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -10,6 +10,13 @@
   },
   "license": "MIT",
   "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     ".": {

packages/db-sqlite/src/index.ts

@@ -5,6 +5,8 @@ import {
   beginTransaction,
   commitTransaction,
   count,
+  countGlobalVersions,
+  countVersions,
   create,
   createGlobal,
   createGlobalVersion,
@@ -114,6 +116,8 @@ export function sqliteAdapter(args: Args): DatabaseAdapterObj<SQLiteAdapter> {
       convertPathToJSONTraversal,
       count,
       countDistinct,
+      countGlobalVersions,
+      countVersions,
       create,
       createGlobal,
       createGlobalVersion,

packages/db-sqlite/src/schema/traverseFields.ts

@@ -179,183 +179,6 @@ export const traverseFields = ({
     }
 
     switch (field.type) {
-      case 'text': {
-        if (field.hasMany) {
-          const isLocalized =
-            Boolean(field.localized && adapter.payload.config.localization) ||
-            withinLocalizedArrayOrBlock ||
-            forceLocalized
-
-          if (isLocalized) {
-            hasLocalizedManyTextField = true
-          }
-
-          if (field.index) {
-            hasManyTextField = 'index'
-          } else if (!hasManyTextField) {
-            hasManyTextField = true
-          }
-
-          if (field.unique) {
-            throw new InvalidConfiguration(
-              'Unique is not supported in SQLite for hasMany text fields.',
-            )
-          }
-        } else {
-          targetTable[fieldName] = withDefault(text(columnName), field)
-        }
-        break
-      }
-      case 'email':
-      case 'code':
-      case 'textarea': {
-        targetTable[fieldName] = withDefault(text(columnName), field)
-        break
-      }
-
-      case 'number': {
-        if (field.hasMany) {
-          const isLocalized =
-            Boolean(field.localized && adapter.payload.config.localization) ||
-            withinLocalizedArrayOrBlock ||
-            forceLocalized
-
-          if (isLocalized) {
-            hasLocalizedManyNumberField = true
-          }
-
-          if (field.index) {
-            hasManyNumberField = 'index'
-          } else if (!hasManyNumberField) {
-            hasManyNumberField = true
-          }
-
-          if (field.unique) {
-            throw new InvalidConfiguration(
-              'Unique is not supported in Postgres for hasMany number fields.',
-            )
-          }
-        } else {
-          targetTable[fieldName] = withDefault(numeric(columnName), field)
-        }
-        break
-      }
-
-      case 'richText':
-      case 'json': {
-        targetTable[fieldName] = withDefault(text(columnName, { mode: 'json' }), field)
-        break
-      }
-
-      case 'date': {
-        targetTable[fieldName] = withDefault(text(columnName), field)
-        break
-      }
-
-      case 'point': {
-        break
-      }
-
-      case 'radio':
-      case 'select': {
-        const options = field.options.map((option) => {
-          if (optionIsObject(option)) {
-            return option.value
-          }
-
-          return option
-        }) as [string, ...string[]]
-
-        if (field.type === 'select' && field.hasMany) {
-          const selectTableName = createTableName({
-            adapter,
-            config: field,
-            parentTableName: newTableName,
-            prefix: `${newTableName}_`,
-            versionsCustomName: versions,
-          })
-          const baseColumns: Record<string, SQLiteColumnBuilder> = {
-            order: integer('order').notNull(),
-            parent: getIDColumn({
-              name: 'parent_id',
-              type: parentIDColType,
-              notNull: true,
-              primaryKey: false,
-            }),
-            value: text('value', { enum: options }),
-          }
-
-          const baseExtraConfig: BaseExtraConfig = {
-            orderIdx: (cols) => index(`${selectTableName}_order_idx`).on(cols.order),
-            parentFk: (cols) =>
-              foreignKey({
-                name: `${selectTableName}_parent_fk`,
-                columns: [cols.parent],
-                foreignColumns: [adapter.tables[parentTableName].id],
-              }).onDelete('cascade'),
-            parentIdx: (cols) => index(`${selectTableName}_parent_idx`).on(cols.parent),
-          }
-
-          const isLocalized =
-            Boolean(field.localized && adapter.payload.config.localization) ||
-            withinLocalizedArrayOrBlock ||
-            forceLocalized
-
-          if (isLocalized) {
-            baseColumns.locale = text('locale', { enum: locales }).notNull()
-            baseExtraConfig.localeIdx = (cols) =>
-              index(`${selectTableName}_locale_idx`).on(cols.locale)
-          }
-
-          if (field.index) {
-            baseExtraConfig.value = (cols) => index(`${selectTableName}_value_idx`).on(cols.value)
-          }
-
-          buildTable({
-            adapter,
-            baseColumns,
-            baseExtraConfig,
-            disableNotNull,
-            disableUnique,
-            fields: [],
-            rootTableName,
-            tableName: selectTableName,
-            versions,
-          })
-
-          relationsToBuild.set(fieldName, {
-            type: 'many',
-            // selects have their own localized table, independent of the base table.
-            localized: false,
-            target: selectTableName,
-          })
-
-          adapter.relations[`relations_${selectTableName}`] = relations(
-            adapter.tables[selectTableName],
-            ({ one }) => ({
-              parent: one(adapter.tables[parentTableName], {
-                fields: [adapter.tables[selectTableName].parent],
-                references: [adapter.tables[parentTableName].id],
-                relationName: fieldName,
-              }),
-            }),
-          )
-        } else {
-          targetTable[fieldName] = withDefault(
-            text(columnName, {
-              enum: options,
-            }),
-            field,
-          )
-        }
-        break
-      }
-
-      case 'checkbox': {
-        targetTable[fieldName] = withDefault(integer(columnName, { mode: 'boolean' }), field)
-        break
-      }
-
       case 'array': {
         const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull
 
@@ -493,7 +316,6 @@ export const traverseFields = ({
 
         break
       }
-
       case 'blocks': {
         const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull
 
@@ -646,9 +468,82 @@ export const traverseFields = ({
 
         break
       }
+      case 'checkbox': {
+        targetTable[fieldName] = withDefault(integer(columnName, { mode: 'boolean' }), field)
+        break
+      }
+      case 'code':
 
-      case 'tab':
-      case 'group': {
+      case 'email':
+
+      case 'textarea': {
+        targetTable[fieldName] = withDefault(text(columnName), field)
+        break
+      }
+      case 'collapsible':
+
+      case 'row': {
+        const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull
+        const {
+          hasLocalizedField: rowHasLocalizedField,
+          hasLocalizedManyNumberField: rowHasLocalizedManyNumberField,
+          hasLocalizedManyTextField: rowHasLocalizedManyTextField,
+          hasLocalizedRelationshipField: rowHasLocalizedRelationshipField,
+          hasManyNumberField: rowHasManyNumberField,
+          hasManyTextField: rowHasManyTextField,
+        } = traverseFields({
+          adapter,
+          columnPrefix,
+          columns,
+          disableNotNull: disableNotNullFromHere,
+          disableUnique,
+          fieldPrefix,
+          fields: field.fields,
+          forceLocalized,
+          indexes,
+          locales,
+          localesColumns,
+          localesIndexes,
+          newTableName,
+          parentTableName,
+          relationships,
+          relationsToBuild,
+          rootRelationsToBuild,
+          rootTableIDColType,
+          rootTableName,
+          uniqueRelationships,
+          versions,
+          withinLocalizedArrayOrBlock,
+        })
+
+        if (rowHasLocalizedField) {
+          hasLocalizedField = true
+        }
+        if (rowHasLocalizedRelationshipField) {
+          hasLocalizedRelationshipField = true
+        }
+        if (rowHasManyTextField) {
+          hasManyTextField = true
+        }
+        if (rowHasLocalizedManyTextField) {
+          hasLocalizedManyTextField = true
+        }
+        if (rowHasManyNumberField) {
+          hasManyNumberField = true
+        }
+        if (rowHasLocalizedManyNumberField) {
+          hasLocalizedManyNumberField = true
+        }
+        break
+      }
+
+      case 'date': {
+        targetTable[fieldName] = withDefault(text(columnName), field)
+        break
+      }
+
+      case 'group':
+      case 'tab': {
         if (!('name' in field)) {
           const {
             hasLocalizedField: groupHasLocalizedField,
@@ -758,114 +653,136 @@ export const traverseFields = ({
         break
       }
 
-      case 'tabs': {
-        const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull
+      case 'json':
 
-        const {
-          hasLocalizedField: tabHasLocalizedField,
-          hasLocalizedManyNumberField: tabHasLocalizedManyNumberField,
-          hasLocalizedManyTextField: tabHasLocalizedManyTextField,
-          hasLocalizedRelationshipField: tabHasLocalizedRelationshipField,
-          hasManyNumberField: tabHasManyNumberField,
-          hasManyTextField: tabHasManyTextField,
-        } = traverseFields({
-          adapter,
-          columnPrefix,
-          columns,
-          disableNotNull: disableNotNullFromHere,
-          disableUnique,
-          fieldPrefix,
-          fields: field.tabs.map((tab) => ({ ...tab, type: 'tab' })),
-          forceLocalized,
-          indexes,
-          locales,
-          localesColumns,
-          localesIndexes,
-          newTableName,
-          parentTableName,
-          relationships,
-          relationsToBuild,
-          rootRelationsToBuild,
-          rootTableIDColType,
-          rootTableName,
-          uniqueRelationships,
-          versions,
-          withinLocalizedArrayOrBlock,
-        })
+      case 'richText': {
+        targetTable[fieldName] = withDefault(text(columnName, { mode: 'json' }), field)
+        break
+      }
 
-        if (tabHasLocalizedField) {
-          hasLocalizedField = true
-        }
-        if (tabHasLocalizedRelationshipField) {
-          hasLocalizedRelationshipField = true
-        }
-        if (tabHasManyTextField) {
-          hasManyTextField = true
-        }
-        if (tabHasLocalizedManyTextField) {
-          hasLocalizedManyTextField = true
-        }
-        if (tabHasManyNumberField) {
-          hasManyNumberField = true
-        }
-        if (tabHasLocalizedManyNumberField) {
-          hasLocalizedManyNumberField = true
+      case 'number': {
+        if (field.hasMany) {
+          const isLocalized =
+            Boolean(field.localized && adapter.payload.config.localization) ||
+            withinLocalizedArrayOrBlock ||
+            forceLocalized
+
+          if (isLocalized) {
+            hasLocalizedManyNumberField = true
+          }
+
+          if (field.index) {
+            hasManyNumberField = 'index'
+          } else if (!hasManyNumberField) {
+            hasManyNumberField = true
+          }
+
+          if (field.unique) {
+            throw new InvalidConfiguration(
+              'Unique is not supported in Postgres for hasMany number fields.',
+            )
+          }
+        } else {
+          targetTable[fieldName] = withDefault(numeric(columnName), field)
         }
         break
       }
 
-      case 'row':
-      case 'collapsible': {
-        const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull
-        const {
-          hasLocalizedField: rowHasLocalizedField,
-          hasLocalizedManyNumberField: rowHasLocalizedManyNumberField,
-          hasLocalizedManyTextField: rowHasLocalizedManyTextField,
-          hasLocalizedRelationshipField: rowHasLocalizedRelationshipField,
-          hasManyNumberField: rowHasManyNumberField,
-          hasManyTextField: rowHasManyTextField,
-        } = traverseFields({
-          adapter,
-          columnPrefix,
-          columns,
-          disableNotNull: disableNotNullFromHere,
-          disableUnique,
-          fieldPrefix,
-          fields: field.fields,
-          forceLocalized,
-          indexes,
-          locales,
-          localesColumns,
-          localesIndexes,
-          newTableName,
-          parentTableName,
-          relationships,
-          relationsToBuild,
-          rootRelationsToBuild,
-          rootTableIDColType,
-          rootTableName,
-          uniqueRelationships,
-          versions,
-          withinLocalizedArrayOrBlock,
-        })
+      case 'point': {
+        break
+      }
+      case 'radio':
 
-        if (rowHasLocalizedField) {
-          hasLocalizedField = true
-        }
-        if (rowHasLocalizedRelationshipField) {
-          hasLocalizedRelationshipField = true
-        }
-        if (rowHasManyTextField) {
-          hasManyTextField = true
-        }
-        if (rowHasLocalizedManyTextField) {
-          hasLocalizedManyTextField = true
-        }
-        if (rowHasManyNumberField) {
-          hasManyNumberField = true
-        }
-        if (rowHasLocalizedManyNumberField) {
-          hasLocalizedManyNumberField = true
+      case 'select': {
+        const options = field.options.map((option) => {
+          if (optionIsObject(option)) {
+            return option.value
+          }
+
+          return option
+        }) as [string, ...string[]]
+
+        if (field.type === 'select' && field.hasMany) {
+          const selectTableName = createTableName({
+            adapter,
+            config: field,
+            parentTableName: newTableName,
+            prefix: `${newTableName}_`,
+            versionsCustomName: versions,
+          })
+          const baseColumns: Record<string, SQLiteColumnBuilder> = {
+            order: integer('order').notNull(),
+            parent: getIDColumn({
+              name: 'parent_id',
+              type: parentIDColType,
+              notNull: true,
+              primaryKey: false,
+            }),
+            value: text('value', { enum: options }),
+          }
+
+          const baseExtraConfig: BaseExtraConfig = {
+            orderIdx: (cols) => index(`${selectTableName}_order_idx`).on(cols.order),
+            parentFk: (cols) =>
+              foreignKey({
+                name: `${selectTableName}_parent_fk`,
+                columns: [cols.parent],
+                foreignColumns: [adapter.tables[parentTableName].id],
+              }).onDelete('cascade'),
+            parentIdx: (cols) => index(`${selectTableName}_parent_idx`).on(cols.parent),
+          }
+
+          const isLocalized =
+            Boolean(field.localized && adapter.payload.config.localization) ||
+            withinLocalizedArrayOrBlock ||
+            forceLocalized
+
+          if (isLocalized) {
+            baseColumns.locale = text('locale', { enum: locales }).notNull()
+            baseExtraConfig.localeIdx = (cols) =>
+              index(`${selectTableName}_locale_idx`).on(cols.locale)
+          }
+
+          if (field.index) {
+            baseExtraConfig.value = (cols) => index(`${selectTableName}_value_idx`).on(cols.value)
+          }
+
+          buildTable({
+            adapter,
+            baseColumns,
+            baseExtraConfig,
+            disableNotNull,
+            disableUnique,
+            fields: [],
+            rootTableName,
+            tableName: selectTableName,
+            versions,
+          })
+
+          relationsToBuild.set(fieldName, {
+            type: 'many',
+            // selects have their own localized table, independent of the base table.
+            localized: false,
+            target: selectTableName,
+          })
+
+          adapter.relations[`relations_${selectTableName}`] = relations(
+            adapter.tables[selectTableName],
+            ({ one }) => ({
+              parent: one(adapter.tables[parentTableName], {
+                fields: [adapter.tables[selectTableName].parent],
+                references: [adapter.tables[parentTableName].id],
+                relationName: fieldName,
+              }),
+            }),
+          )
+        } else {
+          targetTable[fieldName] = withDefault(
+            text(columnName, {
+              enum: options,
+            }),
+            field,
+          )
         }
         break
       }
@@ -931,6 +848,89 @@ export const traverseFields = ({
 
         break
 
+      case 'tabs': {
+        const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull
+
+        const {
+          hasLocalizedField: tabHasLocalizedField,
+          hasLocalizedManyNumberField: tabHasLocalizedManyNumberField,
+          hasLocalizedManyTextField: tabHasLocalizedManyTextField,
+          hasLocalizedRelationshipField: tabHasLocalizedRelationshipField,
+          hasManyNumberField: tabHasManyNumberField,
+          hasManyTextField: tabHasManyTextField,
+        } = traverseFields({
+          adapter,
+          columnPrefix,
+          columns,
+          disableNotNull: disableNotNullFromHere,
+          disableUnique,
+          fieldPrefix,
+          fields: field.tabs.map((tab) => ({ ...tab, type: 'tab' })),
+          forceLocalized,
+          indexes,
+          locales,
+          localesColumns,
+          localesIndexes,
+          newTableName,
+          parentTableName,
+          relationships,
+          relationsToBuild,
+          rootRelationsToBuild,
+          rootTableIDColType,
+          rootTableName,
+          uniqueRelationships,
+          versions,
+          withinLocalizedArrayOrBlock,
+        })
+
+        if (tabHasLocalizedField) {
+          hasLocalizedField = true
+        }
+        if (tabHasLocalizedRelationshipField) {
+          hasLocalizedRelationshipField = true
+        }
+        if (tabHasManyTextField) {
+          hasManyTextField = true
+        }
+        if (tabHasLocalizedManyTextField) {
+          hasLocalizedManyTextField = true
+        }
+        if (tabHasManyNumberField) {
+          hasManyNumberField = true
+        }
+        if (tabHasLocalizedManyNumberField) {
+          hasLocalizedManyNumberField = true
+        }
+        break
+      }
+      case 'text': {
+        if (field.hasMany) {
+          const isLocalized =
+            Boolean(field.localized && adapter.payload.config.localization) ||
+            withinLocalizedArrayOrBlock ||
+            forceLocalized
+
+          if (isLocalized) {
+            hasLocalizedManyTextField = true
+          }
+
+          if (field.index) {
+            hasManyTextField = 'index'
+          } else if (!hasManyTextField) {
+            hasManyTextField = true
+          }
+
+          if (field.unique) {
+            throw new InvalidConfiguration(
+              'Unique is not supported in SQLite for hasMany text fields.',
+            )
+          }
+        } else {
+          targetTable[fieldName] = withDefault(text(columnName), field)
+        }
+        break
+      }
+
       default:
         break
     }

packages/db-vercel-postgres/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/db-vercel-postgres/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/db-vercel-postgres",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "description": "Vercel Postgres adapter for Payload",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -10,6 +10,13 @@
   },
   "license": "MIT",
   "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     ".": {

packages/db-vercel-postgres/src/index.ts

@@ -4,6 +4,8 @@ import {
   beginTransaction,
   commitTransaction,
   count,
+  countGlobalVersions,
+  countVersions,
   create,
   createGlobal,
   createGlobalVersion,
@@ -33,7 +35,6 @@ import {
   updateVersion,
 } from '@payloadcms/drizzle'
 import {
-  convertPathToJSONTraversal,
   countDistinct,
   createDatabase,
   createExtensions,
@@ -124,9 +125,10 @@ export function vercelPostgresAdapter(args: Args = {}): DatabaseAdapterObj<Verce
         args.transactionOptions === false ? defaultBeginTransaction() : beginTransaction,
       commitTransaction,
       connect,
-      convertPathToJSONTraversal,
       count,
       countDistinct,
+      countGlobalVersions,
+      countVersions,
       create,
       createGlobal,
       createGlobalVersion,

packages/db-vercel-postgres/src/predefinedMigrations/v2-v3/fetchAndResave/traverseFields.ts

@@ -13,44 +13,6 @@ type Args = {
 export const traverseFields = ({ doc, fields, locale, path, rows }: Args) => {
   fields.forEach((field) => {
     switch (field.type) {
-      case 'group': {
-        const newPath = `${path ? `${path}.` : ''}${field.name}`
-        const newDoc = doc?.[field.name]
-
-        if (typeof newDoc === 'object' && newDoc !== null) {
-          if (field.localized) {
-            Object.entries(newDoc).forEach(([locale, localeDoc]) => {
-              return traverseFields({
-                doc: localeDoc,
-                fields: field.fields,
-                locale,
-                path: newPath,
-                rows,
-              })
-            })
-          } else {
-            return traverseFields({
-              doc: newDoc as Record<string, unknown>,
-              fields: field.fields,
-              path: newPath,
-              rows,
-            })
-          }
-        }
-
-        break
-      }
-
-      case 'row':
-      case 'collapsible': {
-        return traverseFields({
-          doc,
-          fields: field.fields,
-          path,
-          rows,
-        })
-      }
-
       case 'array': {
         const rowData = doc?.[field.name]
 
@@ -124,45 +86,47 @@ export const traverseFields = ({ doc, fields, locale, path, rows }: Args) => {
 
         break
       }
-
-      case 'tabs': {
-        return field.tabs.forEach((tab) => {
-          if (tabHasName(tab)) {
-            const newDoc = doc?.[tab.name]
-            const newPath = `${path ? `${path}.` : ''}${tab.name}`
-
-            if (typeof newDoc === 'object' && newDoc !== null) {
-              if (tab.localized) {
-                Object.entries(newDoc).forEach(([locale, localeDoc]) => {
-                  return traverseFields({
-                    doc: localeDoc,
-                    fields: tab.fields,
-                    locale,
-                    path: newPath,
-                    rows,
-                  })
-                })
-              } else {
-                return traverseFields({
-                  doc: newDoc as Record<string, unknown>,
-                  fields: tab.fields,
-                  path: newPath,
-                  rows,
-                })
-              }
-            }
-          } else {
-            traverseFields({
-              doc,
-              fields: tab.fields,
-              path,
-              rows,
-            })
-          }
+      case 'collapsible':
+      // falls through
+      case 'row': {
+        return traverseFields({
+          doc,
+          fields: field.fields,
+          path,
+          rows,
         })
       }
 
+      case 'group': {
+        const newPath = `${path ? `${path}.` : ''}${field.name}`
+        const newDoc = doc?.[field.name]
+
+        if (typeof newDoc === 'object' && newDoc !== null) {
+          if (field.localized) {
+            Object.entries(newDoc).forEach(([locale, localeDoc]) => {
+              return traverseFields({
+                doc: localeDoc,
+                fields: field.fields,
+                locale,
+                path: newPath,
+                rows,
+              })
+            })
+          } else {
+            return traverseFields({
+              doc: newDoc as Record<string, unknown>,
+              fields: field.fields,
+              path: newPath,
+              rows,
+            })
+          }
+        }
+
+        break
+      }
+
       case 'relationship':
+      // falls through
       case 'upload': {
         if (typeof field.relationTo === 'string') {
           if (field.type === 'upload' || !field.hasMany) {
@@ -211,6 +175,43 @@ export const traverseFields = ({ doc, fields, locale, path, rows }: Args) => {
             }
           }
         }
+        break
+      }
+      case 'tabs': {
+        return field.tabs.forEach((tab) => {
+          if (tabHasName(tab)) {
+            const newDoc = doc?.[tab.name]
+            const newPath = `${path ? `${path}.` : ''}${tab.name}`
+
+            if (typeof newDoc === 'object' && newDoc !== null) {
+              if (tab.localized) {
+                Object.entries(newDoc).forEach(([locale, localeDoc]) => {
+                  return traverseFields({
+                    doc: localeDoc,
+                    fields: tab.fields,
+                    locale,
+                    path: newPath,
+                    rows,
+                  })
+                })
+              } else {
+                return traverseFields({
+                  doc: newDoc as Record<string, unknown>,
+                  fields: tab.fields,
+                  path: newPath,
+                  rows,
+                })
+              }
+            }
+          } else {
+            traverseFields({
+              doc,
+              fields: tab.fields,
+              path,
+              rows,
+            })
+          }
+        })
       }
     }
   })

packages/db-vercel-postgres/src/predefinedMigrations/v2-v3/traverseFields.ts

@@ -27,30 +27,6 @@ type Args = {
 export const traverseFields = (args: Args) => {
   args.fields.forEach((field) => {
     switch (field.type) {
-      case 'group': {
-        let newTableName = `${args.newTableName}_${toSnakeCase(field.name)}`
-
-        if (field.localized && args.payload.config.localization) {
-          newTableName += args.adapter.localesSuffix
-        }
-
-        return traverseFields({
-          ...args,
-          columnPrefix: `${args.columnPrefix}${toSnakeCase(field.name)}_`,
-          fields: field.fields,
-          newTableName,
-          path: `${args.path ? `${args.path}.` : ''}${field.name}`,
-        })
-      }
-
-      case 'row':
-      case 'collapsible': {
-        return traverseFields({
-          ...args,
-          fields: field.fields,
-        })
-      }
-
       case 'array': {
         const newTableName = args.adapter.tableNameMap.get(
           `${args.newTableName}_${toSnakeCase(field.name)}`,
@@ -82,7 +58,42 @@ export const traverseFields = (args: Args) => {
           })
         })
       }
+      case 'collapsible':
 
+      case 'row': {
+        return traverseFields({
+          ...args,
+          fields: field.fields,
+        })
+      }
+
+      case 'group': {
+        let newTableName = `${args.newTableName}_${toSnakeCase(field.name)}`
+
+        if (field.localized && args.payload.config.localization) {
+          newTableName += args.adapter.localesSuffix
+        }
+
+        return traverseFields({
+          ...args,
+          columnPrefix: `${args.columnPrefix}${toSnakeCase(field.name)}_`,
+          fields: field.fields,
+          newTableName,
+          path: `${args.path ? `${args.path}.` : ''}${field.name}`,
+        })
+      }
+
+      case 'relationship':
+
+      case 'upload': {
+        if (typeof field.relationTo === 'string') {
+          if (field.type === 'upload' || !field.hasMany) {
+            args.pathsToQuery.add(`${args.path ? `${args.path}.` : ''}${field.name}`)
+          }
+        }
+
+        return null
+      }
       case 'tabs': {
         return field.tabs.forEach((tab) => {
           if (tabHasName(tab)) {
@@ -101,17 +112,6 @@ export const traverseFields = (args: Args) => {
           })
         })
       }
-
-      case 'relationship':
-      case 'upload': {
-        if (typeof field.relationTo === 'string') {
-          if (field.type === 'upload' || !field.hasMany) {
-            args.pathsToQuery.add(`${args.path ? `${args.path}.` : ''}${field.name}`)
-          }
-        }
-
-        return null
-      }
     }
   })
 }

packages/drizzle/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/drizzle/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/drizzle",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "description": "A library of shared functions used by different payload database adapters",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -10,6 +10,13 @@
   },
   "license": "MIT",
   "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     ".": {

packages/drizzle/src/countGlobalVersions.ts

@@ -0,0 +1,42 @@
+import type { CountGlobalVersions, SanitizedGlobalConfig } from 'payload'
+
+import { buildVersionGlobalFields } from 'payload'
+import toSnakeCase from 'to-snake-case'
+
+import type { DrizzleAdapter } from './types.js'
+
+import buildQuery from './queries/buildQuery.js'
+
+export const countGlobalVersions: CountGlobalVersions = async function countGlobalVersions(
+  this: DrizzleAdapter,
+  { global, locale, req, where: whereArg },
+) {
+  const globalConfig: SanitizedGlobalConfig = this.payload.globals.config.find(
+    ({ slug }) => slug === global,
+  )
+
+  const tableName = this.tableNameMap.get(
+    `_${toSnakeCase(globalConfig.slug)}${this.versionsSuffix}`,
+  )
+
+  const db = this.sessions[await req?.transactionID]?.db || this.drizzle
+
+  const fields = buildVersionGlobalFields(this.payload.config, globalConfig)
+
+  const { joins, where } = buildQuery({
+    adapter: this,
+    fields,
+    locale,
+    tableName,
+    where: whereArg,
+  })
+
+  const countResult = await this.countDistinct({
+    db,
+    joins,
+    tableName,
+    where,
+  })
+
+  return { totalDocs: countResult }
+}

packages/drizzle/src/countVersions.ts

@@ -0,0 +1,40 @@
+import type { CountVersions, SanitizedCollectionConfig } from 'payload'
+
+import { buildVersionCollectionFields } from 'payload'
+import toSnakeCase from 'to-snake-case'
+
+import type { DrizzleAdapter } from './types.js'
+
+import buildQuery from './queries/buildQuery.js'
+
+export const countVersions: CountVersions = async function countVersions(
+  this: DrizzleAdapter,
+  { collection, locale, req, where: whereArg },
+) {
+  const collectionConfig: SanitizedCollectionConfig = this.payload.collections[collection].config
+
+  const tableName = this.tableNameMap.get(
+    `_${toSnakeCase(collectionConfig.slug)}${this.versionsSuffix}`,
+  )
+
+  const db = this.sessions[await req?.transactionID]?.db || this.drizzle
+
+  const fields = buildVersionCollectionFields(this.payload.config, collectionConfig)
+
+  const { joins, where } = buildQuery({
+    adapter: this,
+    fields,
+    locale,
+    tableName,
+    where: whereArg,
+  })
+
+  const countResult = await this.countDistinct({
+    db,
+    joins,
+    tableName,
+    where,
+  })
+
+  return { totalDocs: countResult }
+}

packages/drizzle/src/exports/postgres.ts

@@ -1,7 +1,6 @@
 export { countDistinct } from '../postgres/countDistinct.js'
 export { createDatabase } from '../postgres/createDatabase.js'
 export { createExtensions } from '../postgres/createExtensions.js'
-export { convertPathToJSONTraversal } from '../postgres/createJSONQuery/convertPathToJSONTraversal.js'
 export { createJSONQuery } from '../postgres/createJSONQuery/index.js'
 export { createMigration } from '../postgres/createMigration.js'
 export { defaultDrizzleSnapshot } from '../postgres/defaultSnapshot.js'

packages/drizzle/src/find/traverseFields.ts

@@ -218,32 +218,6 @@ export const traverseFields = ({
           break
         }
 
-        case 'select': {
-          if (field.hasMany) {
-            if (select) {
-              if (
-                (selectMode === 'include' && !select[field.name]) ||
-                (selectMode === 'exclude' && select[field.name] === false)
-              ) {
-                break
-              }
-            }
-
-            const withSelect: Result = {
-              columns: {
-                id: false,
-                order: false,
-                parent: false,
-              },
-              orderBy: ({ order }, { asc }) => [asc(order)],
-            }
-
-            currentArgs.with[`${path}${field.name}`] = withSelect
-          }
-
-          break
-        }
-
         case 'blocks': {
           const blocksSelect = selectAllOnCurrentLevel ? true : select?.[field.name]
 
@@ -356,6 +330,7 @@ export const traverseFields = ({
         }
 
         case 'group':
+
         case 'tab': {
           const fieldSelect = select?.[field.name]
 
@@ -389,47 +364,6 @@ export const traverseFields = ({
 
           break
         }
-
-        case 'point': {
-          if (adapter.name === 'sqlite') {
-            break
-          }
-
-          const args = field.localized ? _locales : currentArgs
-          if (!args.columns) {
-            args.columns = {}
-          }
-
-          if (!args.extras) {
-            args.extras = {}
-          }
-
-          const name = `${path}${field.name}`
-
-          // Drizzle handles that poorly. See https://github.com/drizzle-team/drizzle-orm/issues/2526
-          // Additionally, this way we format the column value straight in the database using ST_AsGeoJSON
-          args.columns[name] = false
-
-          let shouldSelect = false
-
-          if (select || selectAllOnCurrentLevel) {
-            if (
-              selectAllOnCurrentLevel ||
-              (selectMode === 'include' && select[field.name] === true) ||
-              (selectMode === 'exclude' && typeof select[field.name] === 'undefined')
-            ) {
-              shouldSelect = true
-            }
-          } else {
-            shouldSelect = true
-          }
-
-          if (shouldSelect) {
-            args.extras[name] = sql.raw(`ST_AsGeoJSON(${toSnakeCase(name)})::jsonb`).as(name)
-          }
-          break
-        }
-
         case 'join': {
           // when `joinsQuery` is false, do not join
           if (joinQuery === false) {
@@ -621,6 +555,72 @@ export const traverseFields = ({
           break
         }
 
+        case 'point': {
+          if (adapter.name === 'sqlite') {
+            break
+          }
+
+          const args = field.localized ? _locales : currentArgs
+          if (!args.columns) {
+            args.columns = {}
+          }
+
+          if (!args.extras) {
+            args.extras = {}
+          }
+
+          const name = `${path}${field.name}`
+
+          // Drizzle handles that poorly. See https://github.com/drizzle-team/drizzle-orm/issues/2526
+          // Additionally, this way we format the column value straight in the database using ST_AsGeoJSON
+          args.columns[name] = false
+
+          let shouldSelect = false
+
+          if (select || selectAllOnCurrentLevel) {
+            if (
+              selectAllOnCurrentLevel ||
+              (selectMode === 'include' && select[field.name] === true) ||
+              (selectMode === 'exclude' && typeof select[field.name] === 'undefined')
+            ) {
+              shouldSelect = true
+            }
+          } else {
+            shouldSelect = true
+          }
+
+          if (shouldSelect) {
+            args.extras[name] = sql.raw(`ST_AsGeoJSON(${toSnakeCase(name)})::jsonb`).as(name)
+          }
+          break
+        }
+
+        case 'select': {
+          if (field.hasMany) {
+            if (select) {
+              if (
+                (selectMode === 'include' && !select[field.name]) ||
+                (selectMode === 'exclude' && select[field.name] === false)
+              ) {
+                break
+              }
+            }
+
+            const withSelect: Result = {
+              columns: {
+                id: false,
+                order: false,
+                parent: false,
+              },
+              orderBy: ({ order }, { asc }) => [asc(order)],
+            }
+
+            currentArgs.with[`${path}${field.name}`] = withSelect
+          }
+
+          break
+        }
+
         default: {
           if (!select && !selectAllOnCurrentLevel) {
             break

packages/drizzle/src/index.ts

@@ -1,4 +1,6 @@
 export { count } from './count.js'
+export { countGlobalVersions } from './countGlobalVersions.js'
+export { countVersions } from './countVersions.js'
 export { create } from './create.js'
 export { createGlobal } from './createGlobal.js'
 export { createGlobalVersion } from './createGlobalVersion.js'

packages/drizzle/src/postgres/createJSONQuery/convertPathToJSONTraversal.ts

@@ -1,15 +0,0 @@
-import { formatJSONPathSegment } from './formatJSONPathSegment.js'
-
-export const convertPathToJSONTraversal = (incomingSegments: string[]) => {
-  const segments = [...incomingSegments]
-  segments.shift()
-
-  return segments.reduce((res, segment, i) => {
-    const formattedSegment = formatJSONPathSegment(segment)
-
-    if (i + 1 === segments.length) {
-      return `${res}->>${formattedSegment}`
-    }
-    return `${res}->${formattedSegment}`
-  }, '')
-}

packages/drizzle/src/postgres/createJSONQuery/formatJSONPathSegment.ts

@@ -1,3 +0,0 @@
-export const formatJSONPathSegment = (segment: string) => {
-  return Number.isNaN(parseInt(segment)) ? `'${segment}'` : segment
-}

packages/drizzle/src/postgres/createJSONQuery/index.ts

@@ -1,87 +1,43 @@
-import { convertPathToJSONTraversal } from './convertPathToJSONTraversal.js'
-import { formatJSONPathSegment } from './formatJSONPathSegment.js'
+import type { CreateJSONQueryArgs } from '../../types.js'
 
-const operatorMap = {
-  contains: '~*',
-  equals: '=',
-  like: '~*',
+const operatorMap: Record<string, string> = {
+  contains: '~',
+  equals: '==',
+  in: 'in',
+  like: 'like_regex',
+  not_equals: '!=',
+  not_in: 'in',
 }
 
-type FromArrayArgs = {
-  isRoot?: true
-  operator: string
-  pathSegments: string[]
-  treatAsArray?: string[]
-  value: unknown
-}
-
-const fromArray = ({ isRoot, operator, pathSegments, treatAsArray, value }: FromArrayArgs) => {
-  const newPathSegments = pathSegments.slice(isRoot ? 1 : 2)
-  const alias = `${pathSegments[isRoot ? 0 : 1]}_alias_${newPathSegments.length}`
-
-  newPathSegments.unshift(alias)
-
-  const arrayElements = isRoot
-    ? pathSegments[0]
-    : `${pathSegments[0]} -> ${formatJSONPathSegment(pathSegments[1])}`
-
-  return `EXISTS (
-    SELECT 1
-    FROM jsonb_array_elements(${arrayElements}) AS ${alias}
-    WHERE ${createJSONQuery({
-      operator,
-      pathSegments: newPathSegments,
-      treatAsArray,
-      value,
-    })}
-  )`
-}
-
-type CreateConstraintArgs = {
-  operator: string
-  pathSegments: string[]
-  treatAsArray?: string[]
-  value: unknown
-}
-
-const createConstraint = ({ operator, pathSegments, value }: CreateConstraintArgs): string => {
-  const jsonQuery = convertPathToJSONTraversal(pathSegments)
-  return `${pathSegments[0]}${jsonQuery} ${operatorMap[operator]} '${value}'`
-}
-
-type Args = {
-  operator: string
-  pathSegments: string[]
-  treatAsArray?: string[]
-  treatRootAsArray?: boolean
-  value: unknown
-}
-
-export const createJSONQuery = ({
-  operator,
-  pathSegments,
-  treatAsArray,
-  treatRootAsArray,
-  value,
-}: Args): string => {
-  if (treatRootAsArray) {
-    return fromArray({
-      isRoot: true,
-      operator,
-      pathSegments,
-      treatAsArray,
-      value,
-    })
+const sanitizeValue = (value: unknown, operator?: string) => {
+  if (typeof value === 'string') {
+    // ignore casing with like
+    return `"${operator === 'like' ? '(?i)' : ''}${value}"`
   }
 
-  if (treatAsArray.includes(pathSegments[1])) {
-    return fromArray({
-      operator,
-      pathSegments,
-      treatAsArray,
-      value,
+  return value as string
+}
+
+export const createJSONQuery = ({ column, operator, pathSegments, value }: CreateJSONQueryArgs) => {
+  const columnName = typeof column === 'object' ? column.name : column
+  const jsonPaths = pathSegments
+    .slice(1)
+    .map((key) => {
+      return `${key}[*]`
     })
+    .join('.')
+
+  let sql = ''
+
+  if (['in', 'not_in'].includes(operator) && Array.isArray(value)) {
+    value.forEach((item, i) => {
+      sql = `${sql}${createJSONQuery({ column, operator: operator === 'in' ? 'equals' : 'not_equals', pathSegments, value: item })}${i === value.length - 1 ? '' : ` ${operator === 'in' ? 'OR' : 'AND'} `}`
+    })
+  } else if (operator === 'exists') {
+    sql = `${value === false ? 'NOT ' : ''}jsonb_path_exists(${columnName}, '$.${jsonPaths}')`
+  } else {
+    sql = `jsonb_path_exists(${columnName}, '$.${jsonPaths} ? (@ ${operatorMap[operator]} ${sanitizeValue(value, operator)})')`
   }
 
-  return createConstraint({ operator, pathSegments, treatAsArray, value })
+  return sql
 }

packages/drizzle/src/postgres/schema/traverseFields.ts

@@ -182,197 +182,6 @@ export const traverseFields = ({
     }
 
     switch (field.type) {
-      case 'text': {
-        if (field.hasMany) {
-          const isLocalized =
-            Boolean(field.localized && adapter.payload.config.localization) ||
-            withinLocalizedArrayOrBlock ||
-            forceLocalized
-
-          if (isLocalized) {
-            hasLocalizedManyTextField = true
-          }
-
-          if (field.index) {
-            hasManyTextField = 'index'
-          } else if (!hasManyTextField) {
-            hasManyTextField = true
-          }
-
-          if (field.unique) {
-            throw new InvalidConfiguration(
-              'Unique is not supported in Postgres for hasMany text fields.',
-            )
-          }
-        } else {
-          targetTable[fieldName] = withDefault(varchar(columnName), field)
-        }
-        break
-      }
-      case 'email':
-      case 'code':
-      case 'textarea': {
-        targetTable[fieldName] = withDefault(varchar(columnName), field)
-        break
-      }
-
-      case 'number': {
-        if (field.hasMany) {
-          const isLocalized =
-            Boolean(field.localized && adapter.payload.config.localization) ||
-            withinLocalizedArrayOrBlock ||
-            forceLocalized
-
-          if (isLocalized) {
-            hasLocalizedManyNumberField = true
-          }
-
-          if (field.index) {
-            hasManyNumberField = 'index'
-          } else if (!hasManyNumberField) {
-            hasManyNumberField = true
-          }
-
-          if (field.unique) {
-            throw new InvalidConfiguration(
-              'Unique is not supported in Postgres for hasMany number fields.',
-            )
-          }
-        } else {
-          targetTable[fieldName] = withDefault(numeric(columnName), field)
-        }
-        break
-      }
-
-      case 'richText':
-      case 'json': {
-        targetTable[fieldName] = withDefault(jsonb(columnName), field)
-        break
-      }
-
-      case 'date': {
-        targetTable[fieldName] = withDefault(
-          timestamp(columnName, {
-            mode: 'string',
-            precision: 3,
-            withTimezone: true,
-          }),
-          field,
-        )
-        break
-      }
-
-      case 'point': {
-        targetTable[fieldName] = withDefault(geometryColumn(columnName), field)
-        if (!adapter.extensions.postgis) {
-          adapter.extensions.postgis = true
-        }
-        break
-      }
-
-      case 'radio':
-      case 'select': {
-        const enumName = createTableName({
-          adapter,
-          config: field,
-          parentTableName: newTableName,
-          prefix: `enum_${newTableName}_`,
-          target: 'enumName',
-          throwValidationError,
-        })
-
-        adapter.enums[enumName] = adapter.pgSchema.enum(
-          enumName,
-          field.options.map((option) => {
-            if (optionIsObject(option)) {
-              return option.value
-            }
-
-            return option
-          }) as [string, ...string[]],
-        )
-
-        if (field.type === 'select' && field.hasMany) {
-          const selectTableName = createTableName({
-            adapter,
-            config: field,
-            parentTableName: newTableName,
-            prefix: `${newTableName}_`,
-            throwValidationError,
-            versionsCustomName: versions,
-          })
-          const baseColumns: Record<string, PgColumnBuilder> = {
-            order: integer('order').notNull(),
-            parent: parentIDColumnMap[parentIDColType]('parent_id').notNull(),
-            value: adapter.enums[enumName]('value'),
-          }
-
-          const baseExtraConfig: BaseExtraConfig = {
-            orderIdx: (cols) => index(`${selectTableName}_order_idx`).on(cols.order),
-            parentFk: (cols) =>
-              foreignKey({
-                name: `${selectTableName}_parent_fk`,
-                columns: [cols.parent],
-                foreignColumns: [adapter.tables[parentTableName].id],
-              }).onDelete('cascade'),
-            parentIdx: (cols) => index(`${selectTableName}_parent_idx`).on(cols.parent),
-          }
-
-          const isLocalized =
-            Boolean(field.localized && adapter.payload.config.localization) ||
-            withinLocalizedArrayOrBlock ||
-            forceLocalized
-
-          if (isLocalized) {
-            baseColumns.locale = adapter.enums.enum__locales('locale').notNull()
-            baseExtraConfig.localeIdx = (cols) =>
-              index(`${selectTableName}_locale_idx`).on(cols.locale)
-          }
-
-          if (field.index) {
-            baseExtraConfig.value = (cols) => index(`${selectTableName}_value_idx`).on(cols.value)
-          }
-
-          buildTable({
-            adapter,
-            baseColumns,
-            baseExtraConfig,
-            disableNotNull,
-            disableUnique,
-            fields: [],
-            rootTableName,
-            tableName: selectTableName,
-            versions,
-          })
-
-          relationsToBuild.set(fieldName, {
-            type: 'many',
-            // selects have their own localized table, independent of the base table.
-            localized: false,
-            target: selectTableName,
-          })
-
-          adapter.relations[`relations_${selectTableName}`] = relations(
-            adapter.tables[selectTableName],
-            ({ one }) => ({
-              parent: one(adapter.tables[parentTableName], {
-                fields: [adapter.tables[selectTableName].parent],
-                references: [adapter.tables[parentTableName].id],
-                relationName: fieldName,
-              }),
-            }),
-          )
-        } else {
-          targetTable[fieldName] = withDefault(adapter.enums[enumName](columnName), field)
-        }
-        break
-      }
-
-      case 'checkbox': {
-        targetTable[fieldName] = withDefault(boolean(columnName), field)
-        break
-      }
-
       case 'array': {
         const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull
 
@@ -506,7 +315,6 @@ export const traverseFields = ({
 
         break
       }
-
       case 'blocks': {
         const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull
 
@@ -655,9 +463,88 @@ export const traverseFields = ({
 
         break
       }
+      case 'checkbox': {
+        targetTable[fieldName] = withDefault(boolean(columnName), field)
+        break
+      }
+      case 'code':
 
-      case 'tab':
-      case 'group': {
+      case 'email':
+
+      case 'textarea': {
+        targetTable[fieldName] = withDefault(varchar(columnName), field)
+        break
+      }
+      case 'collapsible':
+
+      case 'row': {
+        const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull
+        const {
+          hasLocalizedField: rowHasLocalizedField,
+          hasLocalizedManyNumberField: rowHasLocalizedManyNumberField,
+          hasLocalizedManyTextField: rowHasLocalizedManyTextField,
+          hasLocalizedRelationshipField: rowHasLocalizedRelationshipField,
+          hasManyNumberField: rowHasManyNumberField,
+          hasManyTextField: rowHasManyTextField,
+        } = traverseFields({
+          adapter,
+          columnPrefix,
+          columns,
+          disableNotNull: disableNotNullFromHere,
+          disableUnique,
+          fieldPrefix,
+          fields: field.fields,
+          forceLocalized,
+          indexes,
+          localesColumns,
+          localesIndexes,
+          newTableName,
+          parentTableName,
+          relationships,
+          relationsToBuild,
+          rootRelationsToBuild,
+          rootTableIDColType,
+          rootTableName,
+          uniqueRelationships,
+          versions,
+          withinLocalizedArrayOrBlock,
+        })
+
+        if (rowHasLocalizedField) {
+          hasLocalizedField = true
+        }
+        if (rowHasLocalizedRelationshipField) {
+          hasLocalizedRelationshipField = true
+        }
+        if (rowHasManyTextField) {
+          hasManyTextField = true
+        }
+        if (rowHasLocalizedManyTextField) {
+          hasLocalizedManyTextField = true
+        }
+        if (rowHasManyNumberField) {
+          hasManyNumberField = true
+        }
+        if (rowHasLocalizedManyNumberField) {
+          hasLocalizedManyNumberField = true
+        }
+        break
+      }
+
+      case 'date': {
+        targetTable[fieldName] = withDefault(
+          timestamp(columnName, {
+            mode: 'string',
+            precision: 3,
+            withTimezone: true,
+          }),
+          field,
+        )
+        break
+      }
+
+      case 'group':
+      case 'tab': {
         if (!('name' in field)) {
           const {
             hasLocalizedField: groupHasLocalizedField,
@@ -765,112 +652,143 @@ export const traverseFields = ({
         break
       }
 
-      case 'tabs': {
-        const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull
+      case 'json':
 
-        const {
-          hasLocalizedField: tabHasLocalizedField,
-          hasLocalizedManyNumberField: tabHasLocalizedManyNumberField,
-          hasLocalizedManyTextField: tabHasLocalizedManyTextField,
-          hasLocalizedRelationshipField: tabHasLocalizedRelationshipField,
-          hasManyNumberField: tabHasManyNumberField,
-          hasManyTextField: tabHasManyTextField,
-        } = traverseFields({
-          adapter,
-          columnPrefix,
-          columns,
-          disableNotNull: disableNotNullFromHere,
-          disableUnique,
-          fieldPrefix,
-          fields: field.tabs.map((tab) => ({ ...tab, type: 'tab' })),
-          forceLocalized,
-          indexes,
-          localesColumns,
-          localesIndexes,
-          newTableName,
-          parentTableName,
-          relationships,
-          relationsToBuild,
-          rootRelationsToBuild,
-          rootTableIDColType,
-          rootTableName,
-          uniqueRelationships,
-          versions,
-          withinLocalizedArrayOrBlock,
-        })
+      case 'richText': {
+        targetTable[fieldName] = withDefault(jsonb(columnName), field)
+        break
+      }
 
-        if (tabHasLocalizedField) {
-          hasLocalizedField = true
-        }
-        if (tabHasLocalizedRelationshipField) {
-          hasLocalizedRelationshipField = true
-        }
-        if (tabHasManyTextField) {
-          hasManyTextField = true
-        }
-        if (tabHasLocalizedManyTextField) {
-          hasLocalizedManyTextField = true
-        }
-        if (tabHasManyNumberField) {
-          hasManyNumberField = true
-        }
-        if (tabHasLocalizedManyNumberField) {
-          hasLocalizedManyNumberField = true
+      case 'number': {
+        if (field.hasMany) {
+          const isLocalized =
+            Boolean(field.localized && adapter.payload.config.localization) ||
+            withinLocalizedArrayOrBlock ||
+            forceLocalized
+
+          if (isLocalized) {
+            hasLocalizedManyNumberField = true
+          }
+
+          if (field.index) {
+            hasManyNumberField = 'index'
+          } else if (!hasManyNumberField) {
+            hasManyNumberField = true
+          }
+
+          if (field.unique) {
+            throw new InvalidConfiguration(
+              'Unique is not supported in Postgres for hasMany number fields.',
+            )
+          }
+        } else {
+          targetTable[fieldName] = withDefault(numeric(columnName), field)
         }
         break
       }
 
-      case 'row':
-      case 'collapsible': {
-        const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull
-        const {
-          hasLocalizedField: rowHasLocalizedField,
-          hasLocalizedManyNumberField: rowHasLocalizedManyNumberField,
-          hasLocalizedManyTextField: rowHasLocalizedManyTextField,
-          hasLocalizedRelationshipField: rowHasLocalizedRelationshipField,
-          hasManyNumberField: rowHasManyNumberField,
-          hasManyTextField: rowHasManyTextField,
-        } = traverseFields({
+      case 'point': {
+        targetTable[fieldName] = withDefault(geometryColumn(columnName), field)
+        if (!adapter.extensions.postgis) {
+          adapter.extensions.postgis = true
+        }
+        break
+      }
+      case 'radio':
+
+      case 'select': {
+        const enumName = createTableName({
           adapter,
-          columnPrefix,
-          columns,
-          disableNotNull: disableNotNullFromHere,
-          disableUnique,
-          fieldPrefix,
-          fields: field.fields,
-          forceLocalized,
-          indexes,
-          localesColumns,
-          localesIndexes,
-          newTableName,
-          parentTableName,
-          relationships,
-          relationsToBuild,
-          rootRelationsToBuild,
-          rootTableIDColType,
-          rootTableName,
-          uniqueRelationships,
-          versions,
-          withinLocalizedArrayOrBlock,
+          config: field,
+          parentTableName: newTableName,
+          prefix: `enum_${newTableName}_`,
+          target: 'enumName',
+          throwValidationError,
         })
 
-        if (rowHasLocalizedField) {
-          hasLocalizedField = true
-        }
-        if (rowHasLocalizedRelationshipField) {
-          hasLocalizedRelationshipField = true
-        }
-        if (rowHasManyTextField) {
-          hasManyTextField = true
-        }
-        if (rowHasLocalizedManyTextField) {
-          hasLocalizedManyTextField = true
-        }
-        if (rowHasManyNumberField) {
-          hasManyNumberField = true
-        }
-        if (rowHasLocalizedManyNumberField) {
-          hasLocalizedManyNumberField = true
+        adapter.enums[enumName] = adapter.pgSchema.enum(
+          enumName,
+          field.options.map((option) => {
+            if (optionIsObject(option)) {
+              return option.value
+            }
+
+            return option
+          }) as [string, ...string[]],
+        )
+
+        if (field.type === 'select' && field.hasMany) {
+          const selectTableName = createTableName({
+            adapter,
+            config: field,
+            parentTableName: newTableName,
+            prefix: `${newTableName}_`,
+            throwValidationError,
+            versionsCustomName: versions,
+          })
+          const baseColumns: Record<string, PgColumnBuilder> = {
+            order: integer('order').notNull(),
+            parent: parentIDColumnMap[parentIDColType]('parent_id').notNull(),
+            value: adapter.enums[enumName]('value'),
+          }
+
+          const baseExtraConfig: BaseExtraConfig = {
+            orderIdx: (cols) => index(`${selectTableName}_order_idx`).on(cols.order),
+            parentFk: (cols) =>
+              foreignKey({
+                name: `${selectTableName}_parent_fk`,
+                columns: [cols.parent],
+                foreignColumns: [adapter.tables[parentTableName].id],
+              }).onDelete('cascade'),
+            parentIdx: (cols) => index(`${selectTableName}_parent_idx`).on(cols.parent),
+          }
+
+          const isLocalized =
+            Boolean(field.localized && adapter.payload.config.localization) ||
+            withinLocalizedArrayOrBlock ||
+            forceLocalized
+
+          if (isLocalized) {
+            baseColumns.locale = adapter.enums.enum__locales('locale').notNull()
+            baseExtraConfig.localeIdx = (cols) =>
+              index(`${selectTableName}_locale_idx`).on(cols.locale)
+          }
+
+          if (field.index) {
+            baseExtraConfig.value = (cols) => index(`${selectTableName}_value_idx`).on(cols.value)
+          }
+
+          buildTable({
+            adapter,
+            baseColumns,
+            baseExtraConfig,
+            disableNotNull,
+            disableUnique,
+            fields: [],
+            rootTableName,
+            tableName: selectTableName,
+            versions,
+          })
+
+          relationsToBuild.set(fieldName, {
+            type: 'many',
+            // selects have their own localized table, independent of the base table.
+            localized: false,
+            target: selectTableName,
+          })
+
+          adapter.relations[`relations_${selectTableName}`] = relations(
+            adapter.tables[selectTableName],
+            ({ one }) => ({
+              parent: one(adapter.tables[parentTableName], {
+                fields: [adapter.tables[selectTableName].parent],
+                references: [adapter.tables[parentTableName].id],
+                relationName: fieldName,
+              }),
+            }),
+          )
+        } else {
+          targetTable[fieldName] = withDefault(adapter.enums[enumName](columnName), field)
         }
         break
       }
@@ -936,6 +854,88 @@ export const traverseFields = ({
 
         break
 
+      case 'tabs': {
+        const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull
+
+        const {
+          hasLocalizedField: tabHasLocalizedField,
+          hasLocalizedManyNumberField: tabHasLocalizedManyNumberField,
+          hasLocalizedManyTextField: tabHasLocalizedManyTextField,
+          hasLocalizedRelationshipField: tabHasLocalizedRelationshipField,
+          hasManyNumberField: tabHasManyNumberField,
+          hasManyTextField: tabHasManyTextField,
+        } = traverseFields({
+          adapter,
+          columnPrefix,
+          columns,
+          disableNotNull: disableNotNullFromHere,
+          disableUnique,
+          fieldPrefix,
+          fields: field.tabs.map((tab) => ({ ...tab, type: 'tab' })),
+          forceLocalized,
+          indexes,
+          localesColumns,
+          localesIndexes,
+          newTableName,
+          parentTableName,
+          relationships,
+          relationsToBuild,
+          rootRelationsToBuild,
+          rootTableIDColType,
+          rootTableName,
+          uniqueRelationships,
+          versions,
+          withinLocalizedArrayOrBlock,
+        })
+
+        if (tabHasLocalizedField) {
+          hasLocalizedField = true
+        }
+        if (tabHasLocalizedRelationshipField) {
+          hasLocalizedRelationshipField = true
+        }
+        if (tabHasManyTextField) {
+          hasManyTextField = true
+        }
+        if (tabHasLocalizedManyTextField) {
+          hasLocalizedManyTextField = true
+        }
+        if (tabHasManyNumberField) {
+          hasManyNumberField = true
+        }
+        if (tabHasLocalizedManyNumberField) {
+          hasLocalizedManyNumberField = true
+        }
+        break
+      }
+      case 'text': {
+        if (field.hasMany) {
+          const isLocalized =
+            Boolean(field.localized && adapter.payload.config.localization) ||
+            withinLocalizedArrayOrBlock ||
+            forceLocalized
+
+          if (isLocalized) {
+            hasLocalizedManyTextField = true
+          }
+
+          if (field.index) {
+            hasManyTextField = 'index'
+          } else if (!hasManyTextField) {
+            hasManyTextField = true
+          }
+
+          if (field.unique) {
+            throw new InvalidConfiguration(
+              'Unique is not supported in Postgres for hasMany text fields.',
+            )
+          }
+        } else {
+          targetTable[fieldName] = withDefault(varchar(columnName), field)
+        }
+        break
+      }
+
       default:
         break
     }

packages/drizzle/src/queries/getTableColumnFromPath.ts

@@ -121,185 +121,6 @@ export const getTableColumnFromPath = ({
     }
 
     switch (field.type) {
-      case 'tabs': {
-        return getTableColumnFromPath({
-          adapter,
-          aliasTable,
-          collectionPath,
-          columnPrefix,
-          constraintPath,
-          constraints,
-          fields: field.tabs.map((tab) => ({
-            ...tab,
-            type: 'tab',
-          })),
-          joins,
-          locale,
-          pathSegments: pathSegments.slice(1),
-          rootTableName,
-          selectFields,
-          tableName: newTableName,
-          tableNameSuffix,
-          value,
-        })
-      }
-      case 'tab': {
-        if (tabHasName(field)) {
-          return getTableColumnFromPath({
-            adapter,
-            aliasTable,
-            collectionPath,
-            columnPrefix: `${columnPrefix}${field.name}_`,
-            constraintPath: `${constraintPath}${field.name}.`,
-            constraints,
-            fields: field.fields,
-            joins,
-            locale,
-            pathSegments: pathSegments.slice(1),
-            rootTableName,
-            selectFields,
-            tableName: newTableName,
-            tableNameSuffix: `${tableNameSuffix}${toSnakeCase(field.name)}_`,
-            value,
-          })
-        }
-        return getTableColumnFromPath({
-          adapter,
-          aliasTable,
-          collectionPath,
-          columnPrefix,
-          constraintPath,
-          constraints,
-          fields: field.fields,
-          joins,
-          locale,
-          pathSegments: pathSegments.slice(1),
-          rootTableName,
-          selectFields,
-          tableName: newTableName,
-          tableNameSuffix,
-          value,
-        })
-      }
-
-      case 'group': {
-        if (locale && field.localized && adapter.payload.config.localization) {
-          newTableName = `${tableName}${adapter.localesSuffix}`
-
-          let condition = eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID)
-
-          if (locale !== 'all') {
-            condition = and(condition, eq(adapter.tables[newTableName]._locale, locale))
-          }
-
-          addJoinTable({
-            condition,
-            joins,
-            table: adapter.tables[newTableName],
-          })
-        }
-        return getTableColumnFromPath({
-          adapter,
-          aliasTable,
-          collectionPath,
-          columnPrefix: `${columnPrefix}${field.name}_`,
-          constraintPath: `${constraintPath}${field.name}.`,
-          constraints,
-          fields: field.fields,
-          joins,
-          locale,
-          pathSegments: pathSegments.slice(1),
-          rootTableName,
-          selectFields,
-          tableName: newTableName,
-          tableNameSuffix: `${tableNameSuffix}${toSnakeCase(field.name)}_`,
-          value,
-        })
-      }
-
-      case 'select': {
-        if (field.hasMany) {
-          const newTableName = adapter.tableNameMap.get(
-            `${tableName}_${tableNameSuffix}${toSnakeCase(field.name)}`,
-          )
-
-          if (locale && field.localized && adapter.payload.config.localization) {
-            const conditions = [
-              eq(adapter.tables[tableName].id, adapter.tables[newTableName].parent),
-              eq(adapter.tables[newTableName]._locale, locale),
-            ]
-
-            if (locale !== 'all') {
-              conditions.push(eq(adapter.tables[newTableName]._locale, locale))
-            }
-
-            addJoinTable({
-              condition: and(...conditions),
-              joins,
-              table: adapter.tables[newTableName],
-            })
-          } else {
-            addJoinTable({
-              condition: eq(adapter.tables[tableName].id, adapter.tables[newTableName].parent),
-              joins,
-              table: adapter.tables[newTableName],
-            })
-          }
-
-          return {
-            columnName: 'value',
-            constraints,
-            field,
-            table: adapter.tables[newTableName],
-          }
-        }
-        break
-      }
-
-      case 'text':
-      case 'number': {
-        if (field.hasMany) {
-          let tableType = 'texts'
-          let columnName = 'text'
-          if (field.type === 'number') {
-            tableType = 'numbers'
-            columnName = 'number'
-          }
-          newTableName = `${rootTableName}_${tableType}`
-          const joinConstraints = [
-            eq(adapter.tables[rootTableName].id, adapter.tables[newTableName].parent),
-            like(adapter.tables[newTableName].path, `${constraintPath}${field.name}`),
-          ]
-
-          if (locale && field.localized && adapter.payload.config.localization) {
-            const conditions = [...joinConstraints]
-
-            if (locale !== 'all') {
-              conditions.push(eq(adapter.tables[newTableName]._locale, locale))
-            }
-            addJoinTable({
-              condition: and(...conditions),
-              joins,
-              table: adapter.tables[newTableName],
-            })
-          } else {
-            addJoinTable({
-              condition: and(...joinConstraints),
-              joins,
-              table: adapter.tables[newTableName],
-            })
-          }
-
-          return {
-            columnName,
-            constraints,
-            field,
-            table: adapter.tables[newTableName],
-          }
-        }
-        break
-      }
-
       case 'array': {
         newTableName = adapter.tableNameMap.get(
           `${tableName}_${tableNameSuffix}${toSnakeCase(field.name)}`,
@@ -341,7 +162,6 @@ export const getTableColumnFromPath = ({
           value,
         })
       }
-
       case 'blocks': {
         let blockTableColumn: TableColumn
         let newTableName: string
@@ -447,7 +267,87 @@ export const getTableColumnFromPath = ({
         break
       }
 
+      case 'group': {
+        if (locale && field.localized && adapter.payload.config.localization) {
+          newTableName = `${tableName}${adapter.localesSuffix}`
+
+          let condition = eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID)
+
+          if (locale !== 'all') {
+            condition = and(condition, eq(adapter.tables[newTableName]._locale, locale))
+          }
+
+          addJoinTable({
+            condition,
+            joins,
+            table: adapter.tables[newTableName],
+          })
+        }
+        return getTableColumnFromPath({
+          adapter,
+          aliasTable,
+          collectionPath,
+          columnPrefix: `${columnPrefix}${field.name}_`,
+          constraintPath: `${constraintPath}${field.name}.`,
+          constraints,
+          fields: field.fields,
+          joins,
+          locale,
+          pathSegments: pathSegments.slice(1),
+          rootTableName,
+          selectFields,
+          tableName: newTableName,
+          tableNameSuffix: `${tableNameSuffix}${toSnakeCase(field.name)}_`,
+          value,
+        })
+      }
+
+      case 'number':
+
+      case 'text': {
+        if (field.hasMany) {
+          let tableType = 'texts'
+          let columnName = 'text'
+          if (field.type === 'number') {
+            tableType = 'numbers'
+            columnName = 'number'
+          }
+          newTableName = `${rootTableName}_${tableType}`
+          const joinConstraints = [
+            eq(adapter.tables[rootTableName].id, adapter.tables[newTableName].parent),
+            like(adapter.tables[newTableName].path, `${constraintPath}${field.name}`),
+          ]
+
+          if (locale && field.localized && adapter.payload.config.localization) {
+            const conditions = [...joinConstraints]
+
+            if (locale !== 'all') {
+              conditions.push(eq(adapter.tables[newTableName]._locale, locale))
+            }
+            addJoinTable({
+              condition: and(...conditions),
+              joins,
+              table: adapter.tables[newTableName],
+            })
+          } else {
+            addJoinTable({
+              condition: and(...joinConstraints),
+              joins,
+              table: adapter.tables[newTableName],
+            })
+          }
+
+          return {
+            columnName,
+            constraints,
+            field,
+            table: adapter.tables[newTableName],
+          }
+        }
+        break
+      }
       case 'relationship':
+
       case 'upload': {
         const newCollectionPath = pathSegments.slice(1).join('.')
         if (Array.isArray(field.relationTo) || field.hasMany) {
@@ -692,6 +592,106 @@ export const getTableColumnFromPath = ({
         break
       }
 
+      case 'select': {
+        if (field.hasMany) {
+          const newTableName = adapter.tableNameMap.get(
+            `${tableName}_${tableNameSuffix}${toSnakeCase(field.name)}`,
+          )
+
+          if (locale && field.localized && adapter.payload.config.localization) {
+            const conditions = [
+              eq(adapter.tables[tableName].id, adapter.tables[newTableName].parent),
+              eq(adapter.tables[newTableName]._locale, locale),
+            ]
+
+            if (locale !== 'all') {
+              conditions.push(eq(adapter.tables[newTableName]._locale, locale))
+            }
+
+            addJoinTable({
+              condition: and(...conditions),
+              joins,
+              table: adapter.tables[newTableName],
+            })
+          } else {
+            addJoinTable({
+              condition: eq(adapter.tables[tableName].id, adapter.tables[newTableName].parent),
+              joins,
+              table: adapter.tables[newTableName],
+            })
+          }
+
+          return {
+            columnName: 'value',
+            constraints,
+            field,
+            table: adapter.tables[newTableName],
+          }
+        }
+        break
+      }
+
+      case 'tab': {
+        if (tabHasName(field)) {
+          return getTableColumnFromPath({
+            adapter,
+            aliasTable,
+            collectionPath,
+            columnPrefix: `${columnPrefix}${field.name}_`,
+            constraintPath: `${constraintPath}${field.name}.`,
+            constraints,
+            fields: field.fields,
+            joins,
+            locale,
+            pathSegments: pathSegments.slice(1),
+            rootTableName,
+            selectFields,
+            tableName: newTableName,
+            tableNameSuffix: `${tableNameSuffix}${toSnakeCase(field.name)}_`,
+            value,
+          })
+        }
+        return getTableColumnFromPath({
+          adapter,
+          aliasTable,
+          collectionPath,
+          columnPrefix,
+          constraintPath,
+          constraints,
+          fields: field.fields,
+          joins,
+          locale,
+          pathSegments: pathSegments.slice(1),
+          rootTableName,
+          selectFields,
+          tableName: newTableName,
+          tableNameSuffix,
+          value,
+        })
+      }
+      case 'tabs': {
+        return getTableColumnFromPath({
+          adapter,
+          aliasTable,
+          collectionPath,
+          columnPrefix,
+          constraintPath,
+          constraints,
+          fields: field.tabs.map((tab) => ({
+            ...tab,
+            type: 'tab',
+          })),
+          joins,
+          locale,
+          pathSegments: pathSegments.slice(1),
+          rootTableName,
+          selectFields,
+          tableName: newTableName,
+          tableNameSuffix,
+          value,
+        })
+      }
+
       default: {
         // fall through
         break

packages/drizzle/src/queries/parseParams.ts

@@ -103,6 +103,18 @@ export function parseParams({
                   Array.isArray(pathSegments) &&
                   pathSegments.length > 1
                 ) {
+                  if (adapter.name === 'postgres') {
+                    const constraint = adapter.createJSONQuery({
+                      column: rawColumn || table[columnName],
+                      operator,
+                      pathSegments,
+                      value: val,
+                    })
+
+                    constraints.push(sql.raw(constraint))
+                    break
+                  }
+
                   const segments = pathSegments.slice(1)
                   segments.unshift(table[columnName].name)
 
@@ -142,11 +154,7 @@ export function parseParams({
                   if (adapter.name === 'sqlite' && operator === 'equals' && !isNaN(val)) {
                     formattedValue = val
                   } else if (['in', 'not_in'].includes(operator) && Array.isArray(val)) {
-                    if (adapter.name === 'sqlite') {
-                      formattedValue = `(${val.map((v) => `${v}`).join(',')})`
-                    } else {
-                      formattedValue = `(${val.map((v) => `'${v}'`).join(', ')})`
-                    }
+                    formattedValue = `(${val.map((v) => `${v}`).join(',')})`
                   } else {
                     formattedValue = `'${operatorKeys[operator].wildcard}${val}${operatorKeys[operator].wildcard}'`
                   }
@@ -287,6 +295,13 @@ export function parseParams({
 
                 if (field.type === 'point' && adapter.name === 'postgres') {
                   switch (operator) {
+                    case 'intersects': {
+                      constraints.push(
+                        sql`ST_Intersects(${table[columnName]}, ST_GeomFromGeoJSON(${JSON.stringify(queryValue)}))`,
+                      )
+                      break
+                    }
+
                     case 'near': {
                       const [lng, lat, maxDistance, minDistance] = queryValue as number[]
 
@@ -305,13 +320,6 @@ export function parseParams({
                       break
                     }
 
-                    case 'intersects': {
-                      constraints.push(
-                        sql`ST_Intersects(${table[columnName]}, ST_GeomFromGeoJSON(${JSON.stringify(queryValue)}))`,
-                      )
-                      break
-                    }
-
                     default:
                       break
                   }

packages/drizzle/src/transform/read/traverseFields.ts

@@ -593,8 +593,16 @@ export const traverseFields = <T extends Record<string, unknown>>({
         let val = fieldData
 
         switch (field.type) {
-          case 'tab':
-          case 'group': {
+          case 'date': {
+            if (typeof fieldData === 'string') {
+              val = new Date(fieldData).toISOString()
+            }
+
+            break
+          }
+          case 'group':
+
+          case 'tab': {
             const groupFieldPrefix = `${fieldPrefix || ''}${field.name}_`
             const groupData = {}
             const locale = table._locale as string
@@ -626,14 +634,6 @@ export const traverseFields = <T extends Record<string, unknown>>({
             return
           }
 
-          case 'text': {
-            if (typeof fieldData === 'string') {
-              val = String(fieldData)
-            }
-
-            break
-          }
-
           case 'number': {
             if (typeof fieldData === 'string') {
               val = Number.parseFloat(fieldData)
@@ -642,15 +642,8 @@ export const traverseFields = <T extends Record<string, unknown>>({
             break
           }
 
-          case 'date': {
-            if (typeof fieldData === 'string') {
-              val = new Date(fieldData).toISOString()
-            }
-
-            break
-          }
-
           case 'relationship':
+
           case 'upload': {
             if (
               val &&
@@ -662,6 +655,13 @@ export const traverseFields = <T extends Record<string, unknown>>({
 
             break
           }
+          case 'text': {
+            if (typeof fieldData === 'string') {
+              val = String(fieldData)
+            }
+
+            break
+          }
 
           default: {
             break

packages/drizzle/src/types.ts

@@ -1,4 +1,5 @@
 import type {
+  Column,
   ColumnBaseConfig,
   ColumnDataType,
   DrizzleConfig,
@@ -148,6 +149,7 @@ export type Migration = {
 } & MigrationData
 
 export type CreateJSONQueryArgs = {
+  column?: Column | string
   operator: string
   pathSegments: string[]
   table?: string
@@ -157,7 +159,7 @@ export type CreateJSONQueryArgs = {
 }
 
 export interface DrizzleAdapter extends BaseDatabaseAdapter {
-  convertPathToJSONTraversal: (incomingSegments: string[]) => string
+  convertPathToJSONTraversal?: (incomingSegments: string[]) => string
   countDistinct: CountDistinct
   createJSONQuery: (args: CreateJSONQueryArgs) => string
   defaultDrizzleSnapshot: Record<string, unknown>

packages/drizzle/src/upsertRow/index.ts

@@ -391,8 +391,8 @@ export const upsertRow = async <T extends Record<string, unknown> | TypeWithID>(
           id,
           errors: [
             {
-              field: fieldName,
               message: req.t('error:valueMustBeUnique'),
+              path: fieldName,
             },
           ],
         },

packages/email-nodemailer/LICENSE.md

@@ -1,22 +1,22 @@
 MIT License
 
-Copyright (c) 2018-2022 Payload CMS, LLC <info@payloadcms.com>
-Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/email-nodemailer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/email-nodemailer",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "description": "Payload Nodemailer Email Adapter",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -10,6 +10,13 @@
   },
   "license": "MIT",
   "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     ".": {

packages/email-resend/LICENSE.md

@@ -1,22 +1,22 @@
 MIT License
 
-Copyright (c) 2018-2022 Payload CMS, LLC <info@payloadcms.com>
-Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/email-resend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/email-resend",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "description": "Payload Resend Email Adapter",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -10,6 +10,13 @@
   },
   "license": "MIT",
   "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     ".": {

packages/eslint-config/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/eslint-config/package.json

@@ -11,29 +11,36 @@
   },
   "license": "MIT",
   "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "main": "index.mjs",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@eslint-react/eslint-plugin": "1.12.3",
-    "@eslint/js": "9.9.1",
+    "@eslint-react/eslint-plugin": "1.16.1",
+    "@eslint/js": "9.14.0",
     "@payloadcms/eslint-plugin": "workspace:*",
     "@types/eslint": "9.6.1",
     "@types/eslint__js": "8.42.3",
-    "@typescript-eslint/parser": "8.3.0",
-    "eslint": "9.9.1",
+    "@typescript-eslint/parser": "8.14.0",
+    "eslint": "9.14.0",
     "eslint-config-prettier": "9.1.0",
-    "eslint-plugin-import-x": "4.1.1",
-    "eslint-plugin-jest": "28.8.1",
+    "eslint-plugin-import-x": "4.4.2",
+    "eslint-plugin-jest": "28.9.0",
     "eslint-plugin-jest-dom": "5.4.0",
-    "eslint-plugin-jsx-a11y": "6.9.0",
-    "eslint-plugin-perfectionist": "3.3.0",
-    "eslint-plugin-react-hooks": "5.1.0-rc-a19a8ab4-20240829",
+    "eslint-plugin-jsx-a11y": "6.10.2",
+    "eslint-plugin-perfectionist": "3.9.1",
+    "eslint-plugin-react-hooks": "5.0.0",
     "eslint-plugin-regexp": "2.6.0",
-    "globals": "15.9.0",
+    "globals": "15.12.0",
     "typescript": "5.6.3",
-    "typescript-eslint": "8.3.0"
+    "typescript-eslint": "8.14.0"
   }
 }

packages/eslint-plugin/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/eslint-plugin/package.json

@@ -11,28 +11,35 @@
   },
   "license": "MIT",
   "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "main": "index.mjs",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@eslint-react/eslint-plugin": "1.12.3",
-    "@eslint/js": "9.9.1",
+    "@eslint-react/eslint-plugin": "1.16.1",
+    "@eslint/js": "9.14.0",
     "@types/eslint": "9.6.1",
     "@types/eslint__js": "8.42.3",
-    "@typescript-eslint/parser": "8.3.0",
-    "eslint": "9.9.1",
+    "@typescript-eslint/parser": "8.14.0",
+    "eslint": "9.14.0",
     "eslint-config-prettier": "9.1.0",
-    "eslint-plugin-import-x": "4.1.1",
-    "eslint-plugin-jest": "28.8.1",
+    "eslint-plugin-import-x": "4.4.2",
+    "eslint-plugin-jest": "28.9.0",
     "eslint-plugin-jest-dom": "5.4.0",
-    "eslint-plugin-jsx-a11y": "6.9.0",
-    "eslint-plugin-perfectionist": "3.3.0",
-    "eslint-plugin-react-hooks": "5.1.0-rc-a19a8ab4-20240829",
+    "eslint-plugin-jsx-a11y": "6.10.2",
+    "eslint-plugin-perfectionist": "3.9.1",
+    "eslint-plugin-react-hooks": "5.0.0",
     "eslint-plugin-regexp": "2.6.0",
-    "globals": "15.9.0",
+    "globals": "15.12.0",
     "typescript": "5.6.3",
-    "typescript-eslint": "8.3.0"
+    "typescript-eslint": "8.14.0"
   }
 }

packages/graphql/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/graphql/package.json

@@ -1,12 +1,21 @@
 {
   "name": "@payloadcms/graphql",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "homepage": "https://payloadcms.com",
   "repository": {
     "type": "git",
     "url": "https://github.com/payloadcms/payload.git",
     "directory": "packages/graphql"
   },
+  "license": "MIT",
+  "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     ".": {

packages/graphql/src/packages/graphql-query-complexity/QueryComplexity.ts

@@ -394,15 +394,15 @@ export class QueryComplexity {
     this.variableValues = coerced
 
     switch (operation.operation) {
-      case 'query':
-        this.complexity += this.nodeComplexity(operation, this.context.getSchema().getQueryType())
-        break
       case 'mutation':
         this.complexity += this.nodeComplexity(
           operation,
           this.context.getSchema().getMutationType(),
         )
         break
+      case 'query':
+        this.complexity += this.nodeComplexity(operation, this.context.getSchema().getQueryType())
+        break
       case 'subscription':
         this.complexity += this.nodeComplexity(
           operation,

packages/graphql/src/packages/graphql-type-json/index.ts

@@ -24,18 +24,18 @@ function parseObject(typeName, ast, variables) {
 
 function parseLiteral(typeName, ast, variables) {
   switch (ast.kind) {
-    case Kind.STRING:
     case Kind.BOOLEAN:
+    case Kind.STRING:
       return ast.value
-    case Kind.INT:
     case Kind.FLOAT:
+    case Kind.INT:
       return parseFloat(ast.value)
-    case Kind.OBJECT:
-      return parseObject(typeName, ast, variables)
     case Kind.LIST:
       return ast.values.map((n) => parseLiteral(typeName, n, variables))
     case Kind.NULL:
       return null
+    case Kind.OBJECT:
+      return parseObject(typeName, ast, variables)
     case Kind.VARIABLE:
       return variables ? variables[ast.name.value] : undefined
     default:

packages/live-preview-react/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/live-preview-react/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/live-preview-react",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "description": "The official React SDK for Payload Live Preview",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -10,6 +10,13 @@
   },
   "license": "MIT",
   "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     ".": {

packages/live-preview-vue/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/live-preview-vue/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/live-preview-vue",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "description": "The official Vue SDK for Payload Live Preview",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -10,6 +10,13 @@
   },
   "license": "MIT",
   "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     ".": {

packages/live-preview/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/live-preview/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/live-preview",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "description": "The official live preview JavaScript SDK for Payload",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -10,6 +10,13 @@
   },
   "license": "MIT",
   "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     ".": {

packages/live-preview/src/traverseFields.ts

@@ -24,16 +24,6 @@ export const traverseFields = <T>(args: {
       const fieldName = fieldSchema.name
 
       switch (fieldSchema.type) {
-        case 'richText':
-          result[fieldName] = traverseRichText({
-            externallyUpdatedRelationship,
-            incomingData: incomingData[fieldName],
-            populationsByCollection,
-            result: result[fieldName],
-          })
-
-          break
-
         case 'array':
           if (Array.isArray(incomingData[fieldName])) {
             result[fieldName] = incomingData[fieldName].map((incomingRow, i) => {
@@ -94,8 +84,9 @@ export const traverseFields = <T>(args: {
 
           break
 
-        case 'tabs':
         case 'group':
+
+        case 'tabs':
           if (!result[fieldName]) {
             result[fieldName] = {}
           }
@@ -109,9 +100,9 @@ export const traverseFields = <T>(args: {
           })
 
           break
+        case 'relationship':
 
         case 'upload':
-        case 'relationship':
           // Handle `hasMany` relationships
           if (fieldSchema.hasMany && Array.isArray(incomingData[fieldName])) {
             if (!result[fieldName] || !incomingData[fieldName].length) {
@@ -271,6 +262,15 @@ export const traverseFields = <T>(args: {
             }
           }
 
+          break
+        case 'richText':
+          result[fieldName] = traverseRichText({
+            externallyUpdatedRelationship,
+            incomingData: incomingData[fieldName],
+            populationsByCollection,
+            result: result[fieldName],
+          })
+
           break
 
         default:

packages/next/license.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/next/package.json

@@ -1,12 +1,21 @@
 {
   "name": "@payloadcms/next",
-  "version": "3.0.0-beta.127",
+  "version": "3.0.0-beta.129",
   "homepage": "https://payloadcms.com",
   "repository": {
     "type": "git",
     "url": "https://github.com/payloadcms/payload.git",
     "directory": "packages/next"
   },
+  "license": "MIT",
+  "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
+  "maintainers": [
+    {
+      "name": "Payload",
+      "email": "info@payloadcms.com",
+      "url": "https://payloadcms.com"
+    }
+  ],
   "type": "module",
   "exports": {
     ".": {
@@ -106,7 +115,7 @@
     "babel-plugin-react-compiler": "0.0.0-experimental-24ec0eb-20240918",
     "esbuild": "0.23.1",
     "esbuild-sass-plugin": "3.3.1",
-    "eslint-plugin-react-compiler": "0.0.0-experimental-7670337-20240918",
+    "eslint-plugin-react-compiler": "19.0.0-beta-a7bf2bd-20241110",
     "payload": "workspace:*",
     "swc-plugin-transform-remove-imports": "1.15.0"
   },

packages/next/src/elements/DocumentHeader/Tabs/Tab/index.tsx

@@ -1,7 +1,8 @@
 import type { DocumentTabConfig, DocumentTabProps } from 'payload'
+import type React from 'react'
 
-import { getCreateMappedComponent, RenderComponent } from '@payloadcms/ui/shared'
-import React, { Fragment } from 'react'
+import { RenderServerComponent } from '@payloadcms/ui/elements/RenderServerComponent'
+import { Fragment } from 'react'
 
 import './index.scss'
 import { DocumentTabLink } from './TabLink.js'
@@ -59,17 +60,6 @@ export const DocumentTab: React.FC<
           })
         : label
 
-    const createMappedComponent = getCreateMappedComponent({
-      importMap: payload.importMap,
-      serverProps: {
-        i18n,
-        payload,
-        permissions,
-      },
-    })
-
-    const mappedPin = createMappedComponent(Pill, undefined, Pill_Component, 'Pill')
-
     return (
       <DocumentTabLink
         adminRoute={routes.admin}
@@ -82,12 +72,21 @@ export const DocumentTab: React.FC<
       >
         <span className={`${baseClass}__label`}>
           {labelToRender}
-          {mappedPin && (
+          {Pill || Pill_Component ? (
             <Fragment>
               &nbsp;
-              <RenderComponent mappedComponent={mappedPin} />
+              <RenderServerComponent
+                Component={Pill}
+                Fallback={Pill_Component}
+                importMap={payload.importMap}
+                serverProps={{
+                  i18n,
+                  payload,
+                  permissions,
+                }}
+              />
             </Fragment>
-          )}
+          ) : null}
         </span>
       </DocumentTabLink>
     )

packages/next/src/elements/DocumentHeader/Tabs/index.tsx

@@ -6,7 +6,7 @@ import type {
   SanitizedGlobalConfig,
 } from 'payload'
 
-import { getCreateMappedComponent, RenderComponent } from '@payloadcms/ui/shared'
+import { RenderServerComponent } from '@payloadcms/ui/elements/RenderServerComponent'
 import React from 'react'
 
 import { getCustomViews } from './getCustomViews.js'
@@ -80,33 +80,21 @@ export const DocumentTabs: React.FC<{
                 const { path, tab } = CustomView
 
                 if (tab.Component) {
-                  const createMappedComponent = getCreateMappedComponent({
-                    importMap: payload.importMap,
-                    serverProps: {
-                      i18n,
-                      payload,
-                      permissions,
-                      ...props,
-                      key: `tab-custom-${index}`,
-                      path,
-                    },
-                  })
-
-                  const mappedTab = createMappedComponent(
-                    tab.Component,
-                    undefined,
-                    undefined,
-                    'tab.Component',
-                  )
-
                   return (
-                    <RenderComponent
+                    <RenderServerComponent
                       clientProps={{
-                        key: `tab-custom-${index}`,
                         path,
                       }}
+                      Component={tab.Component}
+                      importMap={payload.importMap}
                       key={`tab-custom-${index}`}
-                      mappedComponent={mappedTab}
+                      serverProps={{
+                        collectionConfig,
+                        globalConfig,
+                        i18n,
+                        payload,
+                        permissions,
+                      }}
                     />
                   )
                 }
@@ -121,6 +109,7 @@ export const DocumentTabs: React.FC<{
                   />
                 )
               }
+
               return null
             })}
           </ul>