Fix client side filters not being applied for actionMode

emmatown · emmatown · commit f8c96485b98e · 2026-03-13T09:57:07.000+10:00
diff --git a/examples/usecase-versioning/schema.graphql b/examples/usecase-versioning/schema.graphql
@@ -121,17 +121,13 @@ type Mutation {
   updatePosts(data: [PostUpdateArgs!]!): [Post]
   deletePost(where: PostWhereUniqueInput!): Post
   deletePosts(where: [PostWhereUniqueInput!]!): [Post]
-  publishPost(where: PostWhereUniqueInput!, data: PublishPostData!): Post
+  publishPost(where: PostWhereUniqueInput!, data: PostUpdateInput!): Post
   publishPosts(data: [PublishPostArgs!]!): [Post]
 }
 
-input PublishPostData {
-  version: Int!
-}
-
 input PublishPostArgs {
   where: PostWhereUniqueInput!
-  data: PublishPostData!
+  data: PostUpdateInput!
 }
 
 type Query {
diff --git a/examples/usecase-versioning/schema.ts b/examples/usecase-versioning/schema.ts
@@ -50,25 +50,34 @@ export const lists = {
         },
       }),
     },
+    hooks: {
+      validate: ({ item, resolvedData, addValidationError }) => {
+        const resolvedIsPublished = resolvedData?.isPublished ?? item?.isPublished
+        const resolvedContent = resolvedData?.content ?? item?.content
+        if (resolvedIsPublished && !resolvedContent) {
+          addValidationError('Cannot publish a post without content')
+        }
+      },
+    },
     actions: {
       publish: action({
         access: allowAll,
         ui: {
           label: 'Publish',
-          itemView: { actionMode: { enabled: true } },
+          itemView: {
+            actionMode: {
+              enabled: { content: { not: { equals: '' } }, isPublished: { equals: false } },
+              disabled: { isPublished: { equals: false } },
+            },
+          },
         },
         graphql: {
-          __data: {
-            version: true,
-          },
+          __data: true,
         },
         resolve: async ({ where, data }, context) => {
           return context.sudo().db.Post.updateOne({
             where,
-            data: {
-              isPublished: true,
-              version: data.version,
-            },
+            data: { ...data, isPublished: true },
           })
         },
       }),
diff --git a/packages/core/src/___internal-do-not-use-will-break-in-patch/admin-ui/pages/ItemPage/index.tsx b/packages/core/src/___internal-do-not-use-will-break-in-patch/admin-ui/pages/ItemPage/index.tsx
@@ -29,7 +29,9 @@ import { useList, useListItem } from '../../../../admin-ui/context'
 import {
   deserializeItemToValue,
   Fields,
+  resolveConditionalActionMode,
   serializeValueToOperationItem,
+  serializeItemForConditionalFilters,
   useHasChanges,
   useInvalidFields,
 } from '../../../../admin-ui/utils'
@@ -328,17 +330,19 @@ function ItemPage({ listKey }: ItemPageProps) {
     setValue(initialValue)
   }, [initialValue])
 
-  const { actionsInContext, fieldModes, fieldPositions, isRequireds } = useMemo(() => {
-    const actionModes = Object.fromEntries(
-      Object.entries(list.actions).map(([k, v]) => [k, v.itemView.actionMode])
-    )
-    const fieldModes = Object.fromEntries(
-      Object.entries(list.fields).map(([k, v]) => [k, v.itemView.fieldMode])
-    )
-    const fieldPositions = Object.fromEntries(
+  const { actionModes, fieldModes, fieldPositions, isRequireds } = useMemo(() => {
+    const actionModes: Record<
+      string,
+      ConditionalFilter<'enabled' | 'disabled' | 'hidden', BaseListTypeInfo>
+    > = Object.fromEntries(list.actions.map(action => [action.key, action.itemView.actionMode]))
+    const fieldModes: Record<
+      string,
+      ConditionalFilter<'edit' | 'read' | 'hidden', BaseListTypeInfo>
+    > = Object.fromEntries(Object.entries(list.fields).map(([k, v]) => [k, v.itemView.fieldMode]))
+    const fieldPositions: Record<string, 'form' | 'sidebar'> = Object.fromEntries(
       Object.entries(list.fields).map(([k, v]) => [k, v.itemView.fieldPosition])
     )
-    const isRequireds = Object.fromEntries(
+    const isRequireds: Record<string, ConditionalFilterCase<BaseListTypeInfo>> = Object.fromEntries(
       Object.entries(list.fields).map(([k, v]) => [k, v.itemView.isRequired])
     )
     for (const field of data?.keystone?.adminMeta?.list?.fields ?? []) {
@@ -359,24 +363,32 @@ function ItemPage({ listKey }: ItemPageProps) {
       actionModes[action.key] = action.itemView.actionMode
     }
 
-    // actions within context of an item
-    const actionsInContext = list.actions
+    return {
+      actionModes,
+      fieldModes,
+      fieldPositions,
+      isRequireds,
+    }
+  }, [
+    data?.keystone?.adminMeta?.list?.actions,
+    data?.keystone?.adminMeta?.list?.fields,
+    list.actions,
+    list.fields,
+  ])
+
+  const actionsInContext = useMemo(() => {
+    if (!value) return []
+    const serializedValue = serializeItemForConditionalFilters(list.fields, value)
+    return list.actions
       .map(action => ({
         ...action,
         itemView: {
           ...action.itemView,
-          actionMode: actionModes[action.key],
+          actionMode: resolveConditionalActionMode(actionModes[action.key], serializedValue),
         },
       }))
       .filter(action => action.itemView.actionMode !== 'hidden')
-
-    return {
-      actionsInContext,
-      fieldModes,
-      fieldPositions,
-      isRequireds,
-    }
-  }, [data?.keystone?.adminMeta, list.fields])
+  }, [actionModes, list.actions, value])
 
   function onAction(action: ActionMeta, resultId: string | null) {
     const { navigation } = action.itemView
diff --git a/packages/core/src/admin-ui/utils/Fields.tsx b/packages/core/src/admin-ui/utils/Fields.tsx
@@ -17,35 +17,7 @@ import type {
   FieldMeta,
 } from '../../types'
 import { EmptyState } from '../components/EmptyState'
-
-// with implicit ANDing
-function applyFilter<T>(
-  filter: {
-    equals?: T
-    in?: T[]
-  },
-  val: T
-): boolean {
-  if (filter.equals !== undefined && val !== filter.equals) return false
-  if (filter.in !== undefined && !filter.in.includes(val)) return false
-  return true
-}
-export function testFilter(
-  filter: ConditionalFilterCase<BaseListTypeInfo> | undefined,
-  serialized: Record<string, unknown>
-): boolean {
-  if (filter === undefined) return false
-  if (typeof filter === 'boolean') return filter
-  for (const [key, filterOnField] of Object.entries(filter)) {
-    if (!filterOnField) continue
-    const serializedValue = serialized[key]
-    if (!applyFilter(filterOnField, serializedValue)) return false
-    if (filterOnField.not !== undefined && applyFilter(filterOnField.not, serializedValue)) {
-      return false
-    }
-  }
-  return true
-}
+import { serializeItemForConditionalFilters, testFilter } from './conditionalFilters'
 
 export function Fields({
   view,
@@ -74,10 +46,7 @@ export function Fields({
 }) {
   const fieldDomByKey: Record<string, ReactNode> = {}
   let focused = false
-  const serialized: Record<string, unknown> = {}
-  for (const [fieldKey, field] of Object.entries(fields)) {
-    Object.assign(serialized, field.controller.serialize(itemValue[fieldKey]))
-  }
+  const serialized = serializeItemForConditionalFilters(fields, itemValue)
   for (const fieldKey in fields) {
     const field = fields[fieldKey]
     const fieldPosition = fieldPositions[fieldKey] ?? field.itemView.fieldPosition
diff --git a/packages/core/src/admin-ui/utils/conditionalFilters.test.ts b/packages/core/src/admin-ui/utils/conditionalFilters.test.ts
@@ -0,0 +1,76 @@
+import {
+  resolveConditionalActionMode,
+  serializeItemForConditionalFilters,
+} from './conditionalFilters'
+
+test('resolveConditionalActionMode prioritises enabled before disabled and hidden', () => {
+  expect(
+    resolveConditionalActionMode(
+      {
+        enabled: { status: { equals: 'published' } },
+        disabled: { status: { equals: 'published' } },
+        hidden: true,
+      },
+      { status: 'published' }
+    )
+  ).toBe('enabled')
+})
+
+test('resolveConditionalActionMode returns disabled when enabled does not match', () => {
+  expect(
+    resolveConditionalActionMode(
+      {
+        enabled: { status: { equals: 'published' } },
+        disabled: { status: { equals: 'archived' } },
+      },
+      { status: 'archived' }
+    )
+  ).toBe('disabled')
+})
+
+test('resolveConditionalActionMode falls through to hidden when only hidden matches', () => {
+  expect(
+    resolveConditionalActionMode(
+      {
+        enabled: { status: { equals: 'published' } },
+        disabled: { status: { equals: 'archived' } },
+        hidden: { status: { equals: 'draft' } },
+      },
+      { status: 'draft' }
+    )
+  ).toBe('hidden')
+})
+
+test('serialised values reflect unsaved edits when resolving action modes', () => {
+  const fields = {
+    status: {
+      controller: {
+        serialize(value: unknown) {
+          return { status: value }
+        },
+      },
+    },
+  }
+
+  const initialSerialized = serializeItemForConditionalFilters(fields, { status: 'draft' })
+  expect(
+    resolveConditionalActionMode(
+      {
+        enabled: { status: { equals: 'published' } },
+      },
+      initialSerialized
+    )
+  ).toBe('hidden')
+
+  const editedSerialized = serializeItemForConditionalFilters(fields, {
+    status: 'published',
+  })
+  expect(
+    resolveConditionalActionMode(
+      {
+        enabled: { status: { equals: 'published' } },
+      },
+      editedSerialized
+    )
+  ).toBe('enabled')
+})
diff --git a/packages/core/src/admin-ui/utils/conditionalFilters.ts b/packages/core/src/admin-ui/utils/conditionalFilters.ts
@@ -0,0 +1,62 @@
+import type { BaseListTypeInfo, ConditionalFilter, ConditionalFilterCase } from '../../types'
+
+type SerializedItem = Record<string, unknown>
+type SerializableFields = Record<
+  string,
+  {
+    controller: {
+      serialize(value: unknown): Record<string, unknown>
+    }
+  }
+>
+
+// with implicit ANDing
+function applyFilter<T>(
+  filter: {
+    equals?: T
+    in?: T[]
+  },
+  val: T
+): boolean {
+  if (filter.equals !== undefined && val !== filter.equals) return false
+  if (filter.in !== undefined && !filter.in.includes(val)) return false
+  return true
+}
+
+export function testFilter(
+  filter: ConditionalFilterCase<BaseListTypeInfo> | undefined,
+  serialized: SerializedItem
+): boolean {
+  if (filter === undefined) return false
+  if (typeof filter === 'boolean') return filter
+  for (const [key, filterOnField] of Object.entries(filter)) {
+    if (!filterOnField) continue
+    const serializedValue = serialized[key]
+    if (!applyFilter(filterOnField, serializedValue)) return false
+    if (filterOnField.not !== undefined && applyFilter(filterOnField.not, serializedValue)) {
+      return false
+    }
+  }
+  return true
+}
+
+export function serializeItemForConditionalFilters(
+  fields: SerializableFields,
+  itemValue: Record<string, unknown>
+): SerializedItem {
+  const serialized: SerializedItem = {}
+  for (const [fieldKey, field] of Object.entries(fields)) {
+    Object.assign(serialized, field.controller.serialize(itemValue[fieldKey]))
+  }
+  return serialized
+}
+
+export function resolveConditionalActionMode(
+  actionMode: ConditionalFilter<'enabled' | 'disabled' | 'hidden', BaseListTypeInfo>,
+  serialized: SerializedItem
+): 'enabled' | 'disabled' | 'hidden' {
+  if (typeof actionMode === 'string') return actionMode
+  if (testFilter(actionMode.enabled, serialized)) return 'enabled'
+  if (testFilter(actionMode.disabled, serialized)) return 'disabled'
+  return 'hidden'
+}
diff --git a/packages/core/src/admin-ui/utils/index.ts b/packages/core/src/admin-ui/utils/index.ts
@@ -1,4 +1,5 @@
 export * from './Fields'
+export * from './conditionalFilters'
 export * from './utils'
 export * from './useCreateItem'
 
diff --git a/packages/core/src/admin-ui/utils/utils.tsx b/packages/core/src/admin-ui/utils/utils.tsx
@@ -8,7 +8,7 @@ import type {
   FieldController,
   FieldMeta,
 } from '../../types'
-import { testFilter } from './Fields'
+import { serializeItemForConditionalFilters, testFilter } from './conditionalFilters'
 
 function extractRootFields(selectedFields: Set<string>, selectionSet: SelectionSetNode) {
   selectionSet.selections.forEach(selection => {
@@ -37,10 +37,7 @@ export function useInvalidFields(
 ): ReadonlySet<string> {
   return useMemo(() => {
     const invalidFields = new Set<string>()
-    const serialized: Record<string, unknown> = {}
-    for (const [fieldKey, field] of Object.entries(fields)) {
-      Object.assign(serialized, field.controller.serialize(item[fieldKey]))
-    }
+    const serialized = serializeItemForConditionalFilters(fields, item)
 
     for (const fieldKey in item) {
       const validateFn = fields[fieldKey]?.controller?.validate
diff --git a/packages/core/src/lib/admin-meta-graphql.ts b/packages/core/src/lib/admin-meta-graphql.ts
@@ -327,7 +327,10 @@ const KeystoneAdminUIListMeta = g.object<ListMetaSource>()({
       type: g.nonNull(g.list(g.nonNull(KeystoneAdminUIFieldMeta))),
     }),
     groups: g.field({ type: g.nonNull(g.list(g.nonNull(KeystoneAdminUIFieldGroupMeta))) }),
-    actions: g.field({ type: g.nonNull(g.list(g.nonNull(KeystoneAdminUIActionMeta))) }),
+    actions: g.field({
+      resolve: ({ actions, item }) => actions.map(action => ({ ...action, item })),
+      type: g.nonNull(g.list(g.nonNull(KeystoneAdminUIActionMeta))),
+    }),
     graphql: g.field({ type: g.nonNull(KeystoneAdminUIGraphQL) }),
 
     pageSize: g.field({ type: g.nonNull(g.Int) }),
diff --git a/tests/api-tests/actions-graphql-data.test.ts b/tests/api-tests/actions-graphql-data.test.ts

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`export * from './Fields'`
	`2`	`+export * from './conditionalFilters'`
`2`	`3`	`export * from './utils'`
`3`	`4`	`export * from './useCreateItem'`
`4`	`5`