@nixxie-cms/core 1.0.3 → 1.1.0

package/src/admin-ui/utils/utils.tsx

@@ -1,127 +1,127 @@
-import isDeepEqual from 'fast-deep-equal'
-import { type FragmentDefinitionNode, type SelectionSetNode, parse } from 'graphql'
-import { useMemo } from 'react'
-
-import type {
-  BaseListTypeInfo,
-  ConditionalFilterCase,
-  FieldController,
-  FieldMeta,
-} from '../../types'
-import { serializeItemForConditionalFilters, testFilter } from './filters'
-
-function extractRootFields(selectedFields: Set<string>, selectionSet: SelectionSetNode) {
-  selectionSet.selections.forEach(selection => {
-    if (selection.kind === 'Field') {
-      selectedFields.add(selection.alias ? selection.alias.value : selection.name.value)
-    }
-    if (selection.kind === 'InlineFragment') {
-      extractRootFields(selectedFields, selection.selectionSet)
-    }
-    // FragmentSpread will never happen for the use cases of getRootFieldsFromSelection
-  })
-}
-
-export function getRootGraphQLFieldsFromFieldController(controller: FieldController<any, any>) {
-  const ast = parse(`fragment X on Y { id, ${controller.graphqlSelection} }`)
-  const selectedFields = new Set<string>()
-  const fragmentNode = ast.definitions[0] as FragmentDefinitionNode
-  extractRootFields(selectedFields, fragmentNode.selectionSet)
-  return [...selectedFields]
-}
-
-export function useInvalidFields(
-  fields: Record<string, FieldMeta>,
-  item: Record<string, unknown>,
-  isRequireds: Record<string, ConditionalFilterCase<BaseListTypeInfo>>
-): ReadonlySet<string> {
-  return useMemo(() => {
-    const invalidFields = new Set<string>()
-    const serialized = serializeItemForConditionalFilters(fields, item)
-
-    for (const fieldKey in item) {
-      const validateFn = fields[fieldKey]?.controller?.validate
-      if (!validateFn) continue
-      const isRequired = testFilter(isRequireds[fieldKey] ?? false, serialized)
-      const fieldValue = item[fieldKey]
-      const valid = validateFn(fieldValue, { isRequired })
-      if (valid) continue
-
-      invalidFields.add(fieldKey)
-    }
-    return invalidFields
-  }, [fields, isRequireds, item])
-}
-
-export function makeDefaultValueState(fields: Record<string, FieldMeta>) {
-  const result: Record<string, unknown> = {}
-  for (const fieldKey in fields) {
-    result[fieldKey] = fields[fieldKey].controller.defaultValue
-  }
-  return result
-}
-
-export function deserializeItemToValue(
-  fields: Record<string, FieldMeta>,
-  item: Record<string, unknown | null>
-) {
-  const result: Record<string, unknown | null> = {}
-  for (const [fieldKey, field] of Object.entries(fields)) {
-    const itemForField: Record<string, unknown> = {}
-    for (const graphqlField of getRootGraphQLFieldsFromFieldController(field.controller)) {
-      itemForField[graphqlField] = item?.[graphqlField] ?? null
-    }
-    result[fieldKey] = field.controller.deserialize(itemForField)
-  }
-  return result
-}
-
-export function serializeValueToOperationItem(
-  operation: 'create' | 'update',
-  fields: Record<string, FieldMeta>,
-  value: Record<string, unknown>,
-  valueReference?: Record<string, unknown>
-) {
-  const result: Record<string, unknown> = {}
-  valueReference ??= makeDefaultValueState(fields)
-
-  for (const fieldKey in fields) {
-    const field = fields[fieldKey]
-    const fieldValue = value[fieldKey]
-    const fieldValueSerialized = field.controller.serialize(fieldValue)
-    const fieldValueReference = valueReference[fieldKey]
-
-    const isAlwaysRequired = field.isNonNull.includes(operation)
-    if (!isAlwaysRequired) {
-      if (isDeepEqual(fieldValueSerialized, field.controller.serialize(fieldValueReference)))
-        continue
-    }
-
-    Object.assign(result, fieldValueSerialized)
-  }
-
-  return result
-}
-
-export function useHasChanges(
-  operation: 'create' | 'update',
-  fields: Record<string, FieldMeta>,
-  value: Record<string, unknown>,
-  valueReference?: Record<string, unknown>
-) {
-  return useMemo(() => {
-    valueReference ??= makeDefaultValueState(fields)
-
-    for (const fieldKey in fields) {
-      const field = fields[fieldKey]
-      const fieldValue = value[fieldKey]
-      const fieldValueSerialized = field.controller.serialize(fieldValue)
-      const fieldValueReference = valueReference[fieldKey]
-
-      if (!isDeepEqual(fieldValueSerialized, field.controller.serialize(fieldValueReference)))
-        return true
-    }
-
-    return false
-  }, [fields, operation, value, valueReference])
-}
+import isDeepEqual from 'fast-deep-equal'
+import { type FragmentDefinitionNode, type SelectionSetNode, parse } from 'graphql'
+import { useMemo } from 'react'
+
+import type {
+  BaseCollectionTypeInfo,
+  ConditionalFilterCase,
+  FieldController,
+  FieldMeta,
+} from '../../types'
+import { serializeItemForConditionalFilters, testFilter } from './filters'
+
+function extractRootFields(selectedFields: Set<string>, selectionSet: SelectionSetNode) {
+  selectionSet.selections.forEach(selection => {
+    if (selection.kind === 'Field') {
+      selectedFields.add(selection.alias ? selection.alias.value : selection.name.value)
+    }
+    if (selection.kind === 'InlineFragment') {
+      extractRootFields(selectedFields, selection.selectionSet)
+    }
+    // FragmentSpread will never happen for the use cases of getRootFieldsFromSelection
+  })
+}
+
+export function getRootGraphQLFieldsFromFieldController(controller: FieldController<any, any>) {
+  const ast = parse(`fragment X on Y { id, ${controller.graphqlSelection} }`)
+  const selectedFields = new Set<string>()
+  const fragmentNode = ast.definitions[0] as FragmentDefinitionNode
+  extractRootFields(selectedFields, fragmentNode.selectionSet)
+  return [...selectedFields]
+}
+
+export function useInvalidFields(
+  fields: Record<string, FieldMeta>,
+  item: Record<string, unknown>,
+  isRequireds: Record<string, ConditionalFilterCase<BaseCollectionTypeInfo>>
+): ReadonlySet<string> {
+  return useMemo(() => {
+    const invalidFields = new Set<string>()
+    const serialized = serializeItemForConditionalFilters(fields, item)
+
+    for (const fieldKey in item) {
+      const validateFn = fields[fieldKey]?.controller?.validate
+      if (!validateFn) continue
+      const isRequired = testFilter(isRequireds[fieldKey] ?? false, serialized)
+      const fieldValue = item[fieldKey]
+      const valid = validateFn(fieldValue, { isRequired })
+      if (valid) continue
+
+      invalidFields.add(fieldKey)
+    }
+    return invalidFields
+  }, [fields, isRequireds, item])
+}
+
+export function makeDefaultValueState(fields: Record<string, FieldMeta>) {
+  const result: Record<string, unknown> = {}
+  for (const fieldKey in fields) {
+    result[fieldKey] = fields[fieldKey].controller.defaultValue
+  }
+  return result
+}
+
+export function deserializeItemToValue(
+  fields: Record<string, FieldMeta>,
+  item: Record<string, unknown | null>
+) {
+  const result: Record<string, unknown | null> = {}
+  for (const [fieldKey, field] of Object.entries(fields)) {
+    const itemForField: Record<string, unknown> = {}
+    for (const graphqlField of getRootGraphQLFieldsFromFieldController(field.controller)) {
+      itemForField[graphqlField] = item?.[graphqlField] ?? null
+    }
+    result[fieldKey] = field.controller.deserialize(itemForField)
+  }
+  return result
+}
+
+export function serializeValueToOperationItem(
+  operation: 'create' | 'update',
+  fields: Record<string, FieldMeta>,
+  value: Record<string, unknown>,
+  valueReference?: Record<string, unknown>
+) {
+  const result: Record<string, unknown> = {}
+  valueReference ??= makeDefaultValueState(fields)
+
+  for (const fieldKey in fields) {
+    const field = fields[fieldKey]
+    const fieldValue = value[fieldKey]
+    const fieldValueSerialized = field.controller.serialize(fieldValue)
+    const fieldValueReference = valueReference[fieldKey]
+
+    const isAlwaysRequired = field.isNonNull.includes(operation)
+    if (!isAlwaysRequired) {
+      if (isDeepEqual(fieldValueSerialized, field.controller.serialize(fieldValueReference)))
+        continue
+    }
+
+    Object.assign(result, fieldValueSerialized)
+  }
+
+  return result
+}
+
+export function useHasChanges(
+  operation: 'create' | 'update',
+  fields: Record<string, FieldMeta>,
+  value: Record<string, unknown>,
+  valueReference?: Record<string, unknown>
+) {
+  return useMemo(() => {
+    valueReference ??= makeDefaultValueState(fields)
+
+    for (const fieldKey in fields) {
+      const field = fields[fieldKey]
+      const fieldValue = value[fieldKey]
+      const fieldValueSerialized = field.controller.serialize(fieldValue)
+      const fieldValueReference = valueReference[fieldKey]
+
+      if (!isDeepEqual(fieldValueSerialized, field.controller.serialize(fieldValueReference)))
+        return true
+    }
+
+    return false
+  }, [fields, operation, value, valueReference])
+}

package/src/context.ts

@@ -1 +1 @@
-export { getContext } from './lib/system'
+export { createNixxieContext } from './lib/system'

package/src/fields/non-null-graphql.ts

@@ -1,115 +1,115 @@
-import type { BaseFieldTypeInfo, CommonFieldConfig } from '../types'
-import { type BaseListTypeInfo, type FieldData } from '../types'
-import type { FieldHooks } from '../types/config/hooks'
-import { type ValidateFieldHook } from '../types/config/hooks'
-import { merge } from './resolve-hooks'
-
-export function resolveDbNullable(
-  validation: undefined | { isRequired?: boolean },
-  db: undefined | { isNullable?: boolean }
-): boolean {
-  if (db?.isNullable === false) return false
-  if (db?.isNullable === undefined && validation?.isRequired) {
-    return false
-  }
-  return true
-}
-
-export function makeValidateHook<ListTypeInfo extends BaseListTypeInfo>(
-  meta: FieldData<ListTypeInfo>,
-  config: {
-    label?: string
-    db?: {
-      isNullable?: boolean
-    }
-    graphql?: {
-      isNonNull?:
-        | boolean
-        | {
-            read?: boolean
-          }
-    }
-    validation?: {
-      isRequired?: boolean
-      [key: string]: unknown
-    }
-    hooks?: {
-      validate?: FieldHooks<ListTypeInfo, any>['validate']
-    }
-  },
-  f?: ValidateFieldHook<ListTypeInfo, 'create' | 'update' | 'delete', BaseFieldTypeInfo>,
-  hasPrismaDefaultValue: boolean = false
-) {
-  const dbNullable = resolveDbNullable(config.validation, config.db)
-  const mode = dbNullable ? ('optional' as const) : ('required' as const)
-  const valueRequired = (config.validation?.isRequired || !dbNullable) && !hasPrismaDefaultValue
-
-  assertReadIsNonNullAllowed(meta, config, dbNullable)
-  const addValidation = config.db?.isNullable === false || config.validation?.isRequired
-  if (addValidation) {
-    const validate = async function (args) {
-      const { operation, addValidationError, resolvedData } = args
-
-      if (valueRequired) {
-        const value = resolvedData?.[meta.fieldKey]
-        if (
-          (operation === 'create' && value === undefined) ||
-          ((operation === 'create' || operation === 'update') && value === null)
-        ) {
-          addValidationError(`missing value`)
-        }
-      }
-
-      await f?.(args)
-    } satisfies ValidateFieldHook<ListTypeInfo, 'create' | 'update' | 'delete', BaseFieldTypeInfo>
-
-    return {
-      mode,
-      validate: merge(validate, config.hooks?.validate),
-    }
-  }
-
-  return {
-    mode,
-    validate: merge(f, config.hooks?.validate),
-  }
-}
-
-export function assertReadIsNonNullAllowed<ListTypeInfo extends BaseListTypeInfo>(
-  meta: FieldData<ListTypeInfo>,
-  config: {
-    graphql?: {
-      isNonNull?:
-        | boolean
-        | {
-            read?: boolean
-          }
-    }
-  },
-  dbNullable: boolean
-) {
-  if (!dbNullable) return
-  if (!config.graphql?.isNonNull) return
-  if (typeof config.graphql?.isNonNull === 'object' && !config.graphql.isNonNull.read) return
-
-  throw new Error(
-    `${meta.listKey}.${meta.fieldKey} sets graphql.isNonNull.read: true, but not validation.isRequired: true (or db.isNullable: false)\n` +
-      `Set validation.isRequired: true, or db.isNullable: false, or graphql.isNonNull.read: false`
-  )
-}
-
-export function defaultIsRequired(config: CommonFieldConfig<any, any>, isRequired: boolean) {
-  return {
-    ui: {
-      ...config.ui,
-      createView: {
-        ...config.ui?.createView,
-        isRequired: config.ui?.createView?.isRequired ?? isRequired,
-      },
-      itemView: {
-        ...config.ui?.itemView,
-        isRequired: config.ui?.itemView?.isRequired ?? isRequired,
-      },
-    },
-  }
-}
+import type { BaseFieldTypeInfo, CommonFieldConfig } from '../types'
+import { type BaseCollectionTypeInfo, type FieldData } from '../types'
+import type { FieldHooks } from '../types/config/hooks'
+import { type ValidateFieldHook } from '../types/config/hooks'
+import { merge } from './resolve-hooks'
+
+export function resolveDbNullable(
+  validation: undefined | { isRequired?: boolean },
+  db: undefined | { isNullable?: boolean }
+): boolean {
+  if (db?.isNullable === false) return false
+  if (db?.isNullable === undefined && validation?.isRequired) {
+    return false
+  }
+  return true
+}
+
+export function makeValidateHook<CollectionTypeInfo extends BaseCollectionTypeInfo>(
+  meta: FieldData<CollectionTypeInfo>,
+  config: {
+    label?: string
+    db?: {
+      isNullable?: boolean
+    }
+    graphql?: {
+      isNonNull?:
+        | boolean
+        | {
+            read?: boolean
+          }
+    }
+    validation?: {
+      isRequired?: boolean
+      [key: string]: unknown
+    }
+    hooks?: {
+      validate?: FieldHooks<CollectionTypeInfo, any>['validate']
+    }
+  },
+  f?: ValidateFieldHook<CollectionTypeInfo, 'create' | 'update' | 'delete', BaseFieldTypeInfo>,
+  hasPrismaDefaultValue: boolean = false
+) {
+  const dbNullable = resolveDbNullable(config.validation, config.db)
+  const mode = dbNullable ? ('optional' as const) : ('required' as const)
+  const valueRequired = (config.validation?.isRequired || !dbNullable) && !hasPrismaDefaultValue
+
+  assertReadIsNonNullAllowed(meta, config, dbNullable)
+  const addValidation = config.db?.isNullable === false || config.validation?.isRequired
+  if (addValidation) {
+    const validate = async function (args) {
+      const { operation, addValidationError, resolvedData } = args
+
+      if (valueRequired) {
+        const value = resolvedData?.[meta.fieldKey]
+        if (
+          (operation === 'create' && value === undefined) ||
+          ((operation === 'create' || operation === 'update') && value === null)
+        ) {
+          addValidationError(`missing value`)
+        }
+      }
+
+      await f?.(args)
+    } satisfies ValidateFieldHook<CollectionTypeInfo, 'create' | 'update' | 'delete', BaseFieldTypeInfo>
+
+    return {
+      mode,
+      validate: merge(validate, config.hooks?.validate),
+    }
+  }
+
+  return {
+    mode,
+    validate: merge(f, config.hooks?.validate),
+  }
+}
+
+export function assertReadIsNonNullAllowed<CollectionTypeInfo extends BaseCollectionTypeInfo>(
+  meta: FieldData<CollectionTypeInfo>,
+  config: {
+    graphql?: {
+      isNonNull?:
+        | boolean
+        | {
+            read?: boolean
+          }
+    }
+  },
+  dbNullable: boolean
+) {
+  if (!dbNullable) return
+  if (!config.graphql?.isNonNull) return
+  if (typeof config.graphql?.isNonNull === 'object' && !config.graphql.isNonNull.read) return
+
+  throw new Error(
+    `${meta.listKey}.${meta.fieldKey} sets graphql.isNonNull.read: true, but not validation.isRequired: true (or db.isNullable: false)\n` +
+      `Set validation.isRequired: true, or db.isNullable: false, or graphql.isNonNull.read: false`
+  )
+}
+
+export function defaultIsRequired(config: CommonFieldConfig<any, any>, isRequired: boolean) {
+  return {
+    ui: {
+      ...config.ui,
+      createView: {
+        ...config.ui?.createView,
+        isRequired: config.ui?.createView?.isRequired ?? isRequired,
+      },
+      itemView: {
+        ...config.ui?.itemView,
+        isRequired: config.ui?.itemView?.isRequired ?? isRequired,
+      },
+    },
+  }
+}

package/src/fields/types/bigInt/index.ts

@@ -1,6 +1,6 @@
 import type { SimpleFieldTypeInfo } from '../../../types'
 import {
-  type BaseListTypeInfo,
+  type BaseCollectionTypeInfo,
   type CommonFieldConfig,
   type FieldTypeFunc,
   fieldType,
@@ -11,8 +11,8 @@ import { filters } from '../../filters'
 import { resolveDbNullable, makeValidateHook, defaultIsRequired } from '../../non-null-graphql'
 import type { controller } from './views'
 
-export type BigIntFieldConfig<ListTypeInfo extends BaseListTypeInfo> = CommonFieldConfig<
-  ListTypeInfo,
+export type BigIntFieldConfig<CollectionTypeInfo extends BaseCollectionTypeInfo> = CommonFieldConfig<
+  CollectionTypeInfo,
   SimpleFieldTypeInfo<'BigInt'>
 > & {
   isIndexed?: boolean | 'unique'
@@ -34,9 +34,9 @@ const MAX_INT = 9223372036854775807n
 const MIN_INT = -9223372036854775808n
 
 // TODO: https://github.com/Nixxie/keystatic/blob/main/design-system/pkg/src/number-field/NumberField.tsx
-export function bigInt<ListTypeInfo extends BaseListTypeInfo>(
-  config: BigIntFieldConfig<ListTypeInfo> = {}
-): FieldTypeFunc<ListTypeInfo> {
+export function bigInt<CollectionTypeInfo extends BaseCollectionTypeInfo>(
+  config: BigIntFieldConfig<CollectionTypeInfo> = {}
+): FieldTypeFunc<CollectionTypeInfo> {
   const { defaultValue: defaultValue_ = null, isIndexed, validation = {} } = config
 
   const { isRequired = false, min, max } = validation

package/src/fields/types/bytes/index.ts

@@ -1,5 +1,5 @@
 import {
-  type BaseListTypeInfo,
+  type BaseCollectionTypeInfo,
   type CommonFieldConfig,
   type FieldTypeFunc,
   fieldType,
@@ -33,8 +33,8 @@ export type FieldTypeInfo = {
   }
 }
 
-export type BytesFieldConfig<ListTypeInfo extends BaseListTypeInfo> = CommonFieldConfig<
-  ListTypeInfo,
+export type BytesFieldConfig<CollectionTypeInfo extends BaseCollectionTypeInfo> = CommonFieldConfig<
+  CollectionTypeInfo,
   FieldTypeInfo
 > & {
   isIndexed?: boolean | 'unique'
@@ -73,9 +73,9 @@ export type TextFieldMeta = {
   defaultValue: string | null
 }
 
-export function bytes<ListTypeInfo extends BaseListTypeInfo>(
-  config: BytesFieldConfig<ListTypeInfo> = {}
-): FieldTypeFunc<ListTypeInfo> {
+export function bytes<CollectionTypeInfo extends BaseCollectionTypeInfo>(
+  config: BytesFieldConfig<CollectionTypeInfo> = {}
+): FieldTypeFunc<CollectionTypeInfo> {
   const { defaultValue = null, isIndexed, validation = {} } = config
 
   const scalar = config.graphql?.scalar ?? g.Hex

package/src/fields/types/calendarDay/index.ts

@@ -8,7 +8,7 @@ import type {
 
 import { g } from '../../..'
 import {
-  type BaseListTypeInfo,
+  type BaseCollectionTypeInfo,
   type CommonFieldConfig,
   type FieldTypeFunc,
   type SimpleFieldTypeInfo,
@@ -19,25 +19,23 @@ import { filters } from '../../filters'
 import { defaultIsRequired, makeValidateHook } from '../../non-null-graphql'
 import type { CalendarDayFieldMeta } from './views'
 
-export type CalendarDayFieldConfig<ListTypeInfo extends BaseListTypeInfo> = CommonFieldConfig<
-  ListTypeInfo,
-  SimpleFieldTypeInfo<'String' | 'DateTime'>
-> & {
-  isIndexed?: boolean | 'unique'
-  validation?: {
-    isRequired?: boolean
-  }
-  defaultValue?: string
-  db?: {
-    isNullable?: boolean
-    extendPrismaSchema?: (field: string) => string
-    map?: string
+export type CalendarDayFieldConfig<CollectionTypeInfo extends BaseCollectionTypeInfo> =
+  CommonFieldConfig<CollectionTypeInfo, SimpleFieldTypeInfo<'String' | 'DateTime'>> & {
+    isIndexed?: boolean | 'unique'
+    validation?: {
+      isRequired?: boolean
+    }
+    defaultValue?: string
+    db?: {
+      isNullable?: boolean
+      extendPrismaSchema?: (field: string) => string
+      map?: string
+    }
   }
-}
 
-export function calendarDay<ListTypeInfo extends BaseListTypeInfo>(
-  config: CalendarDayFieldConfig<ListTypeInfo> = {}
-): FieldTypeFunc<ListTypeInfo> {
+export function calendarDay<CollectionTypeInfo extends BaseCollectionTypeInfo>(
+  config: CalendarDayFieldConfig<CollectionTypeInfo> = {}
+): FieldTypeFunc<CollectionTypeInfo> {
   const { isIndexed, validation, defaultValue } = config
   return meta => {
     if (typeof defaultValue === 'string') {
@@ -45,7 +43,8 @@ export function calendarDay<ListTypeInfo extends BaseListTypeInfo>(
         g.CalendarDay.parseValue(defaultValue)
       } catch (err) {
         throw new Error(
-          `The calendarDay field at ${meta.listKey}.${meta.fieldKey} specifies defaultValue: ${defaultValue} but values must be provided as a full-date ISO8601 string such as 1970-01-01`
+          `The calendarDay field at ${meta.listKey}.${meta.fieldKey} specifies defaultValue: ${defaultValue} but values must be provided as a full-date ISO8601 string such as 1970-01-01`,
+          { cause: err }
         )
       }
     }

package/src/fields/types/checkbox/index.ts

@@ -1,7 +1,7 @@
 import { userInputError } from '../../../lib/core/graphql-errors'
 import type { SimpleFieldTypeInfo } from '../../../types'
 import {
-  type BaseListTypeInfo,
+  type BaseCollectionTypeInfo,
   type CommonFieldConfig,
   type FieldTypeFunc,
   fieldType,
@@ -12,8 +12,8 @@ import { assertReadIsNonNullAllowed } from '../../non-null-graphql'
 import { filters } from '../../filters'
 import type { controller } from './views'
 
-export type CheckboxFieldConfig<ListTypeInfo extends BaseListTypeInfo> = CommonFieldConfig<
-  ListTypeInfo,
+export type CheckboxFieldConfig<CollectionTypeInfo extends BaseCollectionTypeInfo> = CommonFieldConfig<
+  CollectionTypeInfo,
   SimpleFieldTypeInfo<'Boolean'>
 > & {
   defaultValue?: boolean
@@ -23,9 +23,9 @@ export type CheckboxFieldConfig<ListTypeInfo extends BaseListTypeInfo> = CommonF
   }
 }
 
-export function checkbox<ListTypeInfo extends BaseListTypeInfo>(
-  config: CheckboxFieldConfig<ListTypeInfo> = {}
-): FieldTypeFunc<ListTypeInfo> {
+export function checkbox<CollectionTypeInfo extends BaseCollectionTypeInfo>(
+  config: CheckboxFieldConfig<CollectionTypeInfo> = {}
+): FieldTypeFunc<CollectionTypeInfo> {
   const { defaultValue = false } = config
 
   return meta => {