fix: adds read and readDistinct to hook mapping (#14853)

Fixes #14847

Author: JarrodMFlesch

packages/payload/src/collections/operations/utilities/buildBeforeOperation.ts

@@ -85,9 +85,9 @@ export async function buildBeforeOperation<TOperationGeneric extends CollectionS
   let newArgs = args
 
   if (args.collection.config.hooks?.beforeOperation?.length) {
+    // TODO: v4 should not need this mapping
     // Map the operation to the hook operation type for backward compatibility
-    const hookOperation =
-      operationToHookOperation[operation as keyof typeof operationToHookOperation]
+    const hookOperation = operationToHookOperation[operation]
 
     for (const hook of args.collection.config.hooks.beforeOperation) {
       const hookResult = await hook({

packages/payload/src/collections/operations/utilities/types.ts

@@ -84,6 +84,8 @@ export type AfterOperationArg<TOperationGeneric extends CollectionSlug> = {
       args: Parameters<OperationMap<TOperationGeneric>['find']>[0]
       /**
        * @deprecated Use 'find' or 'findByID' operation instead
+       *
+       * TODO: v4 - remove this union option
        */
       operation: 'read'
       result: Awaited<ReturnType<OperationMap<TOperationGeneric>['find']>>
@@ -179,6 +181,8 @@ export const operationToHookOperation = {
   findVersions: 'read',
   forgotPassword: 'forgotPassword',
   login: 'login',
+  read: 'read',
+  readDistinct: 'readDistinct',
   refresh: 'refresh',
   resetPassword: 'resetPassword',
   restoreVersion: 'restoreVersion',
@@ -199,6 +203,8 @@ export type BeforeOperationArg<TOperationGeneric extends CollectionSlug> = {
         | Parameters<OperationMap<TOperationGeneric>['findByID']>[0]
       /**
        * @deprecated Use 'find' or 'findByID' operation instead
+       *
+       * TODO: v4 - remove this union option
        */
       operation: 'read'
     }
@@ -232,11 +238,16 @@ export type BeforeOperationArg<TOperationGeneric extends CollectionSlug> = {
     }
   | {
       args: Parameters<OperationMap<TOperationGeneric>['findDistinct']>[0]
-      operation: 'findDistinct'
+      /**
+       * @deprecated Use 'findDistinct' operation instead
+       *
+       * TODO: v4 - remove this union option
+       */
+      operation: 'readDistinct'
     }
   | {
       args: Parameters<OperationMap<TOperationGeneric>['findDistinct']>[0]
-      operation: 'readDistinct'
+      operation: 'findDistinct'
     }
   | {
       args: Parameters<OperationMap<TOperationGeneric>['findVersionByID']>[0]

test/hooks/collections/BeforeOperation/index.ts

@@ -0,0 +1,32 @@
+import type { CollectionConfig } from 'payload'
+
+export const beforeOperationSlug = 'beforeOperation'
+
+// Store the last operation for testing
+let lastOperation: string | undefined
+
+export const BeforeOperationCollection: CollectionConfig = {
+  slug: beforeOperationSlug,
+  versions: {
+    drafts: true,
+  },
+  hooks: {
+    beforeOperation: [
+      ({ operation }) => {
+        // Store operation for testing
+        lastOperation = operation
+      },
+    ],
+  },
+  fields: [
+    {
+      name: 'category',
+      type: 'text',
+    },
+  ],
+}
+
+export const getLastOperation = () => lastOperation
+export const clearLastOperation = () => {
+  lastOperation = undefined
+}

test/hooks/config.ts

@@ -13,6 +13,7 @@ import {
   BeforeDelete2Collection,
   BeforeDeleteCollection,
 } from './collections/BeforeDelete/index.js'
+import { BeforeOperationCollection } from './collections/BeforeOperation/index.js'
 import { BeforeValidateCollection } from './collections/BeforeValidate/index.js'
 import ChainingHooks from './collections/ChainingHooks/index.js'
 import ContextHooks from './collections/ContextHooks/index.js'
@@ -34,6 +35,7 @@ export const HooksConfig: Promise<SanitizedConfig> = buildConfigWithDefaults({
     },
   },
   collections: [
+    BeforeOperationCollection,
     BeforeChangeHooks,
     BeforeValidateCollection,
     AfterOperationCollection,

test/hooks/int.spec.ts

@@ -10,6 +10,11 @@ import { devUser, regularUser } from '../credentials.js'
 import { initPayloadInt } from '../helpers/initPayloadInt.js'
 import { isMongoose } from '../helpers/isMongoose.js'
 import { afterOperationSlug } from './collections/AfterOperation/index.js'
+import {
+  beforeOperationSlug,
+  clearLastOperation,
+  getLastOperation,
+} from './collections/BeforeOperation/index.js'
 import { chainingHooksSlug } from './collections/ChainingHooks/index.js'
 import { contextHooksSlug } from './collections/ContextHooks/index.js'
 import { dataHooksSlug } from './collections/Data/index.js'
@@ -743,4 +748,241 @@ describe('Hooks', () => {
       expect(updateResult).toBeDefined()
     })
   })
+
+  describe('beforeOperation', () => {
+    afterEach(() => {
+      clearLastOperation()
+    })
+
+    it('should pass correct operation arg on create', async () => {
+      await payload.create({
+        collection: beforeOperationSlug,
+        data: {},
+      })
+
+      expect(getLastOperation()).toEqual('create')
+    })
+
+    it('should pass correct operation arg on update', async () => {
+      const doc = await payload.create({
+        collection: beforeOperationSlug,
+        data: {},
+      })
+
+      await payload.update({
+        id: doc.id,
+        collection: beforeOperationSlug,
+        data: {},
+      })
+
+      expect(getLastOperation()).toEqual('update')
+    })
+
+    it('should pass correct operation arg on updateByID', async () => {
+      const doc = await payload.create({
+        collection: beforeOperationSlug,
+        data: {},
+      })
+
+      await payload.update({
+        id: doc.id,
+        collection: beforeOperationSlug,
+        data: {},
+      })
+
+      expect(getLastOperation()).toEqual('update')
+    })
+
+    it('should pass correct operation arg on read (findByID)', async () => {
+      const doc = await payload.create({
+        collection: beforeOperationSlug,
+        data: {},
+      })
+
+      await payload.findByID({
+        id: doc.id,
+        collection: beforeOperationSlug,
+      })
+
+      expect(getLastOperation()).toEqual('read')
+    })
+
+    it('should pass correct operation arg on read (find)', async () => {
+      await payload.create({
+        collection: beforeOperationSlug,
+        data: {},
+      })
+
+      clearLastOperation()
+
+      await payload.find({
+        collection: beforeOperationSlug,
+      })
+
+      expect(getLastOperation()).toEqual('read')
+    })
+
+    it('should pass correct operation arg on readDistinct (findDistinct)', async () => {
+      await payload.create({
+        collection: beforeOperationSlug,
+        data: { category: 'test1' },
+      })
+      await payload.create({
+        collection: beforeOperationSlug,
+        data: { category: 'test2' },
+      })
+      await payload.create({
+        collection: beforeOperationSlug,
+        data: { category: 'test1' },
+      })
+
+      await payload.findDistinct({
+        collection: beforeOperationSlug,
+        field: 'category',
+      })
+
+      expect(getLastOperation()).toEqual('readDistinct')
+    })
+
+    it('should pass correct operation arg on delete', async () => {
+      const doc = await payload.create({
+        collection: beforeOperationSlug,
+        data: {},
+      })
+
+      await payload.delete({
+        id: doc.id,
+        collection: beforeOperationSlug,
+      })
+
+      expect(getLastOperation()).toEqual('delete')
+    })
+
+    it('should pass correct operation arg on deleteByID', async () => {
+      const doc = await payload.create({
+        collection: beforeOperationSlug,
+        data: {},
+      })
+
+      await payload.delete({
+        id: doc.id,
+        collection: beforeOperationSlug,
+      })
+
+      expect(getLastOperation()).toEqual('delete')
+    })
+
+    it('should pass correct operation arg on count', async () => {
+      await payload.create({
+        collection: beforeOperationSlug,
+        data: {},
+      })
+
+      await payload.count({
+        collection: beforeOperationSlug,
+      })
+
+      expect(getLastOperation()).toEqual('count')
+    })
+
+    it('should pass correct operation arg on countVersions', async () => {
+      const doc = await payload.create({
+        collection: beforeOperationSlug,
+        data: {},
+      })
+
+      await payload.countVersions({
+        collection: beforeOperationSlug,
+        where: {
+          parent: {
+            equals: doc.id,
+          },
+        },
+      })
+
+      expect(getLastOperation()).toEqual('countVersions')
+    })
+
+    it('should pass correct operation arg on findVersions', async () => {
+      const doc = await payload.create({
+        collection: beforeOperationSlug,
+        data: {},
+      })
+
+      await payload.findVersions({
+        collection: beforeOperationSlug,
+        where: {
+          parent: {
+            equals: doc.id,
+          },
+        },
+      })
+
+      expect(getLastOperation()).toEqual('read')
+    })
+
+    it('should pass correct operation arg on findVersionByID', async () => {
+      const doc = await payload.create({
+        collection: beforeOperationSlug,
+        data: { category: 'v1' },
+      })
+
+      // Update to create a version
+      await payload.update({
+        id: doc.id,
+        collection: beforeOperationSlug,
+        data: { category: 'v2' },
+      })
+
+      const versions = await payload.findVersions({
+        collection: beforeOperationSlug,
+        where: {
+          parent: {
+            equals: doc.id,
+          },
+        },
+      })
+
+      expect(versions.docs.length).toBeGreaterThan(0)
+
+      await payload.findVersionByID({
+        collection: beforeOperationSlug,
+        id: versions.docs[0]!.id,
+      })
+
+      expect(getLastOperation()).toEqual('read')
+    })
+
+    it('should pass correct operation arg on restoreVersion', async () => {
+      const doc = await payload.create({
+        collection: beforeOperationSlug,
+        data: { category: 'v1' },
+      })
+
+      // Update to create a version
+      await payload.update({
+        id: doc.id,
+        collection: beforeOperationSlug,
+        data: { category: 'v2' },
+      })
+
+      const versions = await payload.findVersions({
+        collection: beforeOperationSlug,
+        where: {
+          parent: {
+            equals: doc.id,
+          },
+        },
+      })
+
+      expect(versions.docs.length).toBeGreaterThan(0)
+
+      await payload.restoreVersion({
+        collection: beforeOperationSlug,
+        id: versions.docs[0]!.id,
+      })
+
+      expect(getLastOperation()).toEqual('restoreVersion')
+    })
+  })
 })