@nixxie-cms/core 1.0.0

package/src/lib/core/initialise-lists.ts

@@ -0,0 +1,1097 @@
+import type { CacheHint } from '@apollo/cache-control-types'
+import { GInputObjectType, type GArg, type GInputType } from '@graphql-ts/schema'
+import { GNonNull } from '@graphql-ts/schema'
+import {
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLString,
+  isInputObjectType,
+  type GraphQLType,
+} from 'graphql'
+
+import { g } from '../..'
+import { expandVoidHooks } from '../../fields/resolve-hooks'
+import { humanize } from '../../lib/utils'
+import type { GroupInfo } from '../../schema'
+import type {
+  ActionMeta,
+  BaseFieldTypeInfo,
+  BaseItem,
+  BaseListTypeInfo,
+  CacheHintArgs,
+  FieldTypeFunc,
+  FindManyArgs,
+  GraphQLTypesForList,
+  NixxieConfig,
+  ListGraphQLTypes,
+  ListHooks,
+  MaybeFieldFunction,
+  NextFieldType,
+} from '../../types'
+import { QueryMode } from '../../types'
+import type { FieldHooks, ResolvedFieldHooks, ResolvedListHooks } from '../../types/config/hooks'
+import type {
+  BaseActions,
+  MaybeBooleanItemFunctionWithFilter,
+  MaybeBooleanSessionFunctionWithFilter,
+  MaybeItemActionFunctionWithFilter,
+  MaybeItemFieldFunction,
+  MaybeItemFieldFunctionWithFilter,
+  MaybeSessionFunction,
+  MaybeSessionFunctionWithFilter,
+} from '../../types/config/lists'
+import { type GraphQLNames, __getNames } from '../../types/utils'
+import {
+  type ResolvedActionAccessControl,
+  type ResolvedFieldAccessControl,
+  type ResolvedListAccessControl,
+  parseFieldAccessControl,
+  parseListAccessControl,
+} from './access-control'
+import { assertFieldsValid } from './field-assertions'
+import { outputTypeField } from './queries/output-field'
+import { type ResolvedDBField, resolveRelationships } from './resolve-relationships'
+import { areArraysEqual } from './utils'
+
+export type InitialisedAction = {
+  actionKey: string
+
+  access: ResolvedActionAccessControl
+  resolve: BaseActions<BaseListTypeInfo>[keyof BaseActions<BaseListTypeInfo>]['resolve']
+  graphql: {
+    arguments: { name: string; type: string; source: { itemField: string } | null }[]
+    names: {
+      one: string
+      many: string
+      args: string
+    }
+    types: {
+      arguments: Record<string, GArg<GInputType>>
+      args: GInputObjectType<Record<string, GArg<GInputType>>>
+    }
+  }
+  otel: string
+  ui: {
+    label: ActionMeta['label']
+    icon: ActionMeta['icon']
+    messages: ActionMeta['messages']
+    itemView: Omit<ActionMeta['itemView'], 'actionMode'> & {
+      actionMode: MaybeItemActionFunctionWithFilter<
+        'enabled' | 'disabled' | 'hidden',
+        'disabled' | 'hidden',
+        BaseListTypeInfo
+      >
+    }
+    listView: {
+      actionMode: MaybeSessionFunctionWithFilter<
+        'enabled' | 'disabled' | 'hidden',
+        'disabled' | 'hidden',
+        BaseListTypeInfo
+      >
+    }
+    argSources: Record<string, { itemField: string }>
+  }
+}
+
+function printGraphQLType(type: GraphQLType): string {
+  if (type instanceof GraphQLNonNull) return `${printGraphQLType(type.ofType)}!`
+  if (type instanceof GraphQLList) return `[${printGraphQLType(type.ofType)}]`
+  return type.name
+}
+
+function getArgSources(
+  action: NonNullable<NixxieConfig['lists'][string]['actions']>[string]
+): Record<string, { itemField: string }> {
+  return Object.fromEntries(
+    Object.entries(action.args ?? {}).flatMap(([arg, value]) => {
+      const field = value.ui?.source?.itemField
+      if (!field) return []
+      return [[arg, { itemField: field }]]
+    })
+  )
+}
+
+export type InitialisedField = {
+  fieldKey: string
+
+  access: ResolvedFieldAccessControl
+  dbField: ResolvedDBField
+  hooks: ResolvedFieldHooks<BaseListTypeInfo, BaseFieldTypeInfo>
+  graphql: {
+    isEnabled: {
+      read: boolean
+      create: boolean
+      update: boolean
+      filter: MaybeFieldFunction<BaseListTypeInfo>
+      orderBy: MaybeFieldFunction<BaseListTypeInfo>
+    }
+    isNonNull: {
+      read: boolean
+      create: boolean
+      update: boolean
+    }
+    cacheHint: CacheHint | undefined
+  }
+  ui: {
+    label: string
+    description: string
+    views: string | null
+    createView: {
+      fieldMode: MaybeSessionFunctionWithFilter<'edit' | 'hidden', 'hidden', BaseListTypeInfo>
+      isRequired: MaybeBooleanSessionFunctionWithFilter<BaseListTypeInfo>
+    }
+    itemView: {
+      fieldMode: MaybeItemFieldFunctionWithFilter<
+        'read' | 'edit' | 'hidden',
+        'read' | 'hidden',
+        BaseListTypeInfo,
+        BaseFieldTypeInfo
+      >
+      fieldPosition: MaybeItemFieldFunction<'form' | 'sidebar', BaseListTypeInfo, BaseFieldTypeInfo>
+      isRequired: MaybeBooleanItemFunctionWithFilter<BaseListTypeInfo, BaseFieldTypeInfo>
+    }
+    listView: {
+      fieldMode: MaybeSessionFunction<'read' | 'hidden', BaseListTypeInfo>
+    }
+  }
+} & Pick<
+  NextFieldType,
+  | 'input'
+  | 'output'
+  | 'getAdminMeta'
+  | 'views'
+  | '__ksTelemetryFieldTypeName'
+  | 'extraOutputFields'
+  | 'unreferencedConcreteInterfaceImplementations'
+>
+
+export type InitialisedList = {
+  listKey: string
+
+  access: ResolvedListAccessControl
+
+  fields: Record<string, InitialisedField>
+  actions: InitialisedAction[]
+  groups: GroupInfo<BaseListTypeInfo>[]
+
+  hooks: ResolvedListHooks<BaseListTypeInfo>
+
+  /** This will include the opposites to one-sided relationships */
+  resolvedDbFields: Record<string, ResolvedDBField>
+  lists: Record<string, InitialisedList>
+
+  graphql: {
+    types: GraphQLTypesForList
+    names: GraphQLNames
+    isEnabled: {
+      type: boolean
+      query: boolean
+      create: boolean
+      update: boolean
+      delete: boolean
+      filter: MaybeFieldFunction<BaseListTypeInfo>
+      orderBy: MaybeFieldFunction<BaseListTypeInfo>
+    }
+  }
+
+  prisma: {
+    types: GraphQLNames // TODO: not completely appropriate, but what is used for now
+    listKey: string
+    mapping: string | undefined
+    extendPrismaSchema: ((schema: string) => string) | undefined
+  }
+
+  ui: {
+    labels: { label: string; singular: string; plural: string; path: string }
+    labelField: string
+    searchFields: Set<string>
+    searchableFields: Map<string, 'default' | 'insensitive' | null>
+    triviallySearchableFields: Set<string>
+  }
+
+  isSingleton: boolean
+  cacheHint: ((args: CacheHintArgs<BaseListTypeInfo>) => CacheHint) | undefined
+}
+
+function throwIfNotAFilter(x: unknown, listKey: string, fieldKey: string) {
+  if (['boolean', 'undefined', 'function'].includes(typeof x)) return
+  throw new Error(
+    `Configuration option '${listKey}.${fieldKey}' must be either a boolean value or a function. Received '${x}'.`
+  )
+}
+
+type ListConfigType = NixxieConfig['lists'][string]
+type FieldConfigType = ReturnType<FieldTypeFunc<any>>
+type PartiallyInitialisedList1 = { graphql: { isEnabled: InitialisedList['graphql']['isEnabled'] } }
+type PartiallyInitialisedList2 = Omit<InitialisedList, 'lists' | 'resolvedDbFields'>
+
+// TODO: move to defaultLists?
+function getIsEnabled(listKey: string, listConfig: ListConfigType) {
+  const omit = listConfig.graphql.omit ?? false
+  const { defaultIsFilterable, defaultIsOrderable } = listConfig
+
+  throwIfNotAFilter(defaultIsFilterable, listKey, 'defaultIsFilterable')
+  throwIfNotAFilter(defaultIsOrderable, listKey, 'defaultIsOrderable')
+
+  if (typeof omit === 'boolean') {
+    const notOmit = !omit
+    return {
+      type: notOmit,
+      query: notOmit,
+      create: notOmit,
+      update: notOmit,
+      delete: notOmit,
+      filter: notOmit ? defaultIsFilterable : false,
+      orderBy: notOmit ? defaultIsOrderable : false,
+    }
+  }
+
+  return {
+    type: true,
+    query: !omit.query,
+    create: !omit.create,
+    update: !omit.update,
+    delete: !omit.delete,
+    filter: defaultIsFilterable,
+    orderBy: defaultIsOrderable,
+  }
+}
+
+function getIsEnabledField(
+  f: FieldConfigType,
+  listKey: string,
+  list: PartiallyInitialisedList1,
+  lists: Record<string, PartiallyInitialisedList1>
+) {
+  const omit = f.graphql?.omit ?? false
+  const {
+    isFilterable = list.graphql.isEnabled.filter,
+    isOrderable = list.graphql.isEnabled.orderBy,
+  } = f
+
+  // TODO: check types in initConfig
+  throwIfNotAFilter(isFilterable, listKey, 'isFilterable')
+  throwIfNotAFilter(isOrderable, listKey, 'isOrderable')
+
+  if (f.dbField.kind === 'relation') {
+    if (!lists[f.dbField.list].graphql.isEnabled.type) {
+      return {
+        type: false,
+        read: false,
+        create: false,
+        update: false,
+        filter: false,
+        orderBy: false,
+      }
+    }
+  }
+
+  if (typeof omit === 'boolean') {
+    const notOmit = !omit
+    return {
+      type: notOmit,
+      read: notOmit,
+      create: notOmit,
+      update: notOmit,
+      filter: notOmit ? isFilterable : false,
+      orderBy: notOmit ? isOrderable : false,
+    }
+  }
+
+  return {
+    type: true,
+    read: !omit.read,
+    create: !omit.create,
+    update: !omit.update,
+    filter: !omit.read ? isFilterable : false, // prevent filtering if read is false
+    orderBy: !omit.read ? isOrderable : false, // prevent ordering if read is false
+  }
+}
+
+function defaultListHooksResolveInput({ resolvedData }: { resolvedData: any }) {
+  return resolvedData
+}
+
+function parseListHooks(hooks: ListHooks<BaseListTypeInfo>): ResolvedListHooks<BaseListTypeInfo> {
+  return {
+    resolveInput: {
+      create:
+        typeof hooks.resolveInput === 'function'
+          ? hooks.resolveInput
+          : (hooks.resolveInput?.create ?? defaultListHooksResolveInput),
+      update:
+        typeof hooks.resolveInput === 'function'
+          ? hooks.resolveInput
+          : (hooks.resolveInput?.update ?? defaultListHooksResolveInput),
+    },
+    validate: expandVoidHooks(hooks.validate),
+    beforeOperation: expandVoidHooks(hooks.beforeOperation),
+    afterOperation: expandVoidHooks(hooks.afterOperation),
+  }
+}
+
+function defaultFieldHooksResolveInput({
+  resolvedData,
+  fieldKey,
+}: {
+  resolvedData: any
+  fieldKey: string
+}) {
+  return resolvedData[fieldKey]
+}
+
+function parseFieldHooks(
+  hooks: FieldHooks<BaseListTypeInfo, BaseFieldTypeInfo>
+): ResolvedFieldHooks<BaseListTypeInfo, BaseFieldTypeInfo> {
+  return {
+    resolveInput: {
+      create:
+        typeof hooks.resolveInput === 'function'
+          ? hooks.resolveInput
+          : (hooks.resolveInput?.create ?? defaultFieldHooksResolveInput),
+      update:
+        typeof hooks.resolveInput === 'function'
+          ? hooks.resolveInput
+          : (hooks.resolveInput?.update ?? defaultFieldHooksResolveInput),
+    },
+    validate: expandVoidHooks(hooks.validate),
+    beforeOperation: expandVoidHooks(hooks.beforeOperation),
+    afterOperation: expandVoidHooks(hooks.afterOperation),
+  }
+}
+
+function getListsWithInitialisedFields(
+  config: NixxieConfig,
+  listsRef: Record<string, InitialisedList>
+) {
+  const {
+    lists: listsConfig,
+    db: { provider },
+  } = config
+  const intermediateLists = Object.fromEntries(
+    Object.values(config.lists).map(listConfig => [
+      listConfig.listKey,
+      {
+        graphql: {
+          isEnabled: getIsEnabled(listConfig.listKey, listConfig),
+        },
+      },
+    ])
+  )
+
+  const listGraphqlTypes: Record<string, ListGraphQLTypes<BaseListTypeInfo>> = {}
+
+  for (const listConfig of Object.values(listsConfig)) {
+    const { listKey } = listConfig
+    const {
+      graphql: { names },
+    } = __getNames(listKey, listConfig)
+
+    const output = g.object<BaseItem>()({
+      name: names.outputTypeName,
+      fields: () => {
+        const { fields } = listsRef[listKey]
+        return {
+          ...Object.fromEntries(
+            Object.entries(fields).flatMap(([fieldPath, field]) => {
+              if (
+                !field.output ||
+                !field.graphql.isEnabled.read ||
+                (field.dbField.kind === 'relation' &&
+                  !intermediateLists[field.dbField.list].graphql.isEnabled.query)
+              ) {
+                return []
+              }
+
+              const outputFieldRoot = graphqlForOutputField(field)
+              return [
+                [fieldPath, outputFieldRoot] as const,
+                ...Object.entries(field.extraOutputFields || {}),
+              ].map(([outputTypeFieldName, outputField]) => {
+                return [
+                  outputTypeFieldName,
+                  outputTypeField(
+                    outputField,
+                    field.dbField,
+                    field.graphql?.cacheHint,
+                    field.access.read,
+                    listKey,
+                    fieldPath,
+                    listsRef
+                  ),
+                ]
+              })
+            })
+          ),
+        }
+      },
+    })
+
+    const uniqueWhere = g.inputObject({
+      name: names.whereUniqueInputName,
+      fields: () => {
+        const { fields } = listsRef[listKey]
+        return {
+          ...Object.fromEntries(
+            Object.entries(fields).flatMap(([key, field]) => {
+              if (
+                !field.input?.uniqueWhere?.arg ||
+                !field.graphql.isEnabled.read ||
+                !field.graphql.isEnabled.filter
+              ) {
+                return []
+              }
+
+              // only 1-to-1 relationships can have a uniqueWhere filter on relations
+              if (field.dbField.kind === 'relation') {
+                const remoteField =
+                  listsRef[field.dbField.list].resolvedDbFields[field.dbField.field]
+                if (
+                  field.dbField.mode === 'one' &&
+                  remoteField.kind === 'relation' &&
+                  remoteField.mode === 'one'
+                ) {
+                  return [[key, field.input.uniqueWhere.arg]] as const
+                }
+                return []
+              }
+
+              return [[key, field.input.uniqueWhere.arg]] as const
+            })
+          ),
+          // this is exactly what the id field will add
+          // but this does it more explicitly so that typescript understands
+          id: g.arg({ type: g.ID }),
+        }
+      },
+    })
+
+    const where: GraphQLTypesForList['where'] = g.inputObject({
+      name: names.whereInputName,
+      fields: () => {
+        const { fields } = listsRef[listKey]
+        return Object.assign(
+          {
+            AND: g.arg({ type: g.list(g.nonNull(where)) }),
+            OR: g.arg({ type: g.list(g.nonNull(where)) }),
+            NOT: g.arg({ type: g.list(g.nonNull(where)) }),
+          },
+          ...Object.entries(fields).map(
+            ([fieldKey, field]) =>
+              field.input?.where?.arg &&
+              field.graphql.isEnabled.read &&
+              field.graphql.isEnabled.filter && { [fieldKey]: field.input?.where?.arg }
+          )
+        )
+      },
+    })
+
+    const create = g.inputObject({
+      name: names.createInputName,
+      fields: () => {
+        const { fields } = listsRef[listKey]
+        const ret: Record<keyof typeof fields, GArg<GInputType>> = {}
+
+        for (const key in fields) {
+          const arg = graphqlArgForInputField(fields[key], 'create', listsRef)
+          if (!arg) continue
+          ret[key] = arg
+        }
+
+        return ret
+      },
+    })
+
+    const update = g.inputObject({
+      name: names.updateInputName,
+      fields: () => {
+        const { fields } = listsRef[listKey]
+        const ret: Record<keyof typeof fields, GArg<GInputType>> = {}
+
+        for (const key in fields) {
+          const arg = graphqlArgForInputField(fields[key], 'update', listsRef)
+          if (!arg) continue
+          ret[key] = arg
+        }
+
+        return ret
+      },
+    })
+
+    const orderBy = g.inputObject({
+      name: names.listOrderName,
+      fields: () => {
+        const { fields } = listsRef[listKey]
+        return Object.fromEntries(
+          Object.entries(fields).flatMap(([key, field]) => {
+            if (
+              !field.input?.orderBy?.arg ||
+              !field.graphql.isEnabled.read ||
+              !field.graphql.isEnabled.orderBy
+            ) {
+              return []
+            }
+            return [[key, field.input.orderBy.arg]] as const
+          })
+        )
+      },
+    })
+
+    let take: any = g.arg({ type: g.Int })
+    if (listConfig.graphql?.maxTake !== undefined) {
+      take = g.arg({
+        type: g.nonNull(g.Int),
+        // WARNING: used by queries/resolvers.ts to enforce the limit
+        defaultValue: listConfig.graphql.maxTake,
+      })
+    }
+
+    const findManyArgs: FindManyArgs = {
+      where: g.arg({
+        type: g.nonNull(where),
+        defaultValue: listConfig.isSingleton ? { id: { equals: '1' } } : {},
+      }),
+      orderBy: g.arg({
+        type: g.nonNull(g.list(g.nonNull(orderBy))),
+        defaultValue: [],
+      }),
+      take,
+      skip: g.arg({
+        type: g.nonNull(g.Int),
+        defaultValue: 0,
+      }),
+      cursor: g.arg({ type: uniqueWhere }),
+    }
+
+    const relateToOneForCreate = g.inputObject({
+      name: names.relateToOneForCreateInputName,
+      fields: () => {
+        const listRef = listsRef[listKey]
+        return {
+          ...(listRef.graphql.isEnabled.create && {
+            create: g.arg({ type: listRef.graphql.types.create }),
+          }),
+          connect: g.arg({ type: listRef.graphql.types.uniqueWhere }),
+        }
+      },
+    })
+
+    const relateToOneForUpdate = g.inputObject({
+      name: names.relateToOneForUpdateInputName,
+      fields: () => {
+        const listRef = listsRef[listKey]
+        return {
+          ...(listRef.graphql.isEnabled.create && {
+            create: g.arg({ type: listRef.graphql.types.create }),
+          }),
+          connect: g.arg({ type: listRef.graphql.types.uniqueWhere }),
+          disconnect: g.arg({ type: g.Boolean }),
+        }
+      },
+    })
+
+    const relateToManyForCreate = g.inputObject({
+      name: names.relateToManyForCreateInputName,
+      fields: () => {
+        const listRef = listsRef[listKey]
+        return {
+          ...(listRef.graphql.isEnabled.create && {
+            create: g.arg({
+              type: g.list(g.nonNull(listRef.graphql.types.create)),
+            }),
+          }),
+          connect: g.arg({
+            type: g.list(g.nonNull(listRef.graphql.types.uniqueWhere)),
+          }),
+          set: g.arg({
+            type: g.list(g.nonNull(listRef.graphql.types.uniqueWhere)),
+          }),
+        }
+      },
+    })
+
+    const relateToManyForUpdate = g.inputObject({
+      name: names.relateToManyForUpdateInputName,
+      fields: () => {
+        const listRef = listsRef[listKey]
+        return {
+          // WARNING: the order of these fields reflects the order of mutations
+          disconnect: g.arg({
+            type: g.list(g.nonNull(listRef.graphql.types.uniqueWhere)),
+          }),
+          set: g.arg({
+            type: g.list(g.nonNull(listRef.graphql.types.uniqueWhere)),
+          }),
+          ...(listRef.graphql.isEnabled.create && {
+            create: g.arg({ type: g.list(g.nonNull(listRef.graphql.types.create)) }),
+          }),
+          connect: g.arg({ type: g.list(g.nonNull(listRef.graphql.types.uniqueWhere)) }),
+        }
+      },
+    })
+
+    listGraphqlTypes[listKey] = {
+      types: {
+        output,
+        uniqueWhere,
+        where,
+        create,
+        orderBy,
+        update,
+        findManyArgs,
+        relateTo: {
+          one: {
+            create: relateToOneForCreate,
+            update: relateToOneForUpdate,
+          },
+          many: {
+            where: g.inputObject({
+              name: `${listKey}ManyRelationFilter`,
+              fields: {
+                every: g.arg({ type: where }),
+                some: g.arg({ type: where }),
+                none: g.arg({ type: where }),
+              },
+            }),
+            create: relateToManyForCreate,
+            update: relateToManyForUpdate,
+          },
+        },
+      },
+    }
+  }
+
+  const result: Record<string, PartiallyInitialisedList2> = {}
+
+  for (const listConfig of Object.values(listsConfig)) {
+    const { listKey } = listConfig
+    const intermediateList = intermediateLists[listKey]
+    const resultFields: Record<string, InitialisedField> = {}
+    const groups: GroupInfo<BaseListTypeInfo>[] = []
+    const fieldKeys = Object.keys(listConfig.fields)
+
+    const fieldKeysToGroup: Record<string, GroupInfo<BaseListTypeInfo>> = {}
+    for (const [idx, [fieldKey, fieldFunc]] of Object.entries(listConfig.fields).entries()) {
+      if (fieldKey.startsWith('__group')) {
+        const group__ = fieldFunc as any
+        if (
+          typeof group__ === 'object' &&
+          group__ !== null &&
+          typeof group__.label === 'string' &&
+          (group__.description === null || typeof group__.description === 'string') &&
+          Array.isArray(group__.fields) &&
+          areArraysEqual(group__.fields, fieldKeys.slice(idx + 1, idx + 1 + group__.fields.length))
+        ) {
+          groups.push(group__)
+          for (const field of group__.fields) {
+            fieldKeysToGroup[field] = group__
+          }
+          continue
+        }
+        throw new Error(`unexpected value for a group at ${listKey}.${fieldKey}`)
+      }
+      if (typeof fieldFunc !== 'function') {
+        throw new Error(`The field at ${listKey}.${fieldKey} does not provide a function`)
+      }
+
+      const group = fieldKeysToGroup[fieldKey]
+      const f = fieldFunc({
+        provider,
+        lists: listGraphqlTypes,
+        listKey,
+        fieldKey,
+      })
+
+      const isEnabledField = getIsEnabledField(f, listKey, intermediateList, intermediateLists)
+      resultFields[fieldKey] = {
+        fieldKey,
+
+        dbField: f.dbField as ResolvedDBField,
+        access: parseFieldAccessControl(f.access),
+        hooks: parseFieldHooks(f.hooks ?? {}),
+        graphql: {
+          cacheHint: f.graphql?.cacheHint,
+          isEnabled: isEnabledField,
+          isNonNull: {
+            read:
+              typeof f.graphql?.isNonNull === 'boolean'
+                ? f.graphql.isNonNull
+                : (f.graphql?.isNonNull?.read ?? false),
+            create:
+              typeof f.graphql?.isNonNull === 'boolean'
+                ? f.graphql.isNonNull
+                : (f.graphql?.isNonNull?.create ?? false),
+            update:
+              typeof f.graphql?.isNonNull === 'boolean'
+                ? f.graphql.isNonNull
+                : (f.graphql?.isNonNull?.update ?? false),
+          },
+        },
+        ui: {
+          label: f.ui?.label || humanize(fieldKey),
+          description: f.ui?.description ?? '',
+          views: f.ui?.views ?? null,
+          createView: {
+            isRequired: f.ui?.createView?.isRequired ?? false,
+            fieldMode: isEnabledField.create
+              ? (f.ui?.createView?.fieldMode ??
+                group?.ui?.createView?.defaultFieldMode ??
+                listConfig.ui.createView?.defaultFieldMode ??
+                'edit')
+              : 'hidden',
+          },
+
+          itemView: {
+            isRequired: f.ui?.itemView?.isRequired ?? false,
+            fieldPosition: f.ui?.itemView?.fieldPosition ?? 'form',
+            fieldMode: isEnabledField.update
+              ? (f.ui?.itemView?.fieldMode ??
+                group?.ui?.itemView?.defaultFieldMode ??
+                listConfig.ui.itemView?.defaultFieldMode ??
+                'edit')
+              : isEnabledField.read
+                ? (f.ui?.itemView?.fieldMode ??
+                  group?.ui?.itemView?.defaultFieldMode ??
+                  listConfig.ui.itemView?.defaultFieldMode ??
+                  'read')
+                : 'hidden',
+          },
+
+          listView: {
+            fieldMode: isEnabledField.read
+              ? (f.ui?.listView?.fieldMode ??
+                group?.ui?.listView?.defaultFieldMode ??
+                listConfig.ui.listView?.defaultFieldMode ??
+                'read')
+              : 'hidden',
+          },
+        },
+
+        // copy
+        __ksTelemetryFieldTypeName: f.__ksTelemetryFieldTypeName,
+        extraOutputFields: f.extraOutputFields,
+        getAdminMeta: f.getAdminMeta,
+        input: { ...f.input },
+        output: { ...f.output },
+        unreferencedConcreteInterfaceImplementations:
+          f.unreferencedConcreteInterfaceImplementations,
+        views: f.views,
+      }
+    }
+
+    // default labelField to `name`, `label`, or `title`; fallback to `id`
+    const labelField =
+      listConfig.ui.labelField ??
+      (listConfig.fields.label
+        ? 'label'
+        : listConfig.fields.name
+          ? 'name'
+          : listConfig.fields.title
+            ? 'title'
+            : 'id')
+
+    const searchFields = new Set(listConfig.ui.searchFields ?? [])
+    if (searchFields.has('id')) {
+      throw new Error(`${listKey}.ui.searchFields cannot include 'id'`)
+    }
+
+    const names = __getNames(listKey, listConfig)
+    result[listKey] = {
+      access: parseListAccessControl(listConfig.access),
+
+      fields: resultFields,
+      groups,
+      actions: [],
+
+      graphql: {
+        types: {
+          ...listGraphqlTypes[listKey].types,
+        },
+        names: {
+          ...names.graphql.names,
+        },
+        ...intermediateList.graphql,
+      },
+
+      prisma: {
+        types: {
+          ...names.graphql.names,
+        },
+        listKey: listKey[0].toLowerCase() + listKey.slice(1),
+        mapping: listConfig.db.map,
+        extendPrismaSchema: listConfig.db.extendPrismaSchema,
+      },
+
+      ui: {
+        labels: names.ui.labels,
+        labelField,
+        searchFields,
+        searchableFields: new Map<string, 'default' | 'insensitive' | null>(),
+        triviallySearchableFields: new Set<string>(),
+      },
+      hooks: parseListHooks(listConfig.hooks ?? {}),
+      listKey,
+      cacheHint: (() => {
+        const cacheHint = listConfig.graphql.cacheHint
+        if (typeof cacheHint === 'function') return cacheHint
+        if (cacheHint !== undefined) return () => cacheHint
+        return undefined
+      })(),
+
+      isSingleton: listConfig.isSingleton ?? false,
+    }
+  }
+
+  return result
+}
+
+function introspectGraphQLTypes(lists: Record<string, InitialisedList>) {
+  const namesOfRelationInputs = new Set<string>()
+  for (const list of Object.values(lists)) {
+    const { types } = list.graphql
+    namesOfRelationInputs.add(types.where.name)
+    namesOfRelationInputs.add(types.relateTo.many.where.name)
+  }
+  for (const list of Object.values(lists)) {
+    const {
+      listKey,
+      ui: { searchFields, searchableFields, triviallySearchableFields },
+    } = list
+
+    if (searchFields.has('id')) {
+      throw new Error(
+        `The ui.searchFields option on the ${listKey} list includes 'id'. Lists can always be searched by an item's id so it must not be specified as a search field`
+      )
+    }
+
+    const whereInputFields = list.graphql.types.where.getFields()
+    for (const [fieldKey, field] of Object.entries(list.fields)) {
+      const filterType = whereInputFields[fieldKey]?.type
+      const fieldFilterFields = isInputObjectType(filterType) ? filterType.getFields() : undefined
+      const filterTypeName = isInputObjectType(filterType) ? filterType.name : undefined
+      if (fieldFilterFields?.contains?.type === GraphQLString) {
+        searchableFields.set(
+          fieldKey,
+          fieldFilterFields?.mode?.type === QueryMode ? 'insensitive' : 'default'
+        )
+        triviallySearchableFields.add(fieldKey)
+      } else if (
+        field.dbField.kind === 'relation' &&
+        filterTypeName !== undefined &&
+        namesOfRelationInputs.has(filterTypeName)
+      ) {
+        searchableFields.set(fieldKey, 'default')
+      }
+    }
+
+    if (searchFields.size === 0) {
+      if (searchableFields.has(list.ui.labelField)) {
+        searchFields.add(list.ui.labelField)
+      }
+    }
+  }
+}
+
+function stripDefaultValue(thing: GArg<GInputType, boolean>) {
+  return g.arg({
+    ...thing,
+    defaultValue: undefined,
+  })
+}
+
+function graphqlArgForInputField(
+  field: InitialisedField,
+  operation: 'create' | 'update',
+  listsRef: Record<string, InitialisedList>
+) {
+  const input = field.input?.[operation]
+  if (!input?.arg || !field.graphql.isEnabled[operation]) return
+  if (field.dbField.kind === 'relation') {
+    if (!listsRef[field.dbField.list].graphql.isEnabled.type) return
+  }
+  if (!field.graphql.isNonNull[operation]) return stripDefaultValue(input.arg)
+  if (input.arg.type instanceof GNonNull) return input.arg
+
+  return g.arg({
+    ...input.arg,
+    type: g.nonNull(input.arg.type),
+  })
+}
+
+function graphqlForOutputField(field: InitialisedField) {
+  const output = field.output
+  if (!output || !field.graphql.isEnabled.read) return output
+  if (!field.graphql.isNonNull.read) return output
+  if (output.type instanceof GNonNull) return output
+
+  return g.field({
+    ...(output as any),
+    type: g.nonNull(output.type),
+  })
+}
+
+function getInitialisedActionGraphql(
+  list: Pick<InitialisedList, 'graphql'>,
+  listGraphqlNames: { singular: string; plural: string },
+  actionKey: string,
+  action: NonNullable<NixxieConfig['lists'][string]['actions']>[string]
+): InitialisedAction['graphql'] {
+  const graphqlNames = {
+    one: action.graphql?.singular ?? `${actionKey}${listGraphqlNames.singular}`,
+    many: action.graphql?.plural ?? `${actionKey}${listGraphqlNames.plural}`,
+  }
+  const argsName = `${graphqlNames.one[0].toUpperCase()}${graphqlNames.one.slice(1)}Args`
+  const argumentFields = Object.fromEntries(
+    Object.entries(action.args ?? {}).map(([arg, value]) => [arg, value.graphql])
+  )
+
+  return {
+    arguments: Object.entries(argumentFields).map(([name, arg]) => ({
+      name,
+      type: printGraphQLType(arg.type as unknown as GraphQLType),
+      source: getArgSources(action)[name] ?? null,
+    })),
+    names: {
+      ...graphqlNames,
+      args: argsName,
+    },
+    types: {
+      arguments: argumentFields,
+      args: g.inputObject({
+        name: argsName,
+        isOneOf: false,
+        fields: {
+          where: g.arg({
+            type: g.nonNull(list.graphql.types.uniqueWhere),
+          }),
+          ...argumentFields,
+        },
+      }),
+    },
+  }
+}
+
+export function initialiseLists(config: NixxieConfig): Record<string, InitialisedList> {
+  const listsRef: Record<string, InitialisedList> = {}
+  let intermediateLists
+
+  // step 1
+  intermediateLists = getListsWithInitialisedFields(config, listsRef)
+
+  // step 2
+  const resolvedDBFieldsForLists = resolveRelationships(intermediateLists)
+  intermediateLists = Object.fromEntries(
+    Object.values(intermediateLists).map(list => [
+      list.listKey,
+      {
+        ...list,
+        resolvedDbFields: resolvedDBFieldsForLists[list.listKey],
+      },
+    ])
+  )
+
+  // step 3
+  intermediateLists = Object.fromEntries(
+    Object.values(intermediateLists).map(list => {
+      const fields: Record<string, InitialisedField> = {}
+
+      for (const [fieldKey, field] of Object.entries(list.fields)) {
+        fields[fieldKey] = {
+          ...field,
+          dbField: list.resolvedDbFields[fieldKey],
+        }
+      }
+
+      return [list.listKey, { ...list, fields }]
+    })
+  )
+
+  // fixup the GraphQL refs
+  for (const list of Object.values(intermediateLists)) {
+    listsRef[list.listKey] = {
+      ...list,
+      lists: listsRef,
+    }
+  }
+
+  for (const list of Object.values(listsRef)) {
+    const listConfig = config.lists[list.listKey]
+    let hasAnEnabledCreateField = false
+    let hasAnEnabledUpdateField = false
+
+    for (const field of Object.values(list.fields)) {
+      if (field.input?.create?.arg && field.graphql.isEnabled.create) {
+        hasAnEnabledCreateField = true
+      }
+      if (field.input?.update && field.graphql.isEnabled.update) {
+        hasAnEnabledUpdateField = true
+      }
+    }
+
+    if (!hasAnEnabledCreateField) {
+      list.graphql.types.create = g.Empty
+      list.graphql.names.createInputName = 'Empty'
+    }
+
+    if (!hasAnEnabledUpdateField) {
+      list.graphql.types.update = g.Empty
+      list.graphql.names.updateInputName = 'Empty'
+    }
+
+    list.actions = Object.entries(listConfig.actions ?? {}).map(
+      ([actionKey, action]): InitialisedAction => {
+        const { label } = action.ui
+        const graphql = getInitialisedActionGraphql(
+          list,
+          __getNames(list.listKey, listConfig).graphql,
+          actionKey,
+          action
+        )
+
+        return {
+          ...action,
+          actionKey,
+          graphql,
+          otel: humanize(graphql.names.one, true).toLowerCase(),
+          ui: {
+            label,
+            icon: action.ui.icon ?? null,
+            messages: {
+              promptTitle: `{Label} {singular}`,
+              promptTitleMany: `{Label} {count} {singular|plural}`,
+              prompt: `Are you sure you want to {label} {singular} "{itemLabel}"?`,
+              promptMany: `Are you sure you want to {label} {count} {singular|plural}?`,
+              promptConfirmLabel: `Yes, {label} this {singular}`,
+              promptConfirmLabelMany: `Yes, {label} {count} {singular|plural}`,
+              fail: `Could not {label} {singular}`,
+              failMany: `Could not {label} {countFail} {singular|plural}`,
+              success: `Completed {label} action for {singular}`,
+              successMany: `Completed {label} action for {countSuccess} {singular|plural}`,
+              ...action.ui.messages,
+            },
+            itemView: {
+              actionMode: action.ui.itemView?.actionMode ?? 'enabled',
+              navigation: action.ui.itemView?.navigation ?? 'follow',
+              hidePrompt: action.ui.itemView?.hidePrompt ?? false,
+              hideToast: action.ui.itemView?.hideToast ?? false,
+            },
+            listView: {
+              actionMode: action.ui.listView?.actionMode ?? 'enabled',
+            },
+            argSources: getArgSources(action),
+          },
+        }
+      }
+    )
+  }
+
+  // error checking
+  for (const list of Object.values(listsRef)) {
+    assertFieldsValid(list)
+  }
+
+  // do some introspection
+  introspectGraphQLTypes(listsRef)
+
+  return listsRef
+}