@nixxie-cms/core 1.0.0

package/src/lib/admin-meta.ts

@@ -0,0 +1,369 @@
+import path from 'node:path'
+
+import type {
+  BaseFieldTypeInfo,
+  BaseItem,
+  BaseListTypeInfo,
+  ConditionalFilter,
+  ConditionalFilterCase,
+  NixxieConfig,
+  NixxieContext,
+  ListSortDescriptor,
+  MaybeBooleanItemFunctionWithFilter,
+  MaybeFieldFunction,
+  MaybeItemActionFunctionWithFilter,
+  MaybeItemFieldFunction,
+  MaybeItemFieldFunctionWithFilter,
+  MaybePromise,
+  MaybeSessionFunction,
+} from '../types'
+import type { ActionMeta, FieldMeta, ListMeta } from '../types/admin-meta'
+import type { GraphQLNames, JSONValue } from '../types/utils'
+import type { InitialisedList } from './core/initialise-lists'
+
+type EmptyResolver<Return> = (args: {}, context: NixxieContext) => MaybePromise<Return>
+
+type FieldMetaSource_ = {
+  listKey: string
+  fieldKey: string
+  isOrderable: EmptyResolver<boolean>
+  isFilterable: EmptyResolver<boolean>
+
+  createView: {
+    fieldMode: EmptyResolver<ConditionalFilter<'edit' | 'hidden', 'hidden', BaseListTypeInfo>>
+    isRequired: EmptyResolver<ConditionalFilterCase<BaseListTypeInfo>>
+  }
+  itemView: {
+    fieldMode: MaybeItemFieldFunctionWithFilter<
+      'edit' | 'read' | 'hidden',
+      'read' | 'hidden',
+      BaseListTypeInfo,
+      BaseFieldTypeInfo
+    >
+    fieldPosition: MaybeItemFieldFunction<'form' | 'sidebar', BaseListTypeInfo, BaseFieldTypeInfo>
+    isRequired: MaybeBooleanItemFunctionWithFilter<BaseListTypeInfo, BaseFieldTypeInfo>
+  }
+  listView: {
+    fieldMode: EmptyResolver<'read' | 'hidden'>
+  }
+  item: BaseItem | null
+  itemField: BaseItem[string] | null
+}
+export type FieldMetaSource = FieldMetaSource_ &
+  Omit<FieldMeta, keyof FieldMetaSource_ | 'controller' | 'views'>
+
+type ActionMetaSource_ = {
+  listKey: string
+  itemView: Omit<ActionMeta['itemView'], 'actionMode'> & {
+    actionMode: MaybeItemActionFunctionWithFilter<
+      'enabled' | 'disabled' | 'hidden',
+      'disabled' | 'hidden',
+      BaseListTypeInfo
+    >
+  }
+  listView: {
+    actionMode: EmptyResolver<
+      ConditionalFilter<'enabled' | 'disabled' | 'hidden', 'disabled' | 'hidden', BaseListTypeInfo>
+    >
+  }
+  item: BaseItem | null
+}
+export type ActionMetaSource = ActionMetaSource_ & Omit<ActionMeta, keyof ActionMetaSource_>
+
+type ListMetaSource_ = {
+  fields: FieldMetaSource[]
+  fieldsByKey: Record<string, FieldMetaSource>
+  groups: {
+    label: string
+    description: string
+    fields: FieldMetaSource[]
+  }[]
+  actions: ActionMetaSource[]
+  graphql: { names: GraphQLNames }
+  pageSize: number
+  initialColumns: string[]
+  initialFilter: EmptyResolver<JSONValue>
+  initialSearchFields: string[]
+  initialSort: ListSortDescriptor<string> | null
+  isSingleton: boolean
+
+  hideNavigation: EmptyResolver<boolean>
+  hideCreate: EmptyResolver<boolean>
+  hideDelete: EmptyResolver<boolean>
+  item: BaseItem | null
+}
+export type ListMetaSource = ListMetaSource_ & Omit<ListMeta, keyof ListMetaSource_>
+
+export type AdminMetaSource = {
+  lists: ListMetaSource[]
+  listsByKey: Record<string, ListMetaSource>
+  views: string[]
+  isAccessAllowed: (context: NixxieContext) => MaybePromise<boolean>
+}
+
+export function createAdminMeta(
+  config: NixxieConfig,
+  initialisedLists: Record<string, InitialisedList>
+) {
+  const { lists } = config
+  const adminMetaRoot: AdminMetaSource = {
+    listsByKey: {},
+    lists: [],
+    views: [],
+    isAccessAllowed: config.ui?.isAccessAllowed,
+  }
+
+  const omittedLists: string[] = []
+
+  for (const [listKey, list] of Object.entries(initialisedLists)) {
+    const listConfig = lists[listKey]
+
+    // TODO: is this reasonable?
+    if (list.graphql.isEnabled.query === false) {
+      omittedLists.push(listKey)
+      continue
+    }
+
+    let initialColumns: string[]
+    if (listConfig.ui?.listView?.initialColumns) {
+      // if they've asked for a particular thing, give them that thing
+      initialColumns = listConfig.ui.listView.initialColumns as string[]
+    } else {
+      // otherwise, we'll start with the labelfield on the left and then add
+      // 2 more fields to the right of that. We don't include the 'id' field
+      // unless it happened to be the labelField
+      initialColumns = [
+        list.ui.labelField,
+        ...Object.keys(list.fields)
+          .filter(fieldKey => list.fields[fieldKey].graphql.isEnabled.read)
+          .filter(fieldKey => fieldKey !== list.ui.labelField)
+          .filter(fieldKey => fieldKey !== 'id'),
+      ].slice(0, 3)
+    }
+
+    let initialSearchFields = listConfig.ui?.searchFields?.concat()
+    if (!initialSearchFields) {
+      initialSearchFields = [...list.ui.triviallySearchableFields]
+    }
+
+    const maximumPageSize = Math.min(
+      listConfig.ui?.listView?.pageSize ?? 50,
+      (list.graphql.types.findManyArgs.take.defaultValue ?? Infinity) as number
+    )
+
+    adminMetaRoot.listsByKey[listKey] = {
+      key: listKey,
+      path: list.ui.labels.path,
+
+      label: list.ui.labels.label,
+      singular: list.ui.labels.singular,
+      plural: list.ui.labels.plural,
+
+      labelField: list.ui.labelField,
+      fields: [],
+      fieldsByKey: {},
+      groups: [],
+      actions: [],
+
+      graphql: {
+        names: list.graphql.names,
+      },
+
+      pageSize: maximumPageSize,
+      initialColumns,
+      initialSearchFields,
+      initialSort:
+        (listConfig.ui?.listView?.initialSort as ListSortDescriptor<string> | undefined) ?? null,
+      initialFilter: normalizeMaybeSessionFunction(listConfig.ui?.listView?.initialFilter ?? {}),
+      isSingleton: list.isSingleton,
+
+      hideNavigation: normalizeMaybeSessionFunction(listConfig.ui?.hideNavigation ?? false),
+      hideCreate: normalizeMaybeSessionFunction(
+        listConfig.ui?.hideCreate ?? !list.graphql.isEnabled.create
+      ),
+      hideDelete: normalizeMaybeSessionFunction(
+        listConfig.ui?.hideDelete ?? !list.graphql.isEnabled.delete
+      ),
+
+      item: null, // part of resolver
+    } satisfies ListMetaSource
+
+    adminMetaRoot.lists.push(adminMetaRoot.listsByKey[listKey])
+  }
+
+  let uniqueViewCount = -1
+  const stringViewsToIndex: Record<string, number> = {}
+  function getViewId(view: string) {
+    if (stringViewsToIndex[view] !== undefined) return stringViewsToIndex[view]
+
+    uniqueViewCount++
+    stringViewsToIndex[view] = uniqueViewCount
+    adminMetaRoot.views.push(view)
+    return uniqueViewCount
+  }
+
+  for (const [listKey, list] of Object.entries(initialisedLists)) {
+    if (omittedLists.includes(listKey)) continue
+
+    const listMeta = adminMetaRoot.listsByKey[listKey]
+
+    // populate .fields
+    for (const [fieldKey, field] of Object.entries(list.fields)) {
+      // if the field is a relationship field and is related to an omitted list, skip.
+      if (field.dbField.kind === 'relation' && omittedLists.includes(field.dbField.list)) continue
+      if (Object.values(field.graphql.isEnabled).every(x => x === false)) continue
+      assertValidView(
+        field.views,
+        `The \`views\` on the implementation of the field type at lists.${listKey}.fields.${fieldKey}`
+      )
+
+      const baseOrderFilterArgs = { fieldKey, listKey: list.listKey }
+      const isNonNull = (['read', 'create', 'update'] as const).filter(
+        operation => field.graphql.isNonNull[operation]
+      )
+      const fieldMeta = {
+        // FieldMeta
+        key: fieldKey,
+        label: field.ui.label,
+        description: field.ui.description,
+        fieldMeta: null,
+        viewsIndex: getViewId(field.views),
+        customViewsIndex:
+          field.ui.views === null
+            ? null
+            : (assertValidView(field.views, `lists.${listKey}.fields.${fieldKey}.ui.views`),
+              getViewId(field.ui.views)),
+        search: list.ui.searchableFields.get(fieldKey) ?? null,
+
+        // FieldMetaSource_
+        listKey: listKey,
+        fieldKey: fieldKey,
+        isFilterable: normalizeIsOrderFilter(
+          field.input?.where ? field.graphql.isEnabled.filter : false,
+          baseOrderFilterArgs
+        ),
+        isOrderable: normalizeIsOrderFilter(
+          field.input?.orderBy ? field.graphql.isEnabled.orderBy : false,
+          baseOrderFilterArgs
+        ),
+
+        isNonNull,
+        createView: {
+          fieldMode: normalizeMaybeSessionFunction(field.ui.createView.fieldMode),
+          isRequired: normalizeMaybeSessionFunction(field.ui.createView.isRequired ?? false),
+        },
+        itemView: {
+          fieldMode: field.ui.itemView.fieldMode,
+          fieldPosition: field.ui.itemView.fieldPosition,
+          isRequired: field.ui.itemView.isRequired,
+        },
+        listView: {
+          fieldMode: normalizeMaybeSessionFunction(field.ui.listView.fieldMode),
+        },
+
+        item: null, // part of resolver
+        itemField: null, // part of resolver
+      } satisfies FieldMetaSource
+
+      listMeta.fields.push(fieldMeta)
+      listMeta.fieldsByKey[fieldKey] = fieldMeta
+    }
+
+    // populate .actions
+    for (const action of list.actions) {
+      listMeta.actions.push({
+        // ActionMeta
+        key: action.actionKey,
+        label: action.ui.label,
+        icon: action.ui.icon,
+        messages: {
+          ...action.ui.messages,
+        },
+        graphql: {
+          arguments: action.graphql.arguments,
+          names: action.graphql.names,
+        },
+
+        // ActionMetaSource_
+        listKey,
+        itemView: {
+          ...action.ui.itemView,
+        },
+        listView: {
+          actionMode: normalizeMaybeSessionFunction(action.ui.listView.actionMode),
+        },
+        item: null, // part of resolver
+      })
+    }
+
+    // populate .groups
+    for (const group of list.groups) {
+      listMeta.groups.push({
+        label: group.label,
+        description: group.description,
+        fields: group.fields.map(
+          fieldKey => adminMetaRoot.listsByKey[listKey].fieldsByKey[fieldKey]
+        ),
+      })
+    }
+  }
+
+  // we do this seperately to the above so that fields can check other fields to validate their config or etc.
+  // (ofc they won't necessarily be able to see other field's fieldMeta)
+  for (const [key, list] of Object.entries(initialisedLists)) {
+    if (list.graphql.isEnabled.query === false) continue
+    for (const fieldMetaSource of adminMetaRoot.listsByKey[key].fields) {
+      // if the field is a relationship field and is related to an omitted list, skip.
+      const dbField = list.fields[fieldMetaSource.fieldKey].dbField
+      if (dbField.kind === 'relation' && omittedLists.includes(dbField.list)) continue
+
+      currentAdminMeta = adminMetaRoot
+      try {
+        fieldMetaSource.fieldMeta = list.fields[fieldMetaSource.fieldKey].getAdminMeta?.() ?? null
+      } finally {
+        currentAdminMeta = undefined
+      }
+    }
+  }
+
+  return adminMetaRoot
+}
+
+let currentAdminMeta: undefined | AdminMetaSource
+
+export function getAdminMetaForRelationshipField() {
+  if (currentAdminMeta) return currentAdminMeta
+  throw new Error('unexpected call to getAdminMetaInRelationshipField')
+}
+
+function assertValidView(view: string, location: string) {
+  if (view.includes('\\')) {
+    throw new Error(
+      `${location} contains a backslash, which is invalid. You need to use a module path that is resolved from where 'nixxie start' is run (see https://github.com/nixxiecms/nixxie/pull/7805)`
+    )
+  }
+
+  if (path.isAbsolute(view)) {
+    throw new Error(
+      `${location} is an absolute path, which is invalid. You need to use a module path that is resolved from where 'nixxie start' is run (see https://github.com/nixxiecms/nixxie/pull/7805)`
+    )
+  }
+}
+
+function normalizeMaybeSessionFunction<Return extends string | boolean | object | null | number>(
+  input: MaybeSessionFunction<Return, BaseListTypeInfo>
+): EmptyResolver<Return> {
+  if (typeof input !== 'function') return () => input
+  return (_, context) => input({ context, session: context.session })
+}
+
+function normalizeIsOrderFilter(
+  input: MaybeFieldFunction<BaseListTypeInfo>,
+  baseOrderFilterArgs: {
+    listKey: string
+    fieldKey: string
+  }
+): EmptyResolver<boolean> {
+  if (typeof input !== 'function') return () => input
+  return (_, context) => input({ context, session: context.session, ...baseOrderFilterArgs })
+}

package/src/lib/coerceAndValidateForGraphQLInput.ts

@@ -0,0 +1,29 @@
+import type { GraphQLError, GraphQLInputType, GraphQLSchema, VariableDefinitionNode } from 'graphql'
+import { Kind } from 'graphql'
+import { getVariableValues } from 'graphql/execution/values'
+
+import { getTypeNodeForType } from './context/graphql'
+
+const argName = 'where'
+
+export function coerceAndValidateForGraphQLInput(
+  schema: GraphQLSchema,
+  type: GraphQLInputType,
+  value: any
+): { kind: 'valid'; value: any } | { kind: 'error'; error: GraphQLError } {
+  const variableDefintions: VariableDefinitionNode[] = [
+    {
+      kind: Kind.VARIABLE_DEFINITION,
+      type: getTypeNodeForType(type),
+      variable: { kind: Kind.VARIABLE, name: { kind: Kind.NAME, value: argName } },
+    },
+  ]
+
+  const coercedVariableValues = getVariableValues(schema, variableDefintions, {
+    [argName]: value,
+  })
+  if (coercedVariableValues.errors) {
+    return { kind: 'error', error: coercedVariableValues.errors[0] }
+  }
+  return { kind: 'valid', value: coercedVariableValues.coerced[argName] }
+}

package/src/lib/context/api.ts

@@ -0,0 +1,99 @@
+import type { GraphQLSchema } from 'graphql'
+import type { NixxieContext } from '../../types'
+import type { InitialisedList } from '../core/initialise-lists'
+import { makeContextDbFn, makeContextQueryFn } from './graphql'
+
+export function getQueryFactory(list: InitialisedList, schema: GraphQLSchema) {
+  const queryType = schema.getQueryType()!
+  const mutationType = schema.getMutationType()!
+
+  function f(operation: 'query' | 'mutation', fieldName: string) {
+    const rootType = operation === 'query' ? queryType : mutationType
+    const field = rootType.getFields()[fieldName]
+    if (field) return makeContextQueryFn(schema, operation, field)
+
+    // if omitted
+    return () => {
+      throw new Error(`This ${operation} is not supported by the GraphQL schema: ${fieldName}()`)
+    }
+  }
+
+  const { listQueryCountName, whereInputName } = list.graphql.names
+  const fcache = {
+    findOne: f('query', list.graphql.names.itemQueryName),
+    findMany: f('query', list.graphql.names.listQueryName),
+    count: async (args: Record<string, any> = {}, context: NixxieContext) => {
+      const { where = {} } = args
+      const { count } = (await context.graphql.run({
+        query: `query ($where: ${whereInputName}!) { count: ${listQueryCountName}(where: $where) }`,
+        variables: { where },
+      })) as {
+        count: number
+      }
+
+      return count
+    },
+    createOne: f('mutation', list.graphql.names.createMutationName),
+    createMany: f('mutation', list.graphql.names.createManyMutationName),
+    updateOne: f('mutation', list.graphql.names.updateMutationName),
+    updateMany: f('mutation', list.graphql.names.updateManyMutationName),
+    deleteOne: f('mutation', list.graphql.names.deleteMutationName),
+    deleteMany: f('mutation', list.graphql.names.deleteManyMutationName),
+  }
+
+  return (context: NixxieContext) => {
+    return {
+      findOne: (args: Record<string, any>) => fcache.findOne(args, context),
+      findMany: (args: Record<string, any>) => fcache.findMany(args, context),
+      count: (args: Record<string, any>) => fcache.count(args, context),
+      createOne: (args: Record<string, any>) => fcache.createOne(args, context),
+      createMany: (args: Record<string, any>) => fcache.createMany(args, context),
+      updateOne: (args: Record<string, any>) => fcache.updateOne(args, context),
+      updateMany: (args: Record<string, any>) => fcache.updateMany(args, context),
+      deleteOne: (args: Record<string, any>) => fcache.deleteOne(args, context),
+      deleteMany: (args: Record<string, any>) => fcache.deleteMany(args, context),
+    }
+  }
+}
+
+export function getDbFactory(list: InitialisedList, schema: GraphQLSchema) {
+  const queryType = schema.getQueryType()!
+  const mutationType = schema.getMutationType()!
+
+  function f(operation: 'query' | 'mutation', fieldName: string) {
+    const rootType = operation === 'query' ? queryType : mutationType
+    const field = rootType.getFields()[fieldName]
+    if (field) return makeContextDbFn(field)
+
+    // if omitted
+    return () => {
+      throw new Error(`This ${operation} is not supported by the GraphQL schema: ${fieldName}()`)
+    }
+  }
+
+  const fcache = {
+    findOne: f('query', list.graphql.names.itemQueryName),
+    findMany: f('query', list.graphql.names.listQueryName),
+    count: f('query', list.graphql.names.listQueryCountName),
+    createOne: f('mutation', list.graphql.names.createMutationName),
+    createMany: f('mutation', list.graphql.names.createManyMutationName),
+    updateOne: f('mutation', list.graphql.names.updateMutationName),
+    updateMany: f('mutation', list.graphql.names.updateManyMutationName),
+    deleteOne: f('mutation', list.graphql.names.deleteMutationName),
+    deleteMany: f('mutation', list.graphql.names.deleteManyMutationName),
+  }
+
+  return (context: NixxieContext) => {
+    return {
+      findOne: (args: Record<string, any>) => fcache.findOne(args, context),
+      findMany: (args: Record<string, any>) => fcache.findMany(args, context),
+      count: (args: Record<string, any>) => fcache.count(args, context),
+      createOne: (args: Record<string, any>) => fcache.createOne(args, context),
+      createMany: (args: Record<string, any>) => fcache.createMany(args, context),
+      updateOne: (args: Record<string, any>) => fcache.updateOne(args, context),
+      updateMany: (args: Record<string, any>) => fcache.updateMany(args, context),
+      deleteOne: (args: Record<string, any>) => fcache.deleteOne(args, context),
+      deleteMany: (args: Record<string, any>) => fcache.deleteMany(args, context),
+    }
+  }
+}

package/src/lib/context/createContext.ts

@@ -0,0 +1,161 @@
+import type { IncomingMessage, ServerResponse } from 'http'
+import { type ExecutionResult, type GraphQLSchema, graphql, print } from 'graphql'
+import type { NixxieContext, NixxieGraphQLAPI, NixxieConfig } from '../../types'
+
+import { type InitialisedList } from '../core/initialise-lists'
+import { getDbFactory, getQueryFactory } from './api'
+
+export function createContext({
+  config,
+  lists,
+  graphQLSchemas,
+  prismaClient,
+  prismaTypes,
+}: {
+  config: NixxieConfig
+  lists: Record<string, InitialisedList>
+  graphQLSchemas: {
+    public: GraphQLSchema
+    internal: GraphQLSchema
+  }
+  prismaClient: unknown
+  prismaTypes: {
+    DbNull: unknown
+    JsonNull: unknown
+  }
+}) {
+  const dbFactories: Record<string, ReturnType<typeof getDbFactory>> = {}
+  for (const [listKey, list] of Object.entries(lists)) {
+    dbFactories[listKey] = getDbFactory(list, graphQLSchemas.public)
+  }
+
+  const dbFactoriesInternal: Record<string, ReturnType<typeof getDbFactory>> = {}
+  for (const [listKey, list] of Object.entries(lists)) {
+    dbFactoriesInternal[listKey] = getDbFactory(list, graphQLSchemas.internal)
+  }
+
+  const queryFactories: Record<string, ReturnType<typeof getQueryFactory>> = {}
+  for (const [listKey, list] of Object.entries(lists)) {
+    queryFactories[listKey] = getQueryFactory(list, graphQLSchemas.public)
+  }
+
+  const queryFactoriesInternal: Record<string, ReturnType<typeof getQueryFactory>> = {}
+  for (const [listKey, list] of Object.entries(lists)) {
+    queryFactoriesInternal[listKey] = getQueryFactory(list, graphQLSchemas.internal)
+  }
+
+  const construct = ({
+    prisma,
+    req,
+    res,
+    session,
+    internal,
+    sudo,
+  }: {
+    prisma: any
+    req?: IncomingMessage
+    res?: ServerResponse
+    session?: unknown
+    internal: boolean
+    sudo: boolean
+  }) => {
+    const schema = internal ? graphQLSchemas.internal : graphQLSchemas.public
+    const rawGraphQL: NixxieGraphQLAPI['raw'] = async ({ query, variables }) => {
+      const source = typeof query === 'string' ? query : print(query)
+      return (await graphql({
+        schema,
+        source,
+        contextValue: context,
+        variableValues: variables,
+      })) as ExecutionResult<any>
+    }
+
+    const runGraphQL: NixxieGraphQLAPI['run'] = async ({ query, variables }) => {
+      const result = await rawGraphQL({ query, variables })
+      if (result.errors?.length) throw result.errors[0]
+      return result.data as any
+    }
+
+    const context: NixxieContext = {
+      prisma,
+      db: {},
+      query: {},
+      graphql: { raw: rawGraphQL, run: runGraphQL, schema },
+      services: {
+        email: config.email ?? null,
+        jobs: config.jobs ?? null,
+        cache: config.cache ?? null,
+        audit: config.audit ?? null,
+        webhooks: config.webhooks ?? null,
+        rateLimit: config.rateLimit ?? null,
+        health: config.health ?? null,
+      },
+
+      transaction: async (f, opts) => {
+        return await prisma.$transaction(async (prisma_: any) => {
+          const newContext = construct({
+            prisma: prisma_,
+            req,
+            res,
+            session,
+            internal,
+            sudo,
+          })
+
+          return await f(newContext)
+        }, opts)
+      },
+
+      req,
+      res,
+      sessionStrategy: config.session,
+      ...(session ? { session } : {}),
+
+      withRequest: async (newReq, newRes) => {
+        const newContext = construct({
+          prisma,
+          req: newReq,
+          res: newRes,
+          session,
+          internal,
+          sudo,
+        })
+        return newContext.withSession(
+          (await config.session?.get({ context: newContext })) ?? undefined
+        )
+      },
+
+      withSession: session => {
+        return construct({ prisma, req, res, session, internal, sudo })
+      },
+
+      // privilege escalation
+      internal: () => construct({ prisma, req, res, session, internal: true, sudo }),
+      sudo: () => construct({ prisma, req, res, session, internal: true, sudo: true }),
+
+      __internal: {
+        sudo,
+        lists,
+        prisma: {
+          ...prismaTypes,
+        },
+      },
+    }
+
+    const _dbFactories = internal ? dbFactoriesInternal : dbFactories
+    const _queryFactories = internal ? queryFactoriesInternal : queryFactories
+
+    for (const listKey of Object.keys(lists)) {
+      context.db[listKey] = _dbFactories[listKey](context)
+      context.query[listKey] = _queryFactories[listKey](context)
+    }
+
+    return context
+  }
+
+  return construct({
+    prisma: prismaClient,
+    internal: false,
+    sudo: false,
+  })
+}