@nixxie-cms/core 1.0.3 → 1.1.0

package/src/admin-ui/utils/filters.ts

@@ -1,148 +1,148 @@
-import type {
-  ActionMeta,
-  BaseListTypeInfo,
-  ConditionalFilter,
-  ConditionalFilterCase,
-  FieldMeta,
-} from '../../types'
-
-type SerializedItem = Record<string, unknown>
-type FieldFilter = {
-  equals?: unknown
-  in?: unknown[]
-  not?: {
-    equals?: unknown
-    in?: unknown[]
-  }
-}
-
-function isConditionalFilterOperator(key: string): key is 'AND' | 'OR' | 'NOT' {
-  return key === 'AND' || key === 'OR' || key === 'NOT'
-}
-
-function isFieldFilter(value: unknown): value is FieldFilter {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-function applyFilter<T>(
-  filter: {
-    equals?: T
-    in?: T[]
-  },
-  value: T
-): boolean {
-  // WARNING: this is implicit AND
-  if (filter.equals !== undefined && value !== filter.equals) return false
-  if (filter.in !== undefined && !filter.in.includes(value)) 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
-
-  if (filter.AND !== undefined && !filter.AND.every(filter => testFilter(filter, serialized))) {
-    return false
-  }
-  if (filter.OR !== undefined && !filter.OR.some(filter => testFilter(filter, serialized))) {
-    return false
-  }
-  if (filter.NOT !== undefined && testFilter(filter.NOT, serialized)) {
-    return false
-  }
-
-  for (const [key, fieldFilter] of Object.entries(filter)) {
-    if (!isFieldFilter(fieldFilter)) continue
-    if (isConditionalFilterOperator(key)) continue
-
-    const serializedValue = serialized[key]
-    if (!applyFilter(fieldFilter, serializedValue)) return false
-    if (fieldFilter.not !== undefined && applyFilter(fieldFilter.not, serializedValue)) {
-      return false
-    }
-  }
-  return true
-}
-
-export function serializeItemForConditionalFilters(
-  fields: Record<string, FieldMeta>,
-  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 resolveActionMode(
-  actionMode: ConditionalFilter<
-    'enabled' | 'disabled' | 'hidden',
-    'disabled' | 'hidden',
-    BaseListTypeInfo
-  >,
-  serialized: SerializedItem
-): 'enabled' | 'disabled' | 'hidden' {
-  if (typeof actionMode === 'string') return actionMode
-  if (testFilter(actionMode.hidden, serialized)) return 'hidden'
-  if (testFilter(actionMode.disabled, serialized)) return 'disabled'
-  return 'enabled'
-}
-
-export function resolveFieldMode(
-  fieldMode: ConditionalFilter<'edit' | 'read' | 'hidden', 'read' | 'hidden', BaseListTypeInfo>,
-  serialized: SerializedItem,
-  view: 'createView' | 'itemView'
-) {
-  if (typeof fieldMode === 'string') return fieldMode
-  if (testFilter(fieldMode.hidden, serialized)) return 'hidden'
-  if (view === 'itemView' && testFilter(fieldMode.read, serialized)) return 'read'
-  return 'edit'
-}
-
-export function isActionAvailable(
-  action: ActionMeta,
-  { actionMode }: ActionMeta['listView'] | ActionMeta['itemView']
-): boolean {
-  if (action.graphql.arguments.some(a => !a.source)) return false
-
-  // conditional filters cannot be prefiltered ahead of time
-  if (typeof actionMode !== 'string') return true
-  return actionMode !== 'hidden'
-}
-
-export function getConditionalFilterFieldKeys(
-  actionMode: ConditionalFilter<string, string, BaseListTypeInfo>
-): string[] {
-  if (typeof actionMode === 'string') return []
-
-  const fieldKeys = new Set<string>()
-
-  function collectFieldKeys(filter: ConditionalFilterCase<BaseListTypeInfo> | undefined) {
-    if (!filter || typeof filter !== 'object') return
-
-    if (filter.AND !== undefined) {
-      filter.AND.forEach(collectFieldKeys)
-    }
-    if (filter.OR !== undefined) {
-      filter.OR.forEach(collectFieldKeys)
-    }
-    if (filter.NOT !== undefined) {
-      collectFieldKeys(filter.NOT)
-    }
-
-    for (const key of Object.keys(filter)) {
-      if (isConditionalFilterOperator(key)) continue
-      fieldKeys.add(key)
-    }
-  }
-
-  for (const conditionalFilter of Object.values(actionMode)) {
-    collectFieldKeys(conditionalFilter)
-  }
-
-  return [...fieldKeys]
-}
+import type {
+  ActionMeta,
+  BaseCollectionTypeInfo,
+  ConditionalFilter,
+  ConditionalFilterCase,
+  FieldMeta,
+} from '../../types'
+
+type SerializedItem = Record<string, unknown>
+type FieldFilter = {
+  equals?: unknown
+  in?: unknown[]
+  not?: {
+    equals?: unknown
+    in?: unknown[]
+  }
+}
+
+function isConditionalFilterOperator(key: string): key is 'AND' | 'OR' | 'NOT' {
+  return key === 'AND' || key === 'OR' || key === 'NOT'
+}
+
+function isFieldFilter(value: unknown): value is FieldFilter {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function applyFilter<T>(
+  filter: {
+    equals?: T
+    in?: T[]
+  },
+  value: T
+): boolean {
+  // WARNING: this is implicit AND
+  if (filter.equals !== undefined && value !== filter.equals) return false
+  if (filter.in !== undefined && !filter.in.includes(value)) return false
+  return true
+}
+
+export function testFilter(
+  filter: ConditionalFilterCase<BaseCollectionTypeInfo> | undefined,
+  serialized: SerializedItem
+): boolean {
+  if (filter === undefined) return false
+  if (typeof filter === 'boolean') return filter
+
+  if (filter.AND !== undefined && !filter.AND.every(filter => testFilter(filter, serialized))) {
+    return false
+  }
+  if (filter.OR !== undefined && !filter.OR.some(filter => testFilter(filter, serialized))) {
+    return false
+  }
+  if (filter.NOT !== undefined && testFilter(filter.NOT, serialized)) {
+    return false
+  }
+
+  for (const [key, fieldFilter] of Object.entries(filter)) {
+    if (!isFieldFilter(fieldFilter)) continue
+    if (isConditionalFilterOperator(key)) continue
+
+    const serializedValue = serialized[key]
+    if (!applyFilter(fieldFilter, serializedValue)) return false
+    if (fieldFilter.not !== undefined && applyFilter(fieldFilter.not, serializedValue)) {
+      return false
+    }
+  }
+  return true
+}
+
+export function serializeItemForConditionalFilters(
+  fields: Record<string, FieldMeta>,
+  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 resolveActionMode(
+  actionMode: ConditionalFilter<
+    'enabled' | 'disabled' | 'hidden',
+    'disabled' | 'hidden',
+    BaseCollectionTypeInfo
+  >,
+  serialized: SerializedItem
+): 'enabled' | 'disabled' | 'hidden' {
+  if (typeof actionMode === 'string') return actionMode
+  if (testFilter(actionMode.hidden, serialized)) return 'hidden'
+  if (testFilter(actionMode.disabled, serialized)) return 'disabled'
+  return 'enabled'
+}
+
+export function resolveFieldMode(
+  fieldMode: ConditionalFilter<'edit' | 'read' | 'hidden', 'read' | 'hidden', BaseCollectionTypeInfo>,
+  serialized: SerializedItem,
+  view: 'createView' | 'itemView'
+) {
+  if (typeof fieldMode === 'string') return fieldMode
+  if (testFilter(fieldMode.hidden, serialized)) return 'hidden'
+  if (view === 'itemView' && testFilter(fieldMode.read, serialized)) return 'read'
+  return 'edit'
+}
+
+export function isActionAvailable(
+  action: ActionMeta,
+  { actionMode }: ActionMeta['listView'] | ActionMeta['itemView']
+): boolean {
+  if (action.graphql.arguments.some(a => !a.source)) return false
+
+  // conditional filters cannot be prefiltered ahead of time
+  if (typeof actionMode !== 'string') return true
+  return actionMode !== 'hidden'
+}
+
+export function getConditionalFilterFieldKeys(
+  actionMode: ConditionalFilter<string, string, BaseCollectionTypeInfo>
+): string[] {
+  if (typeof actionMode === 'string') return []
+
+  const fieldKeys = new Set<string>()
+
+  function collectFieldKeys(filter: ConditionalFilterCase<BaseCollectionTypeInfo> | undefined) {
+    if (!filter || typeof filter !== 'object') return
+
+    if (filter.AND !== undefined) {
+      filter.AND.forEach(collectFieldKeys)
+    }
+    if (filter.OR !== undefined) {
+      filter.OR.forEach(collectFieldKeys)
+    }
+    if (filter.NOT !== undefined) {
+      collectFieldKeys(filter.NOT)
+    }
+
+    for (const key of Object.keys(filter)) {
+      if (isConditionalFilterOperator(key)) continue
+      fieldKeys.add(key)
+    }
+  }
+
+  for (const conditionalFilter of Object.values(actionMode)) {
+    collectFieldKeys(conditionalFilter)
+  }
+
+  return [...fieldKeys]
+}

package/src/admin-ui/utils/useCreateItem.ts

@@ -1,171 +1,171 @@
-import { useRouter } from 'next/router'
-import { type ComponentProps, useEffect, useMemo, useRef, useState } from 'react'
-
-import { toastQueue } from '@keystar/ui/toast'
-
-import type { Fields } from '.'
-import {
-  makeDefaultValueState,
-  serializeValueToOperationItem,
-  useHasChanges,
-  useInvalidFields,
-} from '../../admin-ui/utils'
-import type { ListMeta } from '../../types'
-import { type ErrorLike, gql, type TypedDocumentNode, useMutation } from '../apollo'
-import { usePreventNavigation } from './usePreventNavigation'
-
-type CreateItemHookResult = {
-  state: 'editing' | 'loading' | 'created'
-  shouldPreventNavigation: boolean
-  error?: ErrorLike
-  props: ComponentProps<typeof Fields>
-  create: () => Promise<{ id: string; label: string | null } | undefined>
-}
-
-export function useCreateItem(list: ListMeta): CreateItemHookResult {
-  const router = useRouter()
-  const [tryCreateItem, { loading, error, data: returnedData }] = useMutation(
-    gql`mutation($data: ${list.graphql.names.createInputName}!) {
-      item: ${list.graphql.names.createMutationName}(data: $data) {
-        id
-        label: ${list.labelField}
-      }
-    }` as TypedDocumentNode<
-      { item: { id: string; label: string | null } },
-      { data: Record<string, unknown> }
-    >
-  )
-
-  const isRequireds = useMemo(
-    () =>
-      Object.fromEntries(
-        Object.entries(list.fields).map(([key, field]) => [key, field.createView.isRequired])
-      ),
-    [list.fields]
-  )
-
-  const [forceValidation, setForceValidation] = useState(false)
-  const [value, setValue] = useState(() => makeDefaultValueState(list.fields))
-  const invalidFields = useInvalidFields(list.fields, value, isRequireds)
-
-  const hasChangedFields = useHasChanges(
-    'create',
-    list.fields,
-    value,
-    makeDefaultValueState(list.fields)
-  )
-  const shouldPreventNavigation = !returnedData?.item && hasChangedFields
-  const shouldPreventNavigationRef = useRef(shouldPreventNavigation)
-
-  useEffect(() => {
-    shouldPreventNavigationRef.current = shouldPreventNavigation
-  }, [shouldPreventNavigation])
-  usePreventNavigation(shouldPreventNavigationRef)
-
-  return {
-    state: loading ? 'loading' : !returnedData?.item ? 'created' : 'editing',
-    shouldPreventNavigation,
-    error,
-    props: {
-      view: 'createView',
-      position: 'form',
-      fields: list.fields,
-      groups: list.groups,
-      forceValidation,
-      invalidFields,
-      value,
-      isRequireds,
-      onChange: newItemValue => setValue(newItemValue),
-    },
-    async create(): Promise<{ id: string; label: string | null } | undefined> {
-      const newForceValidation = invalidFields.size !== 0
-      setForceValidation(newForceValidation)
-
-      if (newForceValidation) return
-
-      let outputData: { item: { id: string; label: string | null } }
-      try {
-        outputData = await tryCreateItem({
-          variables: {
-            data: serializeValueToOperationItem('create', list.fields, value),
-          },
-          update(cache, { data }) {
-            if (typeof data?.item?.id === 'string') {
-              cache.evict({
-                id: 'ROOT_QUERY',
-                fieldName: `${list.graphql.names.itemQueryName}(${JSON.stringify({
-                  where: { id: data.item.id },
-                })})`,
-              })
-            }
-          },
-        }).then(x => {
-          if (x.data) return x.data
-          if (x.error) throw x.error
-          throw new Error('Something went wrong during item creation.')
-        })
-      } catch {
-        toastQueue.critical(`Unable to create ${list.singular.toLocaleLowerCase()}`)
-        return
-      }
-
-      shouldPreventNavigationRef.current = false
-      toastQueue.positive(`${list.singular} created`, {
-        timeout: 5000,
-        actionLabel: 'Create another',
-        onAction: () => {
-          router.push(`/${list.path}/create`)
-        },
-        shouldCloseOnAction: true,
-      })
-
-      return outputData.item
-    },
-  }
-}
-
-type BuildItemHookResult = {
-  state: 'editing'
-  error?: ErrorLike
-  props: ComponentProps<typeof Fields>
-  build: () => Promise<Record<string, unknown> | undefined>
-}
-
-export function useBuildItem(list: ListMeta, fieldKeys: string[] = []): BuildItemHookResult {
-  const [forceValidation, setForceValidation] = useState(false)
-  const [value, setValue] = useState(() => makeDefaultValueState(list.fields))
-  const fields = fieldKeys.length
-    ? Object.fromEntries(Object.entries(list.fields).filter(([key]) => fieldKeys.includes(key)))
-    : list.fields
-
-  const isRequireds = useMemo(
-    () =>
-      Object.fromEntries(
-        Object.entries(list.fields).map(([key, field]) => [key, field.createView.isRequired])
-      ),
-    [list.fields]
-  )
-
-  const invalidFields = useInvalidFields(list.fields, value, isRequireds)
-
-  return {
-    state: 'editing',
-    props: {
-      view: 'createView',
-      position: 'form',
-      fields,
-      groups: list.groups,
-      forceValidation,
-      invalidFields,
-      value,
-      isRequireds,
-      onChange: newItemValue => setValue(newItemValue),
-    },
-    async build() {
-      const newForceValidation = invalidFields.size !== 0
-      setForceValidation(newForceValidation)
-      if (newForceValidation) return
-      return serializeValueToOperationItem('create', list.fields, value)
-    },
-  }
-}
+import { useRouter } from 'next/router'
+import { type ComponentProps, useEffect, useMemo, useRef, useState } from 'react'
+
+import { toastQueue } from '@keystar/ui/toast'
+
+import type { Fields } from '.'
+import {
+  makeDefaultValueState,
+  serializeValueToOperationItem,
+  useHasChanges,
+  useInvalidFields,
+} from '../../admin-ui/utils'
+import type { CollectionMeta } from '../../types'
+import { type ErrorLike, gql, type TypedDocumentNode, useMutation } from '../apollo'
+import { usePreventNavigation } from './usePreventNavigation'
+
+type CreateItemHookResult = {
+  state: 'editing' | 'loading' | 'created'
+  shouldPreventNavigation: boolean
+  error?: ErrorLike
+  props: ComponentProps<typeof Fields>
+  create: () => Promise<{ id: string; label: string | null } | undefined>
+}
+
+export function useCreateItem(list: CollectionMeta): CreateItemHookResult {
+  const router = useRouter()
+  const [tryCreateItem, { loading, error, data: returnedData }] = useMutation(
+    gql`mutation($data: ${list.graphql.names.createInputName}!) {
+      item: ${list.graphql.names.createMutationName}(data: $data) {
+        id
+        label: ${list.labelField}
+      }
+    }` as TypedDocumentNode<
+      { item: { id: string; label: string | null } },
+      { data: Record<string, unknown> }
+    >
+  )
+
+  const isRequireds = useMemo(
+    () =>
+      Object.fromEntries(
+        Object.entries(list.fields).map(([key, field]) => [key, field.createView.isRequired])
+      ),
+    [list.fields]
+  )
+
+  const [forceValidation, setForceValidation] = useState(false)
+  const [value, setValue] = useState(() => makeDefaultValueState(list.fields))
+  const invalidFields = useInvalidFields(list.fields, value, isRequireds)
+
+  const hasChangedFields = useHasChanges(
+    'create',
+    list.fields,
+    value,
+    makeDefaultValueState(list.fields)
+  )
+  const shouldPreventNavigation = !returnedData?.item && hasChangedFields
+  const shouldPreventNavigationRef = useRef(shouldPreventNavigation)
+
+  useEffect(() => {
+    shouldPreventNavigationRef.current = shouldPreventNavigation
+  }, [shouldPreventNavigation])
+  usePreventNavigation(shouldPreventNavigationRef)
+
+  return {
+    state: loading ? 'loading' : !returnedData?.item ? 'created' : 'editing',
+    shouldPreventNavigation,
+    error,
+    props: {
+      view: 'createView',
+      position: 'form',
+      fields: list.fields,
+      groups: list.groups,
+      forceValidation,
+      invalidFields,
+      value,
+      isRequireds,
+      onChange: newItemValue => setValue(newItemValue),
+    },
+    async create(): Promise<{ id: string; label: string | null } | undefined> {
+      const newForceValidation = invalidFields.size !== 0
+      setForceValidation(newForceValidation)
+
+      if (newForceValidation) return
+
+      let outputData: { item: { id: string; label: string | null } }
+      try {
+        outputData = await tryCreateItem({
+          variables: {
+            data: serializeValueToOperationItem('create', list.fields, value),
+          },
+          update(cache, { data }) {
+            if (typeof data?.item?.id === 'string') {
+              cache.evict({
+                id: 'ROOT_QUERY',
+                fieldName: `${list.graphql.names.itemQueryName}(${JSON.stringify({
+                  where: { id: data.item.id },
+                })})`,
+              })
+            }
+          },
+        }).then(x => {
+          if (x.data) return x.data
+          if (x.error) throw x.error
+          throw new Error('Something went wrong during item creation.')
+        })
+      } catch {
+        toastQueue.critical(`Unable to create ${list.singular.toLocaleLowerCase()}`)
+        return
+      }
+
+      shouldPreventNavigationRef.current = false
+      toastQueue.positive(`${list.singular} created`, {
+        timeout: 5000,
+        actionLabel: 'Create another',
+        onAction: () => {
+          router.push(`/${list.path}/create`)
+        },
+        shouldCloseOnAction: true,
+      })
+
+      return outputData.item
+    },
+  }
+}
+
+type BuildItemHookResult = {
+  state: 'editing'
+  error?: ErrorLike
+  props: ComponentProps<typeof Fields>
+  build: () => Promise<Record<string, unknown> | undefined>
+}
+
+export function useBuildItem(list: CollectionMeta, fieldKeys: string[] = []): BuildItemHookResult {
+  const [forceValidation, setForceValidation] = useState(false)
+  const [value, setValue] = useState(() => makeDefaultValueState(list.fields))
+  const fields = fieldKeys.length
+    ? Object.fromEntries(Object.entries(list.fields).filter(([key]) => fieldKeys.includes(key)))
+    : list.fields
+
+  const isRequireds = useMemo(
+    () =>
+      Object.fromEntries(
+        Object.entries(list.fields).map(([key, field]) => [key, field.createView.isRequired])
+      ),
+    [list.fields]
+  )
+
+  const invalidFields = useInvalidFields(list.fields, value, isRequireds)
+
+  return {
+    state: 'editing',
+    props: {
+      view: 'createView',
+      position: 'form',
+      fields,
+      groups: list.groups,
+      forceValidation,
+      invalidFields,
+      value,
+      isRequireds,
+      onChange: newItemValue => setValue(newItemValue),
+    },
+    async build() {
+      const newForceValidation = invalidFields.size !== 0
+      setForceValidation(newForceValidation)
+      if (newForceValidation) return
+      return serializeValueToOperationItem('create', list.fields, value)
+    },
+  }
+}