Merge branch 'main' into feat/multiple-fallback-locales

Author: jessrynkar

.github/workflows/audit-dependencies.yml

@@ -1,9 +1,9 @@
 name: audit-dependencies
 
 on:
-  # Sundays at 2am EST
+  # Monday at 2am EST
   schedule:
-    - cron: '0 7 * * 0'
+    - cron: '0 7 * * 1'
   workflow_dispatch:
     inputs:
       audit-level:

docs/configuration/overview.mdx

@@ -319,3 +319,13 @@ Now you can run the command using:
 ```sh
 pnpm payload seed
 ```
+
+## Running bin scripts on a schedule
+
+Every bin script supports being run on a schedule using cron syntax. Simply pass the `--cron` flag followed by the cron expression when running the script. Example:
+
+```sh
+pnpm payload run ./myScript.ts --cron "0 * * * *"
+```
+
+This will use the `run` bin script to execute the specified script on the defined schedule.

docs/jobs-queue/queues.mdx

@@ -173,25 +173,31 @@ const results = await payload.jobs.runByID({
 Finally, you can process jobs via the bin script that comes with Payload out of the box. By default, this script will run jobs from the `default` queue, with a limit of 10 jobs per invocation:
 
 ```sh
-npx payload jobs:run
+pnpm payload jobs:run
 ```
 
 You can override the default queue and limit by passing the `--queue` and `--limit` flags:
 
 ```sh
-npx payload jobs:run --queue myQueue --limit 15
+pnpm payload jobs:run --queue myQueue --limit 15
 ```
 
 If you want to run all jobs from all queues, you can pass the `--all-queues` flag:
 
 ```sh
-npx payload jobs:run --all-queues
+pnpm payload jobs:run --all-queues
 ```
 
 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 * * * *"
+pnpm payload jobs:run --cron "*/5 * * * *"
+```
+
+You can also pass `--handle-schedules` flag to the `jobs:run` command to make it schedule jobs according to configured schedules:
+
+```sh
+pnpm payload jobs:run --cron "*/5 * * * *" --queue myQueue --handle-schedules # This will both schedule jobs according to the configuration and run them
 ```
 
 ## Processing Order

docs/jobs-queue/schedules.mdx

@@ -35,6 +35,20 @@ Something needs to actually trigger the scheduling of jobs (execute the scheduli
 
 You can disable this behavior by setting `disableScheduling: true` in your `autorun` configuration, or by passing `disableScheduling=true` to the `/api/payload-jobs/run` endpoint. This is useful if you want to handle scheduling manually, for example, by using a cron job or a serverless function that calls the `/api/payload-jobs/handle-schedules` endpoint or the `payload.jobs.handleSchedules()` local API method.
 
+### Bin Scripts
+
+Payload provides a set of bin scripts that can be used to handle schedules. If you're already using the `jobs:run` bin script, you can set it to also handle schedules by passing the `--handle-schedules` flag:
+
+```sh
+pnpm payload jobs:run --cron "*/5 * * * *" --queue myQueue --handle-schedules # This will both schedule jobs according to the configuration and run them
+```
+
+If you only want to handle schedules, you can use the dedicated `jobs:handle-schedules` bin script:
+
+```sh
+pnpm payload jobs:handle-schedules --cron "*/5 * * * *" --queue myQueue # or --all-queues
+```
+
 ## Defining schedules on Tasks or Workflows
 
 Schedules are defined using the `schedule` property:

examples/multi-tenant/src/collections/Users/index.ts

@@ -23,6 +23,20 @@ const defaultTenantArrayField = tenantsArrayField({
       hasMany: true,
       options: ['tenant-admin', 'tenant-viewer'],
       required: true,
+      access: {
+        update: ({ req }) => {
+          const { user } = req
+          if (!user) {
+            return false
+          }
+
+          if (isSuperAdmin(user)) {
+            return true
+          }
+
+          return true
+        },
+      },
     },
   ],
 })
@@ -41,6 +55,27 @@ const Users: CollectionConfig = {
   auth: true,
   endpoints: [externalUsersLogin],
   fields: [
+    {
+      type: 'text',
+      name: 'password',
+      hidden: true,
+      access: {
+        read: () => false, // Hide password field from read access
+        update: ({ req, id }) => {
+          const { user } = req
+          if (!user) {
+            return false
+          }
+
+          if (id === user.id) {
+            // Allow user to update their own password
+            return true
+          }
+
+          return isSuperAdmin(user)
+        },
+      },
+    },
     {
       admin: {
         position: 'sidebar',

package.json

@@ -1,6 +1,6 @@
 {
   "name": "payload-monorepo",
-  "version": "3.55.1",
+  "version": "3.56.0",
   "private": true,
   "type": "module",
   "workspaces": [

packages/admin-bar/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/admin-bar",
-  "version": "3.55.1",
+  "version": "3.56.0",
   "description": "An admin bar for React apps using Payload",
   "homepage": "https://payloadcms.com",
   "repository": {

packages/create-payload-app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-payload-app",
-  "version": "3.55.1",
+  "version": "3.56.0",
   "homepage": "https://payloadcms.com",
   "repository": {
     "type": "git",

packages/db-mongodb/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/db-mongodb",
-  "version": "3.55.1",
+  "version": "3.56.0",
   "description": "The officially supported MongoDB database adapter for Payload",
   "homepage": "https://payloadcms.com",
   "repository": {

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

@@ -37,123 +37,109 @@ const relationshipSort = ({
   fields,
   locale,
   path,
-  sort,
+  previousField = '',
   sortAggregation,
-  sortDirection,
-  versions,
 }: {
   adapter: MongooseAdapter
   fields: FlattenedField[]
   locale?: string
   path: string
-  sort: Record<string, string>
+  previousField?: string
   sortAggregation: PipelineStage[]
-  sortDirection: SortDirection
   versions?: boolean
-}) => {
+}): null | string => {
   let currentFields = fields
   const segments = path.split('.')
   if (segments.length < 2) {
-    return false
+    return null
   }
 
   for (let i = 0; i < segments.length; i++) {
     const segment = segments[i]
     const field = currentFields.find((each) => each.name === segment)
 
     if (!field) {
-      return false
+      return null
     }
 
     if ('fields' in field) {
       currentFields = field.flattenedFields
-      if (field.name === 'version' && versions && i === 0) {
-        segments.shift()
-        i--
-      }
     } else if (
       (field.type === 'relationship' || field.type === 'upload') &&
       i !== segments.length - 1
     ) {
       const relationshipPath = segments.slice(0, i + 1).join('.')
-      let sortFieldPath = segments.slice(i + 1, segments.length).join('.')
-      if (sortFieldPath.endsWith('.id')) {
-        sortFieldPath = sortFieldPath.split('.').slice(0, -1).join('.')
+      const nextPath = segments.slice(i + 1, segments.length)
+      const relationshipFieldResult = getFieldByPath({ fields, path: relationshipPath })
+
+      if (
+        !relationshipFieldResult ||
+        !('relationTo' in relationshipFieldResult.field) ||
+        typeof relationshipFieldResult.field.relationTo !== 'string'
+      ) {
+        return null
       }
-      if (Array.isArray(field.relationTo)) {
-        throw new APIError('Not supported')
-      }
-
-      const foreignCollection = getCollection({ adapter, collectionSlug: field.relationTo })
 
-      const foreignFieldPath = getFieldByPath({
-        fields: foreignCollection.collectionConfig.flattenedFields,
-        path: sortFieldPath,
+      const { collectionConfig, Model } = getCollection({
+        adapter,
+        collectionSlug: relationshipFieldResult.field.relationTo,
       })
 
-      if (!foreignFieldPath) {
-        return false
-      }
+      let localizedRelationshipPath: string = relationshipFieldResult.localizedPath
 
-      if (foreignFieldPath.pathHasLocalized && locale) {
-        sortFieldPath = foreignFieldPath.localizedPath.replace('<locale>', locale)
+      if (locale && relationshipFieldResult.pathHasLocalized) {
+        localizedRelationshipPath = relationshipFieldResult.localizedPath.replace(
+          '<locale>',
+          locale,
+        )
       }
 
-      const as = `__${relationshipPath.replace(/\./g, '__')}`
+      if (nextPath.join('.') === 'id') {
+        return `${previousField}${localizedRelationshipPath}`
+      }
 
-      // If we have not already sorted on this relationship yet, we need to add a lookup stage
-      if (!sortAggregation.some((each) => '$lookup' in each && each.$lookup.as === as)) {
-        let localField = versions ? `version.${relationshipPath}` : relationshipPath
+      const as = `__${previousField}${localizedRelationshipPath}`
 
-        if (adapter.usePipelineInSortLookup) {
-          const flattenedField = `__${localField.replace(/\./g, '__')}_lookup`
-          sortAggregation.push({
-            $addFields: {
-              [flattenedField]: `$${localField}`,
-            },
-          })
-          localField = flattenedField
-        }
+      sortAggregation.push({
+        $lookup: {
+          as: `__${previousField}${localizedRelationshipPath}`,
+          foreignField: '_id',
+          from: Model.collection.name,
+          localField: `${previousField}${localizedRelationshipPath}`,
+        },
+      })
 
-        sortAggregation.push({
-          $lookup: {
-            as,
-            foreignField: '_id',
-            from: foreignCollection.Model.collection.name,
-            localField,
-            ...(!adapter.usePipelineInSortLookup && {
-              pipeline: [
-                {
-                  $project: {
-                    [sortFieldPath]: true,
-                  },
-                },
-              ],
-            }),
-          },
+      if (nextPath.length > 1) {
+        const nextRes = relationshipSort({
+          adapter,
+          fields: collectionConfig.flattenedFields,
+          locale,
+          path: nextPath.join('.'),
+          previousField: `${as}.`,
+          sortAggregation,
         })
 
-        if (adapter.usePipelineInSortLookup) {
-          sortAggregation.push({
-            $unset: localField,
-          })
+        if (nextRes) {
+          return nextRes
         }
+
+        return `${as}.${nextPath.join('.')}`
       }
 
-      if (!adapter.usePipelineInSortLookup) {
-        const lookup = sortAggregation.find(
-          (each) => '$lookup' in each && each.$lookup.as === as,
-        ) as PipelineStage.Lookup
-        const pipeline = lookup.$lookup.pipeline![0] as PipelineStage.Project
-        pipeline.$project[sortFieldPath] = true
+      const nextField = getFieldByPath({
+        fields: collectionConfig.flattenedFields,
+        path: nextPath[0]!,
+      })
+
+      if (nextField && nextField.pathHasLocalized && locale) {
+        return `${as}.${nextField.localizedPath.replace('<locale>', locale)}`
       }
 
-      sort[`${as}.${sortFieldPath}`] = sortDirection
-      return true
+      return `${as}.${nextPath[0]}`
     }
   }
 
-  return false
+  return null
 }
 
 export const buildSortParam = ({
@@ -217,20 +203,20 @@ export const buildSortParam = ({
       return acc
     }
 
-    if (
-      sortAggregation &&
-      relationshipSort({
+    if (sortAggregation) {
+      const sortRelProperty = relationshipSort({
         adapter,
         fields,
         locale,
         path: sortProperty,
-        sort: acc,
         sortAggregation,
-        sortDirection,
         versions,
       })
-    ) {
-      return acc
+
+      if (sortRelProperty) {
+        acc[sortRelProperty] = sortDirection
+        return acc
+      }
     }
 
     const localizedProperty = getLocalizedSortProperty({