@nixxie-cms/core 1.0.0

package/dist/system-dfec2f0a.esm.js

@@ -0,0 +1,4273 @@
+import { randomBytes } from 'node:crypto';
+import path from 'node:path';
+import { c as createAdminMeta } from './admin-meta-14c60fec.esm.js';
+import { GraphQLScalarType, GraphQLObjectType, Kind, OperationTypeNode, GraphQLSchema, execute, astFromValue, GraphQLNonNull, GraphQLList, parse, validate as validate$1, print, graphql, assertInputObjectType, isInputObjectType, GraphQLString } from 'graphql';
+import { GNonNull, GInputObjectType } from '@graphql-ts/schema';
+import { u as userInputError, e as extensionError, b as accessReturnError, c as accessDeniedError, f as formatKeys, d as filterAccessError, l as limitsExceededError, g as expandVoidHooks, v as validationFailureError, r as resolverError, h as relationshipError } from './resolve-hooks-17aafd37.esm.js';
+import { _ as __getNames } from './utils-ef2cd0f4.esm.js';
+import { g, Q as QueryMode } from './next-fields-9bf04ed8.esm.js';
+import '@graphql-ts/extend';
+import { h as humanize } from './utils-0cc426c8.esm.js';
+import { allowAll } from '../access/dist/nixxie-cms-core-access.esm.js';
+import { getVariableValues } from 'graphql/execution/values';
+import { g as getDBFieldKeyForFieldOnMultiField, w as weakMemoize, a as areArraysEqual, i as isRejected, b as isFulfilled, p as promiseAllRejectWithAllErrors } from './utils-f9556354.esm.js';
+import 'pluralize';
+import { maybeCacheControlFromInfo } from '@apollo/cache-control-types';
+import DataLoader from 'dataloader';
+import _classPrivateFieldInitSpec from '@babel/runtime/helpers/esm/classPrivateFieldInitSpec';
+import _classPrivateFieldGet from '@babel/runtime/helpers/esm/classPrivateFieldGet2';
+import _classPrivateFieldSet from '@babel/runtime/helpers/esm/classPrivateFieldSet2';
+import { trace, SpanStatusCode } from '@opentelemetry/api';
+
+function getNamedOrListTypeNodeForType(type) {
+  if (type instanceof GraphQLList) {
+    return {
+      kind: Kind.LIST_TYPE,
+      type: getTypeNodeForType(type.ofType)
+    };
+  }
+  return {
+    kind: Kind.NAMED_TYPE,
+    name: {
+      kind: Kind.NAME,
+      value: type.name
+    }
+  };
+}
+function getTypeNodeForType(type) {
+  if (type instanceof GraphQLNonNull) {
+    return {
+      kind: Kind.NON_NULL_TYPE,
+      type: getNamedOrListTypeNodeForType(type.ofType)
+    };
+  }
+  return getNamedOrListTypeNodeForType(type);
+}
+function getVariablesForGraphQLField(field) {
+  const variableDefinitions = field.args.map(arg => {
+    var _ref;
+    return {
+      kind: Kind.VARIABLE_DEFINITION,
+      type: getTypeNodeForType(arg.type),
+      variable: {
+        kind: Kind.VARIABLE,
+        name: {
+          kind: Kind.NAME,
+          value: arg.name
+        }
+      },
+      defaultValue: arg.defaultValue === undefined ? undefined : (_ref = astFromValue(arg.defaultValue, arg.type)) !== null && _ref !== void 0 ? _ref : undefined
+    };
+  });
+  const argumentNodes = field.args.map(arg => ({
+    kind: Kind.ARGUMENT,
+    name: {
+      kind: Kind.NAME,
+      value: arg.name
+    },
+    value: {
+      kind: Kind.VARIABLE,
+      name: {
+        kind: Kind.NAME,
+        value: arg.name
+      }
+    }
+  }));
+  return {
+    variableDefinitions,
+    argumentNodes
+  };
+}
+function getRootTypeName(type) {
+  if (type instanceof GraphQLNonNull) {
+    return getRootTypeName(type.ofType);
+  }
+  if (type instanceof GraphQLList) {
+    return getRootTypeName(type.ofType);
+  }
+  return type.name;
+}
+const rawField = 'raw';
+const RawScalar = new GraphQLScalarType({
+  name: 'RawThingPlsDontRelyOnThisAnywhere'
+});
+const ReturnRawValueObjectType = new GraphQLObjectType({
+  name: 'ReturnRawValue',
+  fields: {
+    [rawField]: {
+      type: RawScalar,
+      resolve(source) {
+        return source;
+      }
+    }
+  }
+});
+function argsToArgsConfig(args) {
+  return Object.fromEntries(args.map(arg => {
+    const argConfig = {
+      astNode: arg.astNode,
+      defaultValue: arg.defaultValue,
+      deprecationReason: arg.deprecationReason,
+      description: arg.description,
+      extensions: arg.extensions,
+      type: arg.type
+    };
+    return [arg.name, argConfig];
+  }));
+}
+// note the GraphQLNonNull and GraphQLList constructors are incorrectly
+// not generic over their inner type which is why we have to use as
+// (the classes are generic but not the constructors)
+function getTypeForField(originalType) {
+  if (originalType instanceof GraphQLNonNull) {
+    return new GraphQLNonNull(getTypeForField(originalType.ofType));
+  }
+  if (originalType instanceof GraphQLList) {
+    return new GraphQLList(getTypeForField(originalType.ofType));
+  }
+  return ReturnRawValueObjectType;
+}
+function getSourceGivenOutputType(originalType, value) {
+  if (originalType instanceof GraphQLNonNull) {
+    return getSourceGivenOutputType(originalType.ofType, value);
+  }
+  if (value === null) return null;
+  if (originalType instanceof GraphQLList) {
+    return value.map(x => getSourceGivenOutputType(originalType.ofType, x));
+  }
+  return value[rawField];
+}
+function makeContextDbFn(field) {
+  const {
+    argumentNodes,
+    variableDefinitions
+  } = getVariablesForGraphQLField(field);
+  const document = {
+    kind: Kind.DOCUMENT,
+    definitions: [{
+      kind: Kind.OPERATION_DEFINITION,
+      operation: OperationTypeNode.QUERY,
+      selectionSet: {
+        kind: Kind.SELECTION_SET,
+        selections: [{
+          kind: Kind.FIELD,
+          name: {
+            kind: Kind.NAME,
+            value: field.name
+          },
+          arguments: argumentNodes,
+          selectionSet: {
+            kind: Kind.SELECTION_SET,
+            selections: [{
+              kind: Kind.FIELD,
+              name: {
+                kind: Kind.NAME,
+                value: rawField
+              }
+            }]
+          }
+        }]
+      },
+      variableDefinitions
+    }]
+  };
+  const type = getTypeForField(field.type);
+  const fieldConfig = {
+    args: argsToArgsConfig(field.args),
+    astNode: undefined,
+    deprecationReason: field.deprecationReason,
+    description: field.description,
+    extensions: field.extensions,
+    resolve: field.resolve,
+    subscribe: field.subscribe,
+    type
+  };
+
+  // we construct a schema as we need return a different type than the one in the base GraphQL schema
+  const schema = new GraphQLSchema({
+    query: new GraphQLObjectType({
+      name: 'Query',
+      fields: {
+        [field.name]: fieldConfig
+      }
+    }),
+    assumeValid: true
+  });
+  return async (args, context, rootValue = {}) => {
+    var _result$errors;
+    const result = await execute({
+      schema,
+      document,
+      contextValue: context,
+      variableValues: args,
+      rootValue
+    });
+    if ((_result$errors = result.errors) !== null && _result$errors !== void 0 && _result$errors.length) {
+      throw result.errors[0];
+    }
+    return getSourceGivenOutputType(type, result.data[field.name]);
+  };
+}
+function makeContextQueryFn(schema, operation, field) {
+  const {
+    argumentNodes,
+    variableDefinitions
+  } = getVariablesForGraphQLField(field);
+  const rootName = getRootTypeName(field.type);
+  const exec = async (args, query, context) => {
+    var _result$errors2;
+    const selectionSet = parse(`fragment x on ${rootName} {${query}}`).definitions[0].selectionSet;
+    const document = {
+      kind: Kind.DOCUMENT,
+      definitions: [{
+        kind: Kind.OPERATION_DEFINITION,
+        // OperationTypeNode is an ts enum where the values are 'query' | 'mutation' | 'subscription'
+        operation: operation,
+        selectionSet: {
+          kind: Kind.SELECTION_SET,
+          selections: [{
+            kind: Kind.FIELD,
+            name: {
+              kind: Kind.NAME,
+              value: field.name
+            },
+            arguments: argumentNodes,
+            selectionSet: selectionSet
+          }]
+        },
+        variableDefinitions
+      }]
+    };
+    const validationErrors = validate$1(schema, document);
+    if (validationErrors.length > 0) {
+      throw validationErrors[0];
+    }
+    const result = await execute({
+      schema,
+      document,
+      contextValue: context,
+      variableValues: Object.fromEntries(
+      // GraphQL for some reason decides to make undefined values in args
+      // skip defaulting for some reason
+      // this ofc doesn't technically fully fix it (bc nested things)
+      // but for the cases where we care, it does
+      Object.entries(args).filter(([, val]) => val !== undefined)),
+      rootValue: {}
+    });
+    if ((_result$errors2 = result.errors) !== null && _result$errors2 !== void 0 && _result$errors2.length) {
+      throw result.errors[0];
+    }
+    return result.data[field.name];
+  };
+  return (_args = {}, context) => {
+    const {
+      query,
+      ...args
+    } = _args;
+    return exec(args, query !== null && query !== void 0 ? query : 'id', context);
+  };
+}
+
+function getQueryFactory(list, schema) {
+  const queryType = schema.getQueryType();
+  const mutationType = schema.getMutationType();
+  function f(operation, fieldName) {
+    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 = {}, context) => {
+      const {
+        where = {}
+      } = args;
+      const {
+        count
+      } = await context.graphql.run({
+        query: `query ($where: ${whereInputName}!) { count: ${listQueryCountName}(where: $where) }`,
+        variables: {
+          where
+        }
+      });
+      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 => {
+    return {
+      findOne: args => fcache.findOne(args, context),
+      findMany: args => fcache.findMany(args, context),
+      count: args => fcache.count(args, context),
+      createOne: args => fcache.createOne(args, context),
+      createMany: args => fcache.createMany(args, context),
+      updateOne: args => fcache.updateOne(args, context),
+      updateMany: args => fcache.updateMany(args, context),
+      deleteOne: args => fcache.deleteOne(args, context),
+      deleteMany: args => fcache.deleteMany(args, context)
+    };
+  };
+}
+function getDbFactory(list, schema) {
+  const queryType = schema.getQueryType();
+  const mutationType = schema.getMutationType();
+  function f(operation, fieldName) {
+    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 => {
+    return {
+      findOne: args => fcache.findOne(args, context),
+      findMany: args => fcache.findMany(args, context),
+      count: args => fcache.count(args, context),
+      createOne: args => fcache.createOne(args, context),
+      createMany: args => fcache.createMany(args, context),
+      updateOne: args => fcache.updateOne(args, context),
+      updateMany: args => fcache.updateMany(args, context),
+      deleteOne: args => fcache.deleteOne(args, context),
+      deleteMany: args => fcache.deleteMany(args, context)
+    };
+  };
+}
+
+function createContext({
+  config,
+  lists,
+  graphQLSchemas,
+  prismaClient,
+  prismaTypes
+}) {
+  const dbFactories = {};
+  for (const [listKey, list] of Object.entries(lists)) {
+    dbFactories[listKey] = getDbFactory(list, graphQLSchemas.public);
+  }
+  const dbFactoriesInternal = {};
+  for (const [listKey, list] of Object.entries(lists)) {
+    dbFactoriesInternal[listKey] = getDbFactory(list, graphQLSchemas.internal);
+  }
+  const queryFactories = {};
+  for (const [listKey, list] of Object.entries(lists)) {
+    queryFactories[listKey] = getQueryFactory(list, graphQLSchemas.public);
+  }
+  const queryFactoriesInternal = {};
+  for (const [listKey, list] of Object.entries(lists)) {
+    queryFactoriesInternal[listKey] = getQueryFactory(list, graphQLSchemas.internal);
+  }
+  const construct = ({
+    prisma,
+    req,
+    res,
+    session,
+    internal,
+    sudo
+  }) => {
+    var _config$email, _config$jobs, _config$cache, _config$audit, _config$webhooks, _config$rateLimit, _config$health;
+    const schema = internal ? graphQLSchemas.internal : graphQLSchemas.public;
+    const rawGraphQL = async ({
+      query,
+      variables
+    }) => {
+      const source = typeof query === 'string' ? query : print(query);
+      return await graphql({
+        schema,
+        source,
+        contextValue: context,
+        variableValues: variables
+      });
+    };
+    const runGraphQL = async ({
+      query,
+      variables
+    }) => {
+      var _result$errors;
+      const result = await rawGraphQL({
+        query,
+        variables
+      });
+      if ((_result$errors = result.errors) !== null && _result$errors !== void 0 && _result$errors.length) throw result.errors[0];
+      return result.data;
+    };
+    const context = {
+      prisma,
+      db: {},
+      query: {},
+      graphql: {
+        raw: rawGraphQL,
+        run: runGraphQL,
+        schema
+      },
+      services: {
+        email: (_config$email = config.email) !== null && _config$email !== void 0 ? _config$email : null,
+        jobs: (_config$jobs = config.jobs) !== null && _config$jobs !== void 0 ? _config$jobs : null,
+        cache: (_config$cache = config.cache) !== null && _config$cache !== void 0 ? _config$cache : null,
+        audit: (_config$audit = config.audit) !== null && _config$audit !== void 0 ? _config$audit : null,
+        webhooks: (_config$webhooks = config.webhooks) !== null && _config$webhooks !== void 0 ? _config$webhooks : null,
+        rateLimit: (_config$rateLimit = config.rateLimit) !== null && _config$rateLimit !== void 0 ? _config$rateLimit : null,
+        health: (_config$health = config.health) !== null && _config$health !== void 0 ? _config$health : null
+      },
+      transaction: async (f, opts) => {
+        return await prisma.$transaction(async prisma_ => {
+          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) => {
+        var _await$config$session, _config$session;
+        const newContext = construct({
+          prisma,
+          req: newReq,
+          res: newRes,
+          session,
+          internal,
+          sudo
+        });
+        return newContext.withSession((_await$config$session = await ((_config$session = config.session) === null || _config$session === void 0 ? void 0 : _config$session.get({
+          context: newContext
+        }))) !== null && _await$config$session !== void 0 ? _await$config$session : 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
+  });
+}
+
+const argName = 'where';
+function coerceAndValidateForGraphQLInput(schema, type, value) {
+  const variableDefintions = [{
+    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]
+  };
+}
+
+async function resolveUniqueWhereInput(inputFilter, list, context) {
+  const where = {};
+  for (const key in inputFilter) {
+    const value = inputFilter[key];
+    const resolver = list.fields[key].input.uniqueWhere.resolve;
+    if (resolver !== undefined) {
+      where[key] = await resolver(value, context);
+    } else {
+      where[key] = value;
+    }
+  }
+  return where;
+}
+async function resolveWhereInput(inputFilter, list, context) {
+  return {
+    AND: await Promise.all(Object.entries(inputFilter).map(async ([key, value]) => {
+      if (key === 'OR' || key === 'AND' || key === 'NOT') {
+        return {
+          [key]: await Promise.all(value.map(value => resolveWhereInput(value, list, context)))
+        };
+      }
+
+      // we know if there are filters in the input object with the key of a field,
+      //   the field must have defined a where input so this non null assertion is okay
+      const field = list.fields[key];
+      const {
+        dbField
+      } = field;
+      const resolve = field.input.where.resolve;
+      const ret = resolve ? await resolve(value, context, (() => {
+        if (dbField.kind !== 'relation') {
+          return undefined;
+        }
+        const foreignList = dbField.list;
+        const whereResolver = filter => resolveWhereInput(filter, list.lists[foreignList], context);
+        if (dbField.mode === 'many') {
+          return async () => {
+            if (value === null) {
+              throw userInputError('A many relation filter cannot be set to null');
+            }
+            return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, val]) => {
+              if (val === null) {
+                throw userInputError(`The key "${key}" in a many relation filter cannot be set to null`);
+              }
+              return [key, await whereResolver(val)];
+            })));
+          };
+        }
+        return value => {
+          if (value === null) return null;
+          return whereResolver(value);
+        };
+      })()) : value;
+      if (ret === null) {
+        if (dbField.kind === 'multi') {
+          // Note: no built-in field types support multi valued database fields *and* filtering.
+          // This code path is only relevent to custom fields which fit that criteria.
+          throw new Error('multi db fields cannot return null from where input resolvers');
+        }
+        return {
+          [key]: null
+        };
+      }
+      return handleOperators(key, dbField, ret);
+    }))
+  };
+}
+function handleOperators(fieldKey, dbField, {
+  AND,
+  OR,
+  NOT,
+  ...rest
+}) {
+  return {
+    AND: AND === null || AND === void 0 ? void 0 : AND.map(value => handleOperators(fieldKey, dbField, value)),
+    OR: OR === null || OR === void 0 ? void 0 : OR.map(value => handleOperators(fieldKey, dbField, value)),
+    NOT: NOT === null || NOT === void 0 ? void 0 : NOT.map(value => handleOperators(fieldKey, dbField, value)),
+    ...nestWithAppropiateField(fieldKey, dbField, rest)
+  };
+}
+function nestWithAppropiateField(fieldKey, dbField, value) {
+  if (dbField.kind === 'multi') {
+    return Object.fromEntries(Object.entries(value).map(([key, val]) => [getDBFieldKeyForFieldOnMultiField(fieldKey, key), val]));
+  }
+  return {
+    [fieldKey]: value
+  };
+}
+
+function cannotForItem(operation, list) {
+  if (operation === 'create') return `You cannot ${operation} that ${list.graphql.names.outputTypeName}`;
+  return `You cannot ${operation} that ${list.graphql.names.outputTypeName} - it may not exist`;
+}
+function cannotActionForItem(action, list) {
+  return `You cannot execute action "${action.actionKey}" for that ${list.graphql.names.outputTypeName}`;
+}
+function cannotForItemFields(operation, list, fieldsDenied) {
+  return `You cannot ${operation} that ${list.graphql.names.outputTypeName} - you cannot ${operation} the fields ${formatKeys(fieldsDenied)}`;
+}
+async function getOperationFieldAccess(item, list, fieldKey, context, operation) {
+  if (context.__internal.sudo) return true;
+  const {
+    listKey
+  } = list;
+  let result;
+  try {
+    result = await list.fields[fieldKey].access.read({
+      operation: 'read',
+      session: context.session,
+      listKey,
+      fieldKey,
+      context,
+      item
+    });
+  } catch (error) {
+    throw extensionError('Access control', [{
+      error,
+      tag: `${list.listKey}.${fieldKey}.access.${operation}`
+    }]);
+  }
+  if (typeof result !== 'boolean') {
+    throw accessReturnError([{
+      tag: `${listKey}.access.operation.${operation}`,
+      returned: typeof result
+    }]);
+  }
+  return result;
+}
+async function getOperationAccess(list, context, operation) {
+  if (context.__internal.sudo) return true;
+  const {
+    listKey
+  } = list;
+  let result;
+  try {
+    if (operation === 'query') {
+      result = await list.access.operation.query({
+        operation,
+        session: context.session,
+        listKey,
+        context
+      });
+    } else if (operation === 'create') {
+      result = await list.access.operation.create({
+        operation,
+        session: context.session,
+        listKey,
+        context
+      });
+    } else if (operation === 'update') {
+      result = await list.access.operation.update({
+        operation,
+        session: context.session,
+        listKey,
+        context
+      });
+    } else if (operation === 'delete') {
+      result = await list.access.operation.delete({
+        operation,
+        session: context.session,
+        listKey,
+        context
+      });
+    }
+  } catch (error) {
+    throw extensionError('Access control', [{
+      error,
+      tag: `${listKey}.access.operation.${operation}`
+    }]);
+  }
+  if (typeof result !== 'boolean') {
+    throw accessReturnError([{
+      tag: `${listKey}.access.operation.${operation}`,
+      returned: typeof result
+    }]);
+  }
+  return result;
+}
+async function getAccessFilters(list, context, operation) {
+  if (context.__internal.sudo) return true;
+  try {
+    let filters;
+    if (operation === 'query') {
+      filters = await list.access.filter.query({
+        operation,
+        session: context.session,
+        listKey: list.listKey,
+        context
+      });
+    } else if (operation === 'update') {
+      filters = await list.access.filter.update({
+        operation,
+        session: context.session,
+        listKey: list.listKey,
+        context
+      });
+    } else if (operation === 'delete') {
+      filters = await list.access.filter.delete({
+        operation,
+        session: context.session,
+        listKey: list.listKey,
+        context
+      });
+    }
+    if (typeof filters === 'boolean') return filters;
+    if (!filters) return false; // shouldn't happen, but, Typescript
+
+    const schema = context.sudo().graphql.schema;
+    const whereInput = assertInputObjectType(schema.getType(list.graphql.names.whereInputName));
+    const result = coerceAndValidateForGraphQLInput(schema, whereInput, filters);
+    if (result.kind === 'valid') return result.value;
+    throw result.error;
+  } catch (error) {
+    throw extensionError('Access control', [{
+      error,
+      tag: `${list.listKey}.access.filter.${operation}`
+    }]);
+  }
+}
+async function enforceListLevelAccessControl(context, operation, list, inputData, item) {
+  if (context.__internal.sudo) return;
+  let accepted; // should be boolean, but dont trust, it might accidentally be a filter
+  try {
+    // apply access.item.* controls
+    if (operation === 'create') {
+      const itemAccessControl = list.access.item[operation];
+      accepted = await itemAccessControl({
+        operation,
+        session: context.session,
+        listKey: list.listKey,
+        context,
+        inputData
+      });
+    } else if (operation === 'update' && item !== undefined) {
+      const itemAccessControl = list.access.item[operation];
+      accepted = await itemAccessControl({
+        operation,
+        session: context.session,
+        listKey: list.listKey,
+        context,
+        item,
+        inputData
+      });
+    } else if (operation === 'delete' && item !== undefined) {
+      const itemAccessControl = list.access.item[operation];
+      accepted = await itemAccessControl({
+        operation,
+        session: context.session,
+        listKey: list.listKey,
+        context,
+        item
+      });
+    }
+  } catch (error) {
+    throw extensionError('Access control', [{
+      error,
+      tag: `${list.listKey}.access.item.${operation}`
+    }]);
+  }
+
+  // short circuit the safe path
+  if (accepted === true) return;
+  if (typeof accepted !== 'boolean') {
+    throw accessReturnError([{
+      tag: `${list.listKey}.access.item.${operation}`,
+      returned: typeof accepted
+    }]);
+  }
+  throw accessDeniedError(cannotForItem(operation, list));
+}
+async function enforceFieldLevelAccessControl(context, operation, list, inputData, item) {
+  if (context.__internal.sudo) return;
+  const nonBooleans = [];
+  const fieldsDenied = [];
+  const accessErrors = [];
+  await Promise.allSettled(Object.keys(inputData).map(async fieldKey => {
+    let accepted; // should be boolean, but dont trust
+    try {
+      // apply fields.[fieldKey].access.* controls
+      if (operation === 'create') {
+        const fieldAccessControl = list.fields[fieldKey].access[operation];
+        accepted = await fieldAccessControl({
+          operation,
+          session: context.session,
+          listKey: list.listKey,
+          fieldKey,
+          context,
+          inputData: inputData // FIXME
+        });
+      } else if (operation === 'update' && item !== undefined) {
+        const fieldAccessControl = list.fields[fieldKey].access[operation];
+        accepted = await fieldAccessControl({
+          operation,
+          session: context.session,
+          listKey: list.listKey,
+          fieldKey,
+          context,
+          item,
+          inputData
+        });
+      }
+    } catch (error) {
+      accessErrors.push({
+        error,
+        tag: `${list.listKey}.${fieldKey}.access.${operation}`
+      });
+      return;
+    }
+
+    // short circuit the safe path
+    if (accepted === true) return;
+    fieldsDenied.push(fieldKey);
+
+    // wrong type?
+    if (typeof accepted !== 'boolean') {
+      nonBooleans.push({
+        tag: `${list.listKey}.${fieldKey}.access.${operation}`,
+        returned: typeof accepted
+      });
+    }
+  }));
+  if (nonBooleans.length) {
+    throw accessReturnError(nonBooleans);
+  }
+  if (accessErrors.length) {
+    throw extensionError('Access control', accessErrors);
+  }
+  if (fieldsDenied.length) {
+    throw accessDeniedError(cannotForItemFields(operation, list, fieldsDenied));
+  }
+}
+function parseFieldAccessControl(access) {
+  var _access$read, _access$create, _access$update;
+  if (typeof access === 'function') {
+    return {
+      read: access,
+      create: access,
+      update: access
+    };
+  }
+  return {
+    read: (_access$read = access === null || access === void 0 ? void 0 : access.read) !== null && _access$read !== void 0 ? _access$read : allowAll,
+    create: (_access$create = access === null || access === void 0 ? void 0 : access.create) !== null && _access$create !== void 0 ? _access$create : allowAll,
+    update: (_access$update = access === null || access === void 0 ? void 0 : access.update) !== null && _access$update !== void 0 ? _access$update : allowAll
+  };
+}
+function parseListAccessControl(access) {
+  var _filter$query, _filter$update, _filter$delete, _item$create, _item$update, _item$delete;
+  if (typeof access === 'function') {
+    return {
+      operation: {
+        query: access,
+        create: access,
+        update: access,
+        delete: access
+      },
+      filter: {
+        query: allowAll,
+        update: allowAll,
+        delete: allowAll
+      },
+      item: {
+        create: allowAll,
+        update: allowAll,
+        delete: allowAll
+      }
+    };
+  }
+  let {
+    operation,
+    filter,
+    item
+  } = access;
+  if (typeof operation === 'function') {
+    operation = {
+      query: operation,
+      create: operation,
+      update: operation,
+      delete: operation
+    };
+  }
+  return {
+    operation: {
+      query: operation.query,
+      create: operation.create,
+      update: operation.update,
+      delete: operation.delete
+    },
+    filter: {
+      query: (_filter$query = filter === null || filter === void 0 ? void 0 : filter.query) !== null && _filter$query !== void 0 ? _filter$query : allowAll,
+      // create: not supported
+      update: (_filter$update = filter === null || filter === void 0 ? void 0 : filter.update) !== null && _filter$update !== void 0 ? _filter$update : allowAll,
+      delete: (_filter$delete = filter === null || filter === void 0 ? void 0 : filter.delete) !== null && _filter$delete !== void 0 ? _filter$delete : allowAll
+    },
+    item: {
+      // query: not supported
+      create: (_item$create = item === null || item === void 0 ? void 0 : item.create) !== null && _item$create !== void 0 ? _item$create : allowAll,
+      update: (_item$update = item === null || item === void 0 ? void 0 : item.update) !== null && _item$update !== void 0 ? _item$update : allowAll,
+      delete: (_item$delete = item === null || item === void 0 ? void 0 : item.delete) !== null && _item$delete !== void 0 ? _item$delete : allowAll
+    }
+  };
+}
+async function checkUniqueItemExists(uniqueInput, foreignList, context, operation) {
+  // Validate and resolve the input filter
+  const uniqueWhere = await resolveUniqueWhereInput(uniqueInput, foreignList, context);
+
+  // Check whether the item exists (from this users POV).
+  try {
+    const item = await context.db[foreignList.listKey].findOne({
+      where: uniqueInput
+    });
+    if (item !== null) return uniqueWhere;
+  } catch (err) {}
+  throw accessDeniedError(cannotForItem(operation, foreignList));
+}
+
+function assertFieldsValid(list) {
+  assertNoConflictingExtraOutputFields(list);
+  assertIdFieldGraphQLTypesCorrect(list);
+  assertNoFieldKeysThatConflictWithFilterCombinators(list);
+  assertUniqueWhereInputsValid(list);
+  assertFieldsIsNonNullAllowed(list);
+}
+function assertFieldsIsNonNullAllowed(list) {
+  for (const [fieldKey, field] of Object.entries(list.fields)) {
+    if (field.access.read !== allowAll) {
+      if (field.graphql.isNonNull.read) {
+        throw new Error(`The field at ${list.listKey}.${fieldKey} sets graphql.isNonNull.read: true, and has 'read' field access control, this is not allowed.\n` + `Either disable graphql.read.isNonNull, or disable 'read' field access control.`);
+      }
+    }
+  }
+}
+function assertUniqueWhereInputsValid(list) {
+  for (const [fieldKey, {
+    dbField,
+    input
+  }] of Object.entries(list.fields)) {
+    if (input !== null && input !== void 0 && input.uniqueWhere) {
+      if (dbField.kind !== 'scalar' && dbField.kind !== 'enum' && dbField.kind !== 'relation') {
+        throw new Error(`Only scalar db fields can provide a uniqueWhere input currently but the field at ${list.listKey}.${fieldKey} specifies a uniqueWhere input`);
+      }
+      if (dbField.kind !== 'relation' && dbField.index !== 'unique' && fieldKey !== 'id') {
+        throw new Error(`Fields must have a unique index or be the idField to specify a uniqueWhere input but the field at ${list.listKey}.${fieldKey} specifies a uniqueWhere input without a unique index`);
+      }
+    }
+  }
+}
+function assertNoFieldKeysThatConflictWithFilterCombinators(list) {
+  for (const fieldKey of Object.keys(list.fields)) {
+    if (fieldKey === 'AND' || fieldKey === 'OR' || fieldKey === 'NOT') {
+      throw new Error(`Fields cannot be named ${fieldKey} but there is a field named ${fieldKey} on ${list.listKey}`);
+    }
+  }
+}
+function assertNoConflictingExtraOutputFields(list) {
+  const fieldKeys = new Set(Object.keys(list.fields));
+  const alreadyFoundFields = {};
+  for (const [fieldKey, field] of Object.entries(list.fields)) {
+    if (field.extraOutputFields) {
+      for (const outputTypeFieldName of Object.keys(field.extraOutputFields)) {
+        // note that this and the case handled below are fundamentally the same thing but i want different errors for each of them
+        if (fieldKeys.has(outputTypeFieldName)) {
+          throw new Error(`The field ${fieldKey} on the ${list.listKey} list defines an extra GraphQL output field named ${outputTypeFieldName} which conflicts with the Nixxie field type named ${outputTypeFieldName} on the same list`);
+        }
+        const alreadyFoundField = alreadyFoundFields[outputTypeFieldName];
+        if (alreadyFoundField !== undefined) {
+          throw new Error(`The field ${fieldKey} on the ${list.listKey} list defines an extra GraphQL output field named ${outputTypeFieldName} which conflicts with the Nixxie field type named ${alreadyFoundField} which also defines an extra GraphQL output field named ${outputTypeFieldName}`);
+        }
+        alreadyFoundFields[outputTypeFieldName] = fieldKey;
+      }
+    }
+  }
+}
+function assertIdFieldGraphQLTypesCorrect(list) {
+  var _idField$input;
+  const idField = list.fields.id;
+  if (((_idField$input = idField.input) === null || _idField$input === void 0 ? void 0 : _idField$input.uniqueWhere) === undefined) {
+    throw new Error(`The idField on a list must define a uniqueWhere GraphQL input with the ID GraphQL scalar type but the idField for ${list.listKey} does not define one`);
+  }
+  if (idField.input.uniqueWhere.arg.type !== g.ID) {
+    throw new Error(`The idField on a list must define a uniqueWhere GraphQL input with the ID GraphQL scalar type but the idField for ${list.listKey} defines the type ${idField.input.uniqueWhere.arg.type.toString()}`);
+  }
+  // we may want to loosen these constraints in the future
+  if (idField.input.create !== undefined) {
+    throw new Error(`The idField on a list must not define a create GraphQL input but the idField for ${list.listKey} does define one`);
+  }
+  if (idField.input.update !== undefined) {
+    throw new Error(`The idField on a list must not define an update GraphQL input but the idField for ${list.listKey} does define one`);
+  }
+  if (idField.graphql.isEnabled.read === false) {
+    throw new Error(`The idField on a list must not have graphql.isEnabled.read be set to false but ${list.listKey} does`);
+  }
+  if (!(idField.output.type instanceof GNonNull) || idField.output.type.ofType !== g.ID) {
+    throw new Error(`The idField on a list must define a GraphQL output field with a non-nullable ID GraphQL scalar type but the idField for ${list.listKey} defines the type ${idField.output.type.toString()}`);
+  }
+}
+
+async function checkFilterOrderAccess(things, context, operation) {
+  const func = operation === 'filter' ? 'isFilterable' : 'isOrderable';
+  const failures = [];
+  const returnTypeErrors = [];
+  const accessErrors = [];
+  for (const {
+    fieldKey,
+    list
+  } of things) {
+    const field = list.fields[fieldKey];
+    const rule = field.graphql.isEnabled[operation];
+    if (!rule) throw new Error('Assert failed');
+    if (typeof rule === 'function') {
+      let result;
+      try {
+        result = await rule({
+          context,
+          session: context.session,
+          listKey: list.listKey,
+          fieldKey
+        });
+      } catch (error) {
+        accessErrors.push({
+          error,
+          tag: `${list.listKey}.${fieldKey}.${func}`
+        });
+        continue;
+      }
+      const resultType = typeof result;
+
+      // It's important that we don't cast objects to truthy values, as there's a strong chance that the user
+      // has made a mistake.
+      if (resultType !== 'boolean') {
+        returnTypeErrors.push({
+          tag: `${list.listKey}.${fieldKey}.${func}`,
+          returned: resultType
+        });
+      } else if (!result) {
+        failures.push(`${list.listKey}.${fieldKey}`);
+      }
+    }
+  }
+  if (accessErrors.length) {
+    throw extensionError(func, accessErrors);
+  }
+  if (returnTypeErrors.length) {
+    throw accessReturnError(returnTypeErrors);
+  }
+  if (failures.length) {
+    throw filterAccessError({
+      operation,
+      fieldKeys: failures
+    });
+  }
+}
+
+// we want to put the value we get back from the field's unique where resolver into an equals
+// rather than directly passing the value as the filter (even though Prisma supports that), we use equals
+// because we want to disallow fields from providing an arbitrary filter
+function mapUniqueWhereToWhere(uniqueWhere, list) {
+  const where = {};
+  for (const key in uniqueWhere) {
+    if (list.fields[key].dbField.kind === 'relation') {
+      const foreignList = list.lists[list.fields[key].dbField.list];
+      where[key] = mapUniqueWhereToWhere(uniqueWhere[key], foreignList);
+      continue;
+    }
+    where[key] = {
+      equals: uniqueWhere[key]
+    };
+  }
+  return where;
+}
+function* traverse(list, inputFilter) {
+  for (const fieldKey in inputFilter) {
+    const value = inputFilter[fieldKey];
+    if (fieldKey === 'OR' || fieldKey === 'AND' || fieldKey === 'NOT') {
+      for (const condition of value) {
+        yield* traverse(list, condition);
+      }
+    } else if (fieldKey === 'some' || fieldKey === 'none' || fieldKey === 'every') {
+      yield* traverse(list, value);
+    } else {
+      yield {
+        fieldKey,
+        list
+      };
+
+      // if it's a relationship, check the nested filters.
+      const field = list.fields[fieldKey];
+      if (field.dbField.kind === 'relation' && value !== null) {
+        const foreignList = list.lists[field.dbField.list];
+        yield* traverse(foreignList, value);
+      }
+    }
+  }
+}
+async function accessControlledFilter(list, context, resolvedWhere, accessFilters) {
+  // Merge the filter access control
+  if (typeof accessFilters === 'object') {
+    resolvedWhere = {
+      AND: [resolvedWhere, await resolveWhereInput(accessFilters, list, context)]
+    };
+  }
+  return resolvedWhere;
+}
+async function findOne(args, list, context, info) {
+  // check operation permission to pass into single operation
+  const operationAccess = await getOperationAccess(list, context, 'query');
+  if (!operationAccess) return null;
+  const accessFilters = await getAccessFilters(list, context, 'query');
+  if (accessFilters === false) return null;
+
+  // validate and resolve the input filter
+  const uniqueWhere = await resolveUniqueWhereInput(args.where, list, context);
+  const resolvedWhere = mapUniqueWhereToWhere(uniqueWhere, list);
+
+  // findOne requires at least one filter
+  if (Object.keys(resolvedWhere).length === 0) return null;
+
+  // check filter access
+  await checkFilterOrderAccess([...traverse(list, args.where)], context, 'filter');
+
+  // apply access control
+  const filter = await accessControlledFilter(list, context, resolvedWhere, accessFilters);
+  const result = await context.prisma[list.listKey].findFirst({
+    where: filter
+  });
+  if (list.cacheHint) {
+    var _maybeCacheControlFro, _info$operation$name;
+    (_maybeCacheControlFro = maybeCacheControlFromInfo(info)) === null || _maybeCacheControlFro === void 0 || _maybeCacheControlFro.setCacheHint(list.cacheHint({
+      results: result ? [result] : [],
+      operationName: (_info$operation$name = info.operation.name) === null || _info$operation$name === void 0 ? void 0 : _info$operation$name.value,
+      meta: false
+    }));
+  }
+  return result;
+}
+async function findMany({
+  where,
+  take,
+  skip,
+  orderBy: rawOrderBy,
+  cursor
+}, list, context, info, extraFilter) {
+  var _list$graphql$types$f;
+  const maxTake = (_list$graphql$types$f = list.graphql.types.findManyArgs.take.defaultValue) !== null && _list$graphql$types$f !== void 0 ? _list$graphql$types$f : Infinity;
+  if ((take !== null && take !== void 0 ? take : Infinity) > maxTake) {
+    throw limitsExceededError({
+      list: list.listKey,
+      type: 'maxTake',
+      limit: maxTake
+    });
+  }
+
+  // check operation permission to pass into single operation
+  const operationAccess = await getOperationAccess(list, context, 'query');
+  if (!operationAccess) return [];
+  const accessFilters = await getAccessFilters(list, context, 'query');
+  if (accessFilters === false) return [];
+
+  // validate and resolve the input filter
+  const resolvedWhere = await resolveWhereInput(where, list, context);
+
+  // check filter access (TODO: why isn't this using resolvedWhere)
+  await checkFilterOrderAccess([...traverse(list, where)], context, 'filter');
+
+  // check filter access for cursor
+  if (cursor) {
+    await checkFilterOrderAccess([...traverse(list, cursor)], context, 'filter');
+  }
+
+  // WARNING: this checks .isOrderable
+  const orderBy = await resolveOrderBy(rawOrderBy, list, context);
+
+  // apply access control
+  const filter = await accessControlledFilter(list, context, resolvedWhere, accessFilters);
+  const results = await context.prisma[list.listKey].findMany({
+    where: extraFilter === undefined ? filter : {
+      AND: [filter, extraFilter]
+    },
+    orderBy,
+    take: take !== null && take !== void 0 ? take : undefined,
+    skip,
+    cursor: cursor !== null && cursor !== void 0 ? cursor : undefined
+  });
+  if (list.cacheHint) {
+    var _maybeCacheControlFro2, _info$operation$name2;
+    (_maybeCacheControlFro2 = maybeCacheControlFromInfo(info)) === null || _maybeCacheControlFro2 === void 0 || _maybeCacheControlFro2.setCacheHint(list.cacheHint({
+      results,
+      operationName: (_info$operation$name2 = info.operation.name) === null || _info$operation$name2 === void 0 ? void 0 : _info$operation$name2.value,
+      meta: false
+    }));
+  }
+  return results;
+}
+async function resolveOrderBy(orderBy, list, context) {
+  // Check input format. FIXME: Group all errors
+  orderBy.forEach(orderBySelection => {
+    const keys = Object.keys(orderBySelection);
+    if (keys.length !== 1) {
+      throw userInputError(`Only a single key must be passed to ${list.graphql.types.orderBy.name}`);
+    }
+    const fieldKey = keys[0];
+    const value = orderBySelection[fieldKey];
+    if (value === null) {
+      throw userInputError('null cannot be passed as an order direction');
+    }
+  });
+
+  // Check orderBy access
+  const orderByKeys = orderBy.map(orderBySelection => ({
+    fieldKey: Object.keys(orderBySelection)[0],
+    list
+  }));
+  await checkFilterOrderAccess(orderByKeys, context, 'orderBy');
+  return await Promise.all(orderBy.map(async orderBySelection => {
+    const keys = Object.keys(orderBySelection);
+    const fieldKey = keys[0];
+    const value = orderBySelection[fieldKey];
+    const field = list.fields[fieldKey];
+    const resolve = field.input.orderBy.resolve;
+    const resolvedValue = resolve ? await resolve(value, context) : value;
+    if (field.dbField.kind === 'multi') {
+      // Note: no built-in field types support multi valued database fields *and* orderBy.
+      // This code path is only relevent to custom fields which fit that criteria.
+      const keys = Object.keys(resolvedValue);
+      if (keys.length !== 1) {
+        throw new Error(`Only a single key must be returned from an orderBy input resolver for a multi db field`);
+      }
+      const innerKey = keys[0];
+      return {
+        [getDBFieldKeyForFieldOnMultiField(fieldKey, innerKey)]: resolvedValue[innerKey]
+      };
+    } else {
+      return {
+        [fieldKey]: resolvedValue
+      };
+    }
+  }));
+}
+async function count({
+  where
+}, list, context, info, extraFilter) {
+  const operationAccess = await getOperationAccess(list, context, 'query');
+  if (!operationAccess) return 0;
+  const accessFilters = await getAccessFilters(list, context, 'query');
+  if (accessFilters === false) return 0;
+  const resolvedWhere = await resolveWhereInput(where, list, context);
+
+  // check filter access (TODO: why isn't this using resolvedWhere)
+  await checkFilterOrderAccess([...traverse(list, where)], context, 'filter');
+  const filter = await accessControlledFilter(list, context, resolvedWhere, accessFilters);
+  const count = await context.prisma[list.listKey].count({
+    where: extraFilter === undefined ? filter : {
+      AND: [filter, extraFilter]
+    }
+  });
+  if (list.cacheHint) {
+    var _maybeCacheControlFro3, _info$operation$name3;
+    (_maybeCacheControlFro3 = maybeCacheControlFromInfo(info)) === null || _maybeCacheControlFro3 === void 0 || _maybeCacheControlFro3.setCacheHint(list.cacheHint({
+      results: count,
+      operationName: (_info$operation$name3 = info.operation.name) === null || _info$operation$name3 === void 0 ? void 0 : _info$operation$name3.value,
+      meta: true
+    }));
+  }
+  return count;
+}
+
+function getRelationVal(dbField, id, foreignList, context, info, fk) {
+  const oppositeDbField = foreignList.resolvedDbFields[dbField.field];
+  if (oppositeDbField.kind !== 'relation') throw new Error('failed assert');
+  if (dbField.mode === 'many') {
+    const relationFilter = {
+      [dbField.field]: oppositeDbField.mode === 'many' ? {
+        some: {
+          id
+        }
+      } : {
+        id
+      }
+    };
+    return {
+      findMany: async args => findMany(args, foreignList, context, info, relationFilter),
+      count: async ({
+        where
+      }) => count({
+        where
+      }, foreignList, context, info, relationFilter)
+    };
+  } else {
+    return async () => {
+      if (fk === null) {
+        // If the foreign key is explicitly null, there's no need to anything else,
+        // since we know the related item doesn't exist.
+        return null;
+      }
+      // for one-to-many relationships, the one side always owns the foreign key
+      // so that means we have the id for the related item and we're fetching it by _its_ id.
+      // for the a one-to-one relationship though, the id might be on the related item
+      // so we need to fetch the related item by the id of the current item on the foreign key field
+      const currentItemOwnsForeignKey = fk !== undefined;
+      return fetchRelatedItem(context)(foreignList)(currentItemOwnsForeignKey ? 'id' : `${dbField.field}Id`)(currentItemOwnsForeignKey ? fk : id);
+    };
+  }
+}
+function memoize(cb) {
+  const cache = new Map();
+  return arg => {
+    if (!cache.has(arg)) {
+      const result = cb(arg);
+      cache.set(arg, result);
+    }
+    return cache.get(arg);
+  };
+}
+const fetchRelatedItem = weakMemoize(context => weakMemoize(foreignList => memoize(idFieldKey => {
+  const relatedItemLoader = new DataLoader(keys => fetchRelatedItems(context, foreignList, idFieldKey, keys), {
+    cache: false
+  });
+  return id => relatedItemLoader.load(id);
+})));
+async function fetchRelatedItems(context, foreignList, idFieldKey, toFetch) {
+  const operationAccess = await getOperationAccess(foreignList, context, 'query');
+  if (!operationAccess) {
+    return toFetch.map(() => undefined);
+  }
+  const accessFilters = await getAccessFilters(foreignList, context, 'query');
+  if (accessFilters === false) {
+    return toFetch.map(() => undefined);
+  }
+  const toFetchUnique = Array.from(new Set(toFetch));
+  const resolvedWhere = await accessControlledFilter(foreignList, context, {
+    [idFieldKey]: {
+      in: toFetchUnique
+    }
+  }, accessFilters);
+  const results = await context.prisma[foreignList.listKey].findMany({
+    where: resolvedWhere
+  });
+  const resultsById = new Map(results.map(x => [x[idFieldKey], x]));
+  return toFetch.map(id => resultsById.get(id));
+}
+function getValueForDBField(item, dbField, id, fieldPath, context, lists, info) {
+  if (dbField.kind === 'multi') {
+    return Object.fromEntries(Object.keys(dbField.fields).map(innerDBFieldKey => {
+      const keyOnDbValue = getDBFieldKeyForFieldOnMultiField(fieldPath, innerDBFieldKey);
+      return [innerDBFieldKey, item[keyOnDbValue]];
+    }));
+  }
+  if (dbField.kind === 'relation') {
+    // If we're holding a foreign key value, let's take advantage of that.
+    let fk;
+    if (dbField.mode === 'one' && dbField.foreignIdField.kind !== 'none') {
+      fk = item[`${fieldPath}Id`];
+    }
+    return getRelationVal(dbField, id, lists[dbField.list], context, info, fk);
+  } else {
+    return item[fieldPath];
+  }
+}
+function outputTypeField(output, dbField, cacheHint, access, listKey, fieldKey, lists) {
+  const list = lists[listKey];
+  return g.field({
+    type: output.type,
+    deprecationReason: output.deprecationReason,
+    description: output.description,
+    args: output.args,
+    extensions: output.extensions,
+    async resolve(item, args, context, info) {
+      const id = item.id;
+      const fieldAccess = await getOperationFieldAccess(item, list, fieldKey, context, 'read');
+      if (!fieldAccess) return null;
+
+      // only static cache hints are supported at the field level until a use-case makes it clear what parameters a dynamic hint would take
+      if (cacheHint && info) {
+        var _maybeCacheControlFro;
+        (_maybeCacheControlFro = maybeCacheControlFromInfo(info)) === null || _maybeCacheControlFro === void 0 || _maybeCacheControlFro.setCacheHint(cacheHint);
+      }
+      const value = getValueForDBField(item, dbField, id, fieldKey, context, lists, info);
+      if (output.resolve) {
+        return output.resolve({
+          value,
+          item: item
+        }, args, context, info);
+      } else {
+        return value;
+      }
+    }
+  });
+}
+
+// note: all nixxie fields correspond to a field here
+// not all fields here correspond to nixxie fields(the implicit side of one-sided relation fields)
+
+function sortRelationships(left, right) {
+  if (left.field.mode === 'one' && right.field.mode === 'one') {
+    if (left.field.foreignKey !== undefined && right.field.foreignKey !== undefined) {
+      throw new Error(`You can only set db.foreignKey on one side of a one to one relationship, but foreignKey is set on both ${left.listKey}.${left.fieldPath} and ${right.listKey}.${right.fieldPath}`);
+    }
+
+    // return the field that specifies the foreignKey first
+    if (left.field.foreignKey) return [left, right];
+    if (right.field.foreignKey) return [right, left];
+  } else if (left.field.mode === 'one' || right.field.mode === 'one') {
+    // many relationships will never have a foreign key, so return the one relationship first
+    const rels = left.field.mode === 'one' ? [left, right] : [right, left];
+    // we're only doing this for rels[1] because:
+    // - rels[1] is the many side
+    // - for the one side, TypeScript will already disallow relationName
+    if (rels[1].field.relationName !== undefined) throw new Error(`You can only set db.relationName on one side of a many to many relationship, but db.relationName is set on ${rels[1].listKey}.${rels[1].fieldPath} which is the many side of a many to one relationship with ${rels[0].listKey}.${rels[0].fieldPath}`);
+    return rels;
+  }
+  if (left.field.mode === 'many' && right.field.mode === 'many' && (left.field.relationName !== undefined || right.field.relationName !== undefined)) {
+    if (left.field.relationName !== undefined && right.field.relationName !== undefined) {
+      throw new Error(`You can only set db.relationName on one side of a many to many relationship, but db.relationName is set on both ${left.listKey}.${left.fieldPath} and ${right.listKey}.${right.fieldPath}`);
+    }
+    return left.field.relationName !== undefined ? [left, right] : [right, left];
+  }
+  const order = left.listKey.localeCompare(right.listKey);
+  if (order > 0) return [right, left]; // left comes after right, so swap them
+  if (order === 0) {
+    // self referential list, so check the paths.
+    if (left.fieldPath.localeCompare(right.fieldPath) > 0) {
+      return [right, left];
+    }
+  }
+  return [left, right];
+}
+
+// what's going on here:
+// - validating all the relationships
+// - for relationships involving to-one: deciding which side owns the foreign key
+// - turning one-sided relationships into two-sided relationships so that elsewhere in Nixxie,
+//   you only have to reason about two-sided relationships
+//   (note that this means that there are "fields" in the returned ListsWithResolvedRelations
+//   which are not actually proper Nixxie fields, they are just a db field and nothing else)
+function resolveRelationships(lists) {
+  const alreadyResolvedTwoSidedRelationships = new Set();
+  const resolvedLists = Object.fromEntries(Object.keys(lists).map(listKey => [listKey, {}]));
+  for (const [listKey, fields] of Object.entries(lists)) {
+    const resolvedList = resolvedLists[listKey];
+    for (const [fieldPath, {
+      dbField: field
+    }] of Object.entries(fields.fields)) {
+      if (field.kind !== 'relation') {
+        resolvedList[fieldPath] = field;
+        continue;
+      }
+      const foreignUnresolvedList = lists[field.list];
+      if (!foreignUnresolvedList) {
+        throw new Error(`The relationship field at ${listKey}.${fieldPath} points to the list ${listKey} which does not exist`);
+      }
+      if (foreignUnresolvedList.isSingleton) {
+        throw new Error(`The relationship field at ${listKey}.${fieldPath} points to a singleton list, ${listKey}, which is not allowed`);
+      }
+      if (field.field) {
+        var _foreignUnresolvedLis, _leftRel$field$foreig2;
+        const localRef = `${listKey}.${fieldPath}`;
+        const foreignRef = `${field.list}.${field.field}`;
+        if (alreadyResolvedTwoSidedRelationships.has(localRef)) continue;
+        alreadyResolvedTwoSidedRelationships.add(foreignRef);
+        const foreignField = (_foreignUnresolvedLis = foreignUnresolvedList.fields[field.field]) === null || _foreignUnresolvedLis === void 0 ? void 0 : _foreignUnresolvedLis.dbField;
+        if (!foreignField) throw new Error(`${localRef} points to ${foreignRef}, but ${foreignRef} doesn't exist`);
+        if (foreignField.kind !== 'relation') {
+          throw new Error(`${localRef} points to ${foreignRef}, but ${foreignRef} is not a relationship field`);
+        }
+        const actualRef = foreignField.field ? `${foreignField.list}.${foreignField.field}` : foreignField.list;
+        if (actualRef !== localRef) {
+          throw new Error(`${localRef} expects ${foreignRef} to be a two way relationship, but ${foreignRef} points to ${actualRef}`);
+        }
+        const [leftRel, rightRel] = sortRelationships({
+          listKey,
+          fieldPath,
+          field
+        }, {
+          listKey: field.list,
+          fieldPath: field.field,
+          field: foreignField
+        });
+        if (leftRel.field.mode === 'one' && rightRel.field.mode === 'one') {
+          var _leftRel$field$foreig;
+          const relationName = `${leftRel.listKey}_${leftRel.fieldPath}`;
+          resolvedLists[leftRel.listKey][leftRel.fieldPath] = {
+            kind: 'relation',
+            mode: 'one',
+            field: rightRel.fieldPath,
+            list: rightRel.listKey,
+            extendPrismaSchema: leftRel.field.extendPrismaSchema,
+            foreignIdField: {
+              kind: 'owned-unique',
+              map: typeof leftRel.field.foreignKey === 'object' ? (_leftRel$field$foreig = leftRel.field.foreignKey) === null || _leftRel$field$foreig === void 0 ? void 0 : _leftRel$field$foreig.map : leftRel.fieldPath
+            },
+            relationName
+          };
+          resolvedLists[rightRel.listKey][rightRel.fieldPath] = {
+            kind: 'relation',
+            mode: 'one',
+            field: leftRel.fieldPath,
+            list: leftRel.listKey,
+            extendPrismaSchema: rightRel.field.extendPrismaSchema,
+            foreignIdField: {
+              kind: 'none'
+            },
+            relationName
+          };
+          continue;
+        }
+        if (leftRel.field.mode === 'many' && rightRel.field.mode === 'many') {
+          var _leftRel$field$relati;
+          const relationName = (_leftRel$field$relati = leftRel.field.relationName) !== null && _leftRel$field$relati !== void 0 ? _leftRel$field$relati : `${leftRel.listKey}_${leftRel.fieldPath}`;
+          resolvedLists[leftRel.listKey][leftRel.fieldPath] = {
+            kind: 'relation',
+            mode: 'many',
+            extendPrismaSchema: leftRel.field.extendPrismaSchema,
+            field: rightRel.fieldPath,
+            list: rightRel.listKey,
+            relationName
+          };
+          resolvedLists[rightRel.listKey][rightRel.fieldPath] = {
+            kind: 'relation',
+            mode: 'many',
+            extendPrismaSchema: rightRel.field.extendPrismaSchema,
+            field: leftRel.fieldPath,
+            list: leftRel.listKey,
+            relationName
+          };
+          continue;
+        }
+        const relationName = `${leftRel.listKey}_${leftRel.fieldPath}`;
+        resolvedLists[leftRel.listKey][leftRel.fieldPath] = {
+          kind: 'relation',
+          mode: 'one',
+          field: rightRel.fieldPath,
+          extendPrismaSchema: leftRel.field.extendPrismaSchema,
+          list: rightRel.listKey,
+          foreignIdField: {
+            kind: 'owned',
+            map: typeof leftRel.field.foreignKey === 'object' ? (_leftRel$field$foreig2 = leftRel.field.foreignKey) === null || _leftRel$field$foreig2 === void 0 ? void 0 : _leftRel$field$foreig2.map : leftRel.fieldPath
+          },
+          relationName
+        };
+        resolvedLists[rightRel.listKey][rightRel.fieldPath] = {
+          kind: 'relation',
+          mode: 'many',
+          extendPrismaSchema: rightRel.field.extendPrismaSchema,
+          field: leftRel.fieldPath,
+          list: leftRel.listKey,
+          relationName
+        };
+        continue;
+      }
+      const foreignFieldPath = `from_${listKey}_${fieldPath}`;
+      if (foreignUnresolvedList.fields[foreignFieldPath]) {
+        throw new Error(`The relationship field at ${listKey}.${fieldPath} points to the list ${field.list}, Nixxie needs to a create a relationship field at ${field.list}.${foreignFieldPath} to support the relationship at ${listKey}.${fieldPath} but ${field.list} already has a field named ${foreignFieldPath}`);
+      }
+      if (field.mode === 'many') {
+        var _field$relationName;
+        const relationName = (_field$relationName = field.relationName) !== null && _field$relationName !== void 0 ? _field$relationName : `${listKey}_${fieldPath}`;
+        resolvedLists[field.list][foreignFieldPath] = {
+          kind: 'relation',
+          mode: 'many',
+          extendPrismaSchema: field.extendPrismaSchema,
+          list: listKey,
+          field: fieldPath,
+          relationName
+        };
+        resolvedList[fieldPath] = {
+          kind: 'relation',
+          mode: 'many',
+          extendPrismaSchema: field.extendPrismaSchema,
+          list: field.list,
+          field: foreignFieldPath,
+          relationName
+        };
+      } else {
+        var _field$foreignKey;
+        const relationName = `${listKey}_${fieldPath}`;
+        resolvedLists[field.list][foreignFieldPath] = {
+          kind: 'relation',
+          mode: 'many',
+          extendPrismaSchema: field.extendPrismaSchema,
+          list: listKey,
+          field: fieldPath,
+          relationName
+        };
+        resolvedList[fieldPath] = {
+          kind: 'relation',
+          list: field.list,
+          extendPrismaSchema: field.extendPrismaSchema,
+          field: foreignFieldPath,
+          foreignIdField: {
+            kind: 'owned',
+            map: typeof field.foreignKey === 'object' ? (_field$foreignKey = field.foreignKey) === null || _field$foreignKey === void 0 ? void 0 : _field$foreignKey.map : fieldPath
+          },
+          relationName,
+          mode: 'one'
+        };
+      }
+    }
+  }
+
+  // the way we resolve the relationships means that the relationships will be in a
+  // different order than the order the user specified in their config
+  // doesn't really change the behaviour of anything but it means that the order of the fields in the prisma schema will be
+  // the same as the user provided
+  return Object.fromEntries(Object.entries(resolvedLists).map(([listKey, outOfOrderDbFields]) => {
+    // this adds the fields based on the order that the user passed in
+    // (except it will not add the opposites to one-sided relations)
+    const resolvedDbFields = Object.fromEntries(Object.keys(lists[listKey].fields).map(fieldKey => [fieldKey, outOfOrderDbFields[fieldKey]]));
+    // then we add the opposites to one-sided relations
+    Object.assign(resolvedDbFields, outOfOrderDbFields);
+    return [listKey, resolvedDbFields];
+  }));
+}
+
+function printGraphQLType(type) {
+  if (type instanceof GraphQLNonNull) return `${printGraphQLType(type.ofType)}!`;
+  if (type instanceof GraphQLList) return `[${printGraphQLType(type.ofType)}]`;
+  return type.name;
+}
+function getArgSources(action) {
+  var _action$args;
+  return Object.fromEntries(Object.entries((_action$args = action.args) !== null && _action$args !== void 0 ? _action$args : {}).flatMap(([arg, value]) => {
+    var _value$ui;
+    const field = (_value$ui = value.ui) === null || _value$ui === void 0 || (_value$ui = _value$ui.source) === null || _value$ui === void 0 ? void 0 : _value$ui.itemField;
+    if (!field) return [];
+    return [[arg, {
+      itemField: field
+    }]];
+  }));
+}
+function throwIfNotAFilter(x, listKey, fieldKey) {
+  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}'.`);
+}
+// TODO: move to defaultLists?
+function getIsEnabled(listKey, listConfig) {
+  var _listConfig$graphql$o;
+  const omit = (_listConfig$graphql$o = listConfig.graphql.omit) !== null && _listConfig$graphql$o !== void 0 ? _listConfig$graphql$o : 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, listKey, list, lists) {
+  var _f$graphql$omit, _f$graphql;
+  const omit = (_f$graphql$omit = (_f$graphql = f.graphql) === null || _f$graphql === void 0 ? void 0 : _f$graphql.omit) !== null && _f$graphql$omit !== void 0 ? _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
+}) {
+  return resolvedData;
+}
+function parseListHooks(hooks) {
+  var _hooks$resolveInput$c, _hooks$resolveInput, _hooks$resolveInput$u, _hooks$resolveInput2;
+  return {
+    resolveInput: {
+      create: typeof hooks.resolveInput === 'function' ? hooks.resolveInput : (_hooks$resolveInput$c = (_hooks$resolveInput = hooks.resolveInput) === null || _hooks$resolveInput === void 0 ? void 0 : _hooks$resolveInput.create) !== null && _hooks$resolveInput$c !== void 0 ? _hooks$resolveInput$c : defaultListHooksResolveInput,
+      update: typeof hooks.resolveInput === 'function' ? hooks.resolveInput : (_hooks$resolveInput$u = (_hooks$resolveInput2 = hooks.resolveInput) === null || _hooks$resolveInput2 === void 0 ? void 0 : _hooks$resolveInput2.update) !== null && _hooks$resolveInput$u !== void 0 ? _hooks$resolveInput$u : defaultListHooksResolveInput
+    },
+    validate: expandVoidHooks(hooks.validate),
+    beforeOperation: expandVoidHooks(hooks.beforeOperation),
+    afterOperation: expandVoidHooks(hooks.afterOperation)
+  };
+}
+function defaultFieldHooksResolveInput({
+  resolvedData,
+  fieldKey
+}) {
+  return resolvedData[fieldKey];
+}
+function parseFieldHooks(hooks) {
+  var _hooks$resolveInput$c2, _hooks$resolveInput3, _hooks$resolveInput$u2, _hooks$resolveInput4;
+  return {
+    resolveInput: {
+      create: typeof hooks.resolveInput === 'function' ? hooks.resolveInput : (_hooks$resolveInput$c2 = (_hooks$resolveInput3 = hooks.resolveInput) === null || _hooks$resolveInput3 === void 0 ? void 0 : _hooks$resolveInput3.create) !== null && _hooks$resolveInput$c2 !== void 0 ? _hooks$resolveInput$c2 : defaultFieldHooksResolveInput,
+      update: typeof hooks.resolveInput === 'function' ? hooks.resolveInput : (_hooks$resolveInput$u2 = (_hooks$resolveInput4 = hooks.resolveInput) === null || _hooks$resolveInput4 === void 0 ? void 0 : _hooks$resolveInput4.update) !== null && _hooks$resolveInput$u2 !== void 0 ? _hooks$resolveInput$u2 : defaultFieldHooksResolveInput
+    },
+    validate: expandVoidHooks(hooks.validate),
+    beforeOperation: expandVoidHooks(hooks.beforeOperation),
+    afterOperation: expandVoidHooks(hooks.afterOperation)
+  };
+}
+function getListsWithInitialisedFields(config, listsRef) {
+  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 = {};
+  for (const listConfig of Object.values(listsConfig)) {
+    var _listConfig$graphql;
+    const {
+      listKey
+    } = listConfig;
+    const {
+      graphql: {
+        names
+      }
+    } = __getNames(listKey, listConfig);
+    const output = g.object()({
+      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], ...Object.entries(field.extraOutputFields || {})].map(([outputTypeFieldName, outputField]) => {
+              var _field$graphql;
+              return [outputTypeFieldName, outputTypeField(outputField, field.dbField, (_field$graphql = field.graphql) === null || _field$graphql === void 0 ? void 0 : _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]) => {
+            var _field$input;
+            if (!((_field$input = field.input) !== null && _field$input !== void 0 && (_field$input = _field$input.uniqueWhere) !== null && _field$input !== void 0 && _field$input.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]];
+              }
+              return [];
+            }
+            return [[key, field.input.uniqueWhere.arg]];
+          })),
+          // 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 = 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]) => {
+          var _field$input2, _field$input3;
+          return ((_field$input2 = field.input) === null || _field$input2 === void 0 || (_field$input2 = _field$input2.where) === null || _field$input2 === void 0 ? void 0 : _field$input2.arg) && field.graphql.isEnabled.read && field.graphql.isEnabled.filter && {
+            [fieldKey]: (_field$input3 = field.input) === null || _field$input3 === void 0 || (_field$input3 = _field$input3.where) === null || _field$input3 === void 0 ? void 0 : _field$input3.arg
+          };
+        }));
+      }
+    });
+    const create = g.inputObject({
+      name: names.createInputName,
+      fields: () => {
+        const {
+          fields
+        } = listsRef[listKey];
+        const ret = {};
+        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 = {};
+        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]) => {
+          var _field$input4;
+          if (!((_field$input4 = field.input) !== null && _field$input4 !== void 0 && (_field$input4 = _field$input4.orderBy) !== null && _field$input4 !== void 0 && _field$input4.arg) || !field.graphql.isEnabled.read || !field.graphql.isEnabled.orderBy) {
+            return [];
+          }
+          return [[key, field.input.orderBy.arg]];
+        }));
+      }
+    });
+    let take = g.arg({
+      type: g.Int
+    });
+    if (((_listConfig$graphql = listConfig.graphql) === null || _listConfig$graphql === void 0 ? void 0 : _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 = {
+      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 = {};
+  for (const listConfig of Object.values(listsConfig)) {
+    var _listConfig$ui$labelF, _listConfig$ui$search, _listConfig$hooks, _listConfig$isSinglet;
+    const {
+      listKey
+    } = listConfig;
+    const intermediateList = intermediateLists[listKey];
+    const resultFields = {};
+    const groups = [];
+    const fieldKeys = Object.keys(listConfig.fields);
+    const fieldKeysToGroup = {};
+    for (const [idx, [fieldKey, fieldFunc]] of Object.entries(listConfig.fields).entries()) {
+      var _f$hooks, _f$graphql2, _f$graphql3, _f$graphql$isNonNull$, _f$graphql4, _f$graphql5, _f$graphql$isNonNull$2, _f$graphql6, _f$graphql7, _f$graphql$isNonNull$3, _f$graphql8, _f$ui, _f$ui$description, _f$ui2, _f$ui$views, _f$ui3, _f$ui$createView$isRe, _f$ui4, _ref, _ref2, _f$ui$createView$fiel, _f$ui5, _group$ui, _listConfig$ui$create, _f$ui$itemView$isRequ, _f$ui6, _f$ui$itemView$fieldP, _f$ui7, _ref3, _ref4, _f$ui$itemView$fieldM, _f$ui8, _group$ui2, _listConfig$ui$itemVi, _ref5, _ref6, _f$ui$itemView$fieldM2, _f$ui9, _group$ui3, _listConfig$ui$itemVi2, _ref7, _ref8, _f$ui$listView$fieldM, _f$ui0, _group$ui4, _listConfig$ui$listVi;
+      if (fieldKey.startsWith('__group')) {
+        const group__ = fieldFunc;
+        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,
+        access: parseFieldAccessControl(f.access),
+        hooks: parseFieldHooks((_f$hooks = f.hooks) !== null && _f$hooks !== void 0 ? _f$hooks : {}),
+        graphql: {
+          cacheHint: (_f$graphql2 = f.graphql) === null || _f$graphql2 === void 0 ? void 0 : _f$graphql2.cacheHint,
+          isEnabled: isEnabledField,
+          isNonNull: {
+            read: typeof ((_f$graphql3 = f.graphql) === null || _f$graphql3 === void 0 ? void 0 : _f$graphql3.isNonNull) === 'boolean' ? f.graphql.isNonNull : (_f$graphql$isNonNull$ = (_f$graphql4 = f.graphql) === null || _f$graphql4 === void 0 || (_f$graphql4 = _f$graphql4.isNonNull) === null || _f$graphql4 === void 0 ? void 0 : _f$graphql4.read) !== null && _f$graphql$isNonNull$ !== void 0 ? _f$graphql$isNonNull$ : false,
+            create: typeof ((_f$graphql5 = f.graphql) === null || _f$graphql5 === void 0 ? void 0 : _f$graphql5.isNonNull) === 'boolean' ? f.graphql.isNonNull : (_f$graphql$isNonNull$2 = (_f$graphql6 = f.graphql) === null || _f$graphql6 === void 0 || (_f$graphql6 = _f$graphql6.isNonNull) === null || _f$graphql6 === void 0 ? void 0 : _f$graphql6.create) !== null && _f$graphql$isNonNull$2 !== void 0 ? _f$graphql$isNonNull$2 : false,
+            update: typeof ((_f$graphql7 = f.graphql) === null || _f$graphql7 === void 0 ? void 0 : _f$graphql7.isNonNull) === 'boolean' ? f.graphql.isNonNull : (_f$graphql$isNonNull$3 = (_f$graphql8 = f.graphql) === null || _f$graphql8 === void 0 || (_f$graphql8 = _f$graphql8.isNonNull) === null || _f$graphql8 === void 0 ? void 0 : _f$graphql8.update) !== null && _f$graphql$isNonNull$3 !== void 0 ? _f$graphql$isNonNull$3 : false
+          }
+        },
+        ui: {
+          label: ((_f$ui = f.ui) === null || _f$ui === void 0 ? void 0 : _f$ui.label) || humanize(fieldKey),
+          description: (_f$ui$description = (_f$ui2 = f.ui) === null || _f$ui2 === void 0 ? void 0 : _f$ui2.description) !== null && _f$ui$description !== void 0 ? _f$ui$description : '',
+          views: (_f$ui$views = (_f$ui3 = f.ui) === null || _f$ui3 === void 0 ? void 0 : _f$ui3.views) !== null && _f$ui$views !== void 0 ? _f$ui$views : null,
+          createView: {
+            isRequired: (_f$ui$createView$isRe = (_f$ui4 = f.ui) === null || _f$ui4 === void 0 || (_f$ui4 = _f$ui4.createView) === null || _f$ui4 === void 0 ? void 0 : _f$ui4.isRequired) !== null && _f$ui$createView$isRe !== void 0 ? _f$ui$createView$isRe : false,
+            fieldMode: isEnabledField.create ? (_ref = (_ref2 = (_f$ui$createView$fiel = (_f$ui5 = f.ui) === null || _f$ui5 === void 0 || (_f$ui5 = _f$ui5.createView) === null || _f$ui5 === void 0 ? void 0 : _f$ui5.fieldMode) !== null && _f$ui$createView$fiel !== void 0 ? _f$ui$createView$fiel : group === null || group === void 0 || (_group$ui = group.ui) === null || _group$ui === void 0 || (_group$ui = _group$ui.createView) === null || _group$ui === void 0 ? void 0 : _group$ui.defaultFieldMode) !== null && _ref2 !== void 0 ? _ref2 : (_listConfig$ui$create = listConfig.ui.createView) === null || _listConfig$ui$create === void 0 ? void 0 : _listConfig$ui$create.defaultFieldMode) !== null && _ref !== void 0 ? _ref : 'edit' : 'hidden'
+          },
+          itemView: {
+            isRequired: (_f$ui$itemView$isRequ = (_f$ui6 = f.ui) === null || _f$ui6 === void 0 || (_f$ui6 = _f$ui6.itemView) === null || _f$ui6 === void 0 ? void 0 : _f$ui6.isRequired) !== null && _f$ui$itemView$isRequ !== void 0 ? _f$ui$itemView$isRequ : false,
+            fieldPosition: (_f$ui$itemView$fieldP = (_f$ui7 = f.ui) === null || _f$ui7 === void 0 || (_f$ui7 = _f$ui7.itemView) === null || _f$ui7 === void 0 ? void 0 : _f$ui7.fieldPosition) !== null && _f$ui$itemView$fieldP !== void 0 ? _f$ui$itemView$fieldP : 'form',
+            fieldMode: isEnabledField.update ? (_ref3 = (_ref4 = (_f$ui$itemView$fieldM = (_f$ui8 = f.ui) === null || _f$ui8 === void 0 || (_f$ui8 = _f$ui8.itemView) === null || _f$ui8 === void 0 ? void 0 : _f$ui8.fieldMode) !== null && _f$ui$itemView$fieldM !== void 0 ? _f$ui$itemView$fieldM : group === null || group === void 0 || (_group$ui2 = group.ui) === null || _group$ui2 === void 0 || (_group$ui2 = _group$ui2.itemView) === null || _group$ui2 === void 0 ? void 0 : _group$ui2.defaultFieldMode) !== null && _ref4 !== void 0 ? _ref4 : (_listConfig$ui$itemVi = listConfig.ui.itemView) === null || _listConfig$ui$itemVi === void 0 ? void 0 : _listConfig$ui$itemVi.defaultFieldMode) !== null && _ref3 !== void 0 ? _ref3 : 'edit' : isEnabledField.read ? (_ref5 = (_ref6 = (_f$ui$itemView$fieldM2 = (_f$ui9 = f.ui) === null || _f$ui9 === void 0 || (_f$ui9 = _f$ui9.itemView) === null || _f$ui9 === void 0 ? void 0 : _f$ui9.fieldMode) !== null && _f$ui$itemView$fieldM2 !== void 0 ? _f$ui$itemView$fieldM2 : group === null || group === void 0 || (_group$ui3 = group.ui) === null || _group$ui3 === void 0 || (_group$ui3 = _group$ui3.itemView) === null || _group$ui3 === void 0 ? void 0 : _group$ui3.defaultFieldMode) !== null && _ref6 !== void 0 ? _ref6 : (_listConfig$ui$itemVi2 = listConfig.ui.itemView) === null || _listConfig$ui$itemVi2 === void 0 ? void 0 : _listConfig$ui$itemVi2.defaultFieldMode) !== null && _ref5 !== void 0 ? _ref5 : 'read' : 'hidden'
+          },
+          listView: {
+            fieldMode: isEnabledField.read ? (_ref7 = (_ref8 = (_f$ui$listView$fieldM = (_f$ui0 = f.ui) === null || _f$ui0 === void 0 || (_f$ui0 = _f$ui0.listView) === null || _f$ui0 === void 0 ? void 0 : _f$ui0.fieldMode) !== null && _f$ui$listView$fieldM !== void 0 ? _f$ui$listView$fieldM : group === null || group === void 0 || (_group$ui4 = group.ui) === null || _group$ui4 === void 0 || (_group$ui4 = _group$ui4.listView) === null || _group$ui4 === void 0 ? void 0 : _group$ui4.defaultFieldMode) !== null && _ref8 !== void 0 ? _ref8 : (_listConfig$ui$listVi = listConfig.ui.listView) === null || _listConfig$ui$listVi === void 0 ? void 0 : _listConfig$ui$listVi.defaultFieldMode) !== null && _ref7 !== void 0 ? _ref7 : '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$labelF = listConfig.ui.labelField) !== null && _listConfig$ui$labelF !== void 0 ? _listConfig$ui$labelF : listConfig.fields.label ? 'label' : listConfig.fields.name ? 'name' : listConfig.fields.title ? 'title' : 'id';
+    const searchFields = new Set((_listConfig$ui$search = listConfig.ui.searchFields) !== null && _listConfig$ui$search !== void 0 ? _listConfig$ui$search : []);
+    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(),
+        triviallySearchableFields: new Set()
+      },
+      hooks: parseListHooks((_listConfig$hooks = listConfig.hooks) !== null && _listConfig$hooks !== void 0 ? _listConfig$hooks : {}),
+      listKey,
+      cacheHint: (() => {
+        const cacheHint = listConfig.graphql.cacheHint;
+        if (typeof cacheHint === 'function') return cacheHint;
+        if (cacheHint !== undefined) return () => cacheHint;
+        return undefined;
+      })(),
+      isSingleton: (_listConfig$isSinglet = listConfig.isSingleton) !== null && _listConfig$isSinglet !== void 0 ? _listConfig$isSinglet : false
+    };
+  }
+  return result;
+}
+function introspectGraphQLTypes(lists) {
+  const namesOfRelationInputs = new Set();
+  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)) {
+      var _whereInputFields$fie, _fieldFilterFields$co;
+      const filterType = (_whereInputFields$fie = whereInputFields[fieldKey]) === null || _whereInputFields$fie === void 0 ? void 0 : _whereInputFields$fie.type;
+      const fieldFilterFields = isInputObjectType(filterType) ? filterType.getFields() : undefined;
+      const filterTypeName = isInputObjectType(filterType) ? filterType.name : undefined;
+      if ((fieldFilterFields === null || fieldFilterFields === void 0 || (_fieldFilterFields$co = fieldFilterFields.contains) === null || _fieldFilterFields$co === void 0 ? void 0 : _fieldFilterFields$co.type) === GraphQLString) {
+        var _fieldFilterFields$mo;
+        searchableFields.set(fieldKey, (fieldFilterFields === null || fieldFilterFields === void 0 || (_fieldFilterFields$mo = fieldFilterFields.mode) === null || _fieldFilterFields$mo === void 0 ? void 0 : _fieldFilterFields$mo.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) {
+  return g.arg({
+    ...thing,
+    defaultValue: undefined
+  });
+}
+function graphqlArgForInputField(field, operation, listsRef) {
+  var _field$input5;
+  const input = (_field$input5 = field.input) === null || _field$input5 === void 0 ? void 0 : _field$input5[operation];
+  if (!(input !== null && input !== void 0 && 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) {
+  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,
+    type: g.nonNull(output.type)
+  });
+}
+function getInitialisedActionGraphql(list, listGraphqlNames, actionKey, action) {
+  var _action$graphql$singu, _action$graphql, _action$graphql$plura, _action$graphql2, _action$args2;
+  const graphqlNames = {
+    one: (_action$graphql$singu = (_action$graphql = action.graphql) === null || _action$graphql === void 0 ? void 0 : _action$graphql.singular) !== null && _action$graphql$singu !== void 0 ? _action$graphql$singu : `${actionKey}${listGraphqlNames.singular}`,
+    many: (_action$graphql$plura = (_action$graphql2 = action.graphql) === null || _action$graphql2 === void 0 ? void 0 : _action$graphql2.plural) !== null && _action$graphql$plura !== void 0 ? _action$graphql$plura : `${actionKey}${listGraphqlNames.plural}`
+  };
+  const argsName = `${graphqlNames.one[0].toUpperCase()}${graphqlNames.one.slice(1)}Args`;
+  const argumentFields = Object.fromEntries(Object.entries((_action$args2 = action.args) !== null && _action$args2 !== void 0 ? _action$args2 : {}).map(([arg, value]) => [arg, value.graphql]));
+  return {
+    arguments: Object.entries(argumentFields).map(([name, arg]) => {
+      var _getArgSources$name;
+      return {
+        name,
+        type: printGraphQLType(arg.type),
+        source: (_getArgSources$name = getArgSources(action)[name]) !== null && _getArgSources$name !== void 0 ? _getArgSources$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
+        }
+      })
+    }
+  };
+}
+function initialiseLists(config) {
+  const listsRef = {};
+  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 = {};
+    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)) {
+    var _listConfig$actions;
+    const listConfig = config.lists[list.listKey];
+    let hasAnEnabledCreateField = false;
+    let hasAnEnabledUpdateField = false;
+    for (const field of Object.values(list.fields)) {
+      var _field$input6, _field$input7;
+      if ((_field$input6 = field.input) !== null && _field$input6 !== void 0 && (_field$input6 = _field$input6.create) !== null && _field$input6 !== void 0 && _field$input6.arg && field.graphql.isEnabled.create) {
+        hasAnEnabledCreateField = true;
+      }
+      if ((_field$input7 = field.input) !== null && _field$input7 !== void 0 && _field$input7.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 = listConfig.actions) !== null && _listConfig$actions !== void 0 ? _listConfig$actions : {}).map(([actionKey, action]) => {
+      var _action$ui$icon, _action$ui$itemView$a, _action$ui$itemView, _action$ui$itemView$n, _action$ui$itemView2, _action$ui$itemView$h, _action$ui$itemView3, _action$ui$itemView$h2, _action$ui$itemView4, _action$ui$listView$a, _action$ui$listView;
+      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 = action.ui.icon) !== null && _action$ui$icon !== void 0 ? _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$a = (_action$ui$itemView = action.ui.itemView) === null || _action$ui$itemView === void 0 ? void 0 : _action$ui$itemView.actionMode) !== null && _action$ui$itemView$a !== void 0 ? _action$ui$itemView$a : 'enabled',
+            navigation: (_action$ui$itemView$n = (_action$ui$itemView2 = action.ui.itemView) === null || _action$ui$itemView2 === void 0 ? void 0 : _action$ui$itemView2.navigation) !== null && _action$ui$itemView$n !== void 0 ? _action$ui$itemView$n : 'follow',
+            hidePrompt: (_action$ui$itemView$h = (_action$ui$itemView3 = action.ui.itemView) === null || _action$ui$itemView3 === void 0 ? void 0 : _action$ui$itemView3.hidePrompt) !== null && _action$ui$itemView$h !== void 0 ? _action$ui$itemView$h : false,
+            hideToast: (_action$ui$itemView$h2 = (_action$ui$itemView4 = action.ui.itemView) === null || _action$ui$itemView4 === void 0 ? void 0 : _action$ui$itemView4.hideToast) !== null && _action$ui$itemView$h2 !== void 0 ? _action$ui$itemView$h2 : false
+          },
+          listView: {
+            actionMode: (_action$ui$listView$a = (_action$ui$listView = action.ui.listView) === null || _action$ui$listView === void 0 ? void 0 : _action$ui$listView.actionMode) !== null && _action$ui$listView$a !== void 0 ? _action$ui$listView$a : 'enabled'
+          },
+          argSources: getArgSources(action)
+        }
+      };
+    });
+  }
+
+  // error checking
+  for (const list of Object.values(listsRef)) {
+    assertFieldsValid(list);
+  }
+
+  // do some introspection
+  introspectGraphQLTypes(listsRef);
+  return listsRef;
+}
+
+const NixxieAdminUIFieldMeta = g.object()({
+  name: 'NixxieAdminUIFieldMeta',
+  fields: {
+    key: g.field({
+      type: g.nonNull(g.String)
+    }),
+    label: g.field({
+      type: g.nonNull(g.String)
+    }),
+    description: g.field({
+      type: g.String
+    }),
+    isOrderable: g.field({
+      type: g.nonNull(g.Boolean)
+    }),
+    isFilterable: g.field({
+      type: g.nonNull(g.Boolean)
+    }),
+    isNonNull: g.field({
+      type: g.list(g.nonNull(g.enum({
+        name: 'NixxieAdminUIFieldMetaIsNonNull',
+        values: g.enumValues(['read', 'create', 'update'])
+      })))
+    }),
+    fieldMeta: g.field({
+      type: g.JSON
+    }),
+    viewsIndex: g.field({
+      type: g.nonNull(g.Int)
+    }),
+    customViewsIndex: g.field({
+      type: g.Int
+    }),
+    createView: g.field({
+      type: g.nonNull(g.object()({
+        name: 'NixxieAdminUIFieldMetaCreateView',
+        fields: {
+          fieldMode: g.field({
+            type: g.nonNull(g.JSON)
+          }),
+          isRequired: g.field({
+            type: g.nonNull(g.JSON)
+          })
+        }
+      }))
+    }),
+    itemView: g.field({
+      resolve: args => args,
+      type: g.object()({
+        name: 'NixxieAdminUIFieldMetaItemView',
+        fields: {
+          fieldMode: g.field({
+            type: g.nonNull(g.JSON),
+            async resolve({
+              listKey,
+              fieldKey,
+              itemView,
+              item,
+              itemField
+            }, _, context) {
+              const {
+                fieldMode
+              } = itemView;
+              if (typeof fieldMode !== 'function') return fieldMode;
+              return fieldMode({
+                session: context.session,
+                context,
+                listKey,
+                fieldKey,
+                item,
+                itemField
+              });
+            }
+          }),
+          fieldPosition: g.field({
+            type: g.nonNull(g.enum({
+              name: 'NixxieAdminUIFieldMetaItemViewFieldPosition',
+              values: g.enumValues(['form', 'sidebar'])
+            })),
+            async resolve({
+              listKey,
+              fieldKey,
+              itemView,
+              item,
+              itemField
+            }, _, context) {
+              const {
+                fieldPosition
+              } = itemView;
+              if (typeof fieldPosition !== 'function') return fieldPosition;
+              return fieldPosition({
+                session: context.session,
+                context,
+                listKey,
+                fieldKey,
+                item,
+                itemField
+              });
+            }
+          }),
+          isRequired: g.field({
+            type: g.nonNull(g.JSON),
+            resolve({
+              listKey,
+              fieldKey,
+              itemView,
+              item,
+              itemField
+            }, _, context) {
+              const {
+                isRequired
+              } = itemView;
+              if (typeof isRequired !== 'function') return isRequired;
+              return isRequired({
+                session: context.session,
+                context,
+                listKey,
+                fieldKey,
+                item,
+                itemField
+              });
+            }
+          })
+        }
+      })
+    }),
+    listView: g.field({
+      type: g.nonNull(g.object()({
+        name: 'NixxieAdminUIFieldMetaListView',
+        fields: {
+          fieldMode: g.field({
+            type: g.nonNull(g.enum({
+              name: 'NixxieAdminUIFieldMetaListViewFieldMode',
+              values: g.enumValues(['read', 'hidden'])
+            }))
+          })
+        }
+      }))
+    }),
+    search: g.field({
+      type: QueryMode
+    })
+  }
+});
+const NixxieAdminUIActionMeta = g.object()({
+  name: 'NixxieAdminUIActionMeta',
+  fields: {
+    key: g.field({
+      type: g.nonNull(g.String)
+    }),
+    label: g.field({
+      type: g.nonNull(g.String)
+    }),
+    icon: g.field({
+      type: g.String
+    }),
+    messages: g.field({
+      type: g.nonNull(g.object()({
+        name: 'NixxieAdminUIActionMetaMessages',
+        fields: {
+          promptTitle: g.field({
+            type: g.nonNull(g.String)
+          }),
+          promptTitleMany: g.field({
+            type: g.String
+          }),
+          prompt: g.field({
+            type: g.nonNull(g.String)
+          }),
+          promptMany: g.field({
+            type: g.String
+          }),
+          promptConfirmLabel: g.field({
+            type: g.nonNull(g.String)
+          }),
+          promptConfirmLabelMany: g.field({
+            type: g.String
+          }),
+          fail: g.field({
+            type: g.nonNull(g.String)
+          }),
+          failMany: g.field({
+            type: g.String
+          }),
+          success: g.field({
+            type: g.nonNull(g.String)
+          }),
+          successMany: g.field({
+            type: g.String
+          })
+        }
+      }))
+    }),
+    graphql: g.field({
+      type: g.object()({
+        name: 'NixxieAdminUIActionMetaGraphQL',
+        fields: {
+          arguments: g.field({
+            type: g.nonNull(g.list(g.nonNull(g.object()({
+              name: 'NixxieAdminUIActionMetaGraphQLArgument',
+              fields: {
+                name: g.field({
+                  type: g.nonNull(g.String)
+                }),
+                type: g.field({
+                  type: g.nonNull(g.String)
+                }),
+                source: g.field({
+                  type: g.JSON
+                })
+              }
+            }))))
+          }),
+          names: g.field({
+            type: g.nonNull(g.object()({
+              name: 'NixxieAdminUIActionMetaGraphQLNames',
+              fields: {
+                one: g.field({
+                  type: g.nonNull(g.String)
+                }),
+                many: g.field({
+                  type: g.String
+                })
+              }
+            }))
+          })
+        }
+      })
+    }),
+    itemView: g.field({
+      resolve: args => args,
+      type: g.object()({
+        name: 'NixxieAdminUIActionMetaItemView',
+        fields: {
+          actionMode: g.field({
+            type: g.nonNull(g.JSON),
+            async resolve({
+              listKey,
+              key,
+              itemView,
+              item
+            }, _, context) {
+              const {
+                actionMode
+              } = itemView;
+              if (typeof actionMode !== 'function') return actionMode;
+              return actionMode({
+                session: context.session,
+                context,
+                listKey,
+                actionKey: key,
+                item
+              });
+            }
+          }),
+          navigation: g.field({
+            type: g.nonNull(g.enum({
+              name: 'NixxieAdminUIActionMetaItemViewNavigation',
+              values: g.enumValues(['follow', 'refetch', 'return'])
+            })),
+            resolve({
+              itemView
+            }) {
+              return itemView.navigation;
+            }
+          }),
+          hidePrompt: g.field({
+            type: g.nonNull(g.Boolean),
+            resolve({
+              itemView
+            }) {
+              return itemView.hidePrompt;
+            }
+          }),
+          hideToast: g.field({
+            type: g.nonNull(g.Boolean),
+            resolve({
+              itemView
+            }) {
+              return itemView.hideToast;
+            }
+          })
+        }
+      })
+    }),
+    listView: g.field({
+      type: g.nonNull(g.object()({
+        name: 'NixxieAdminUIActionMetaListView',
+        fields: {
+          actionMode: g.field({
+            type: g.nonNull(g.JSON)
+          })
+        }
+      }))
+    })
+  }
+});
+const NixxieAdminUIFieldGroupMeta = g.object()({
+  name: 'NixxieAdminUIFieldGroupMeta',
+  fields: {
+    label: g.field({
+      type: g.nonNull(g.String)
+    }),
+    description: g.field({
+      type: g.String
+    }),
+    fields: g.field({
+      type: g.nonNull(g.list(g.nonNull(NixxieAdminUIFieldMeta)))
+    })
+  }
+});
+const NixxieAdminUISort = g.object()({
+  name: 'NixxieAdminUISort',
+  fields: {
+    field: g.field({
+      type: g.nonNull(g.String)
+    }),
+    direction: g.field({
+      type: g.nonNull(g.enum({
+        name: 'NixxieAdminUISortDirection',
+        values: g.enumValues(['ASC', 'DESC'])
+      }))
+    })
+  }
+});
+const NixxieAdminUIGraphQL = g.object()({
+  name: 'NixxieAdminUIGraphQL',
+  fields: {
+    names: g.field({
+      type: g.nonNull(g.object()({
+        name: 'NixxieAdminUIGraphQLNames',
+        fields: {
+          outputTypeName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          whereInputName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          whereUniqueInputName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          // create
+          createInputName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          createMutationName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          createManyMutationName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          relateToOneForCreateInputName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          relateToManyForCreateInputName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          // read
+          itemQueryName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          listOrderName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          listQueryCountName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          listQueryName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          // update
+          updateInputName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          updateMutationName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          updateManyInputName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          updateManyMutationName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          relateToOneForUpdateInputName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          relateToManyForUpdateInputName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          // delete
+          deleteMutationName: g.field({
+            type: g.nonNull(g.String)
+          }),
+          deleteManyMutationName: g.field({
+            type: g.nonNull(g.String)
+          })
+        }
+      }))
+    })
+  }
+});
+const NixxieAdminUIListMeta = g.object()({
+  name: 'NixxieAdminUIListMeta',
+  fields: {
+    key: g.field({
+      type: g.nonNull(g.String)
+    }),
+    label: g.field({
+      type: g.nonNull(g.String)
+    }),
+    singular: g.field({
+      type: g.nonNull(g.String)
+    }),
+    plural: g.field({
+      type: g.nonNull(g.String)
+    }),
+    path: g.field({
+      type: g.nonNull(g.String)
+    }),
+    labelField: g.field({
+      type: g.nonNull(g.String)
+    }),
+    fields: g.field({
+      resolve: ({
+        fields,
+        item
+      }) => {
+        return fields.map(f => {
+          var _item$f$key;
+          return {
+            ...f,
+            item,
+            itemField: (_item$f$key = item === null || item === void 0 ? void 0 : item[f.key]) !== null && _item$f$key !== void 0 ? _item$f$key : null
+          };
+        });
+      },
+      type: g.nonNull(g.list(g.nonNull(NixxieAdminUIFieldMeta)))
+    }),
+    groups: g.field({
+      type: g.nonNull(g.list(g.nonNull(NixxieAdminUIFieldGroupMeta)))
+    }),
+    actions: g.field({
+      resolve: ({
+        actions,
+        item
+      }) => actions.map(action => ({
+        ...action,
+        item
+      })),
+      type: g.nonNull(g.list(g.nonNull(NixxieAdminUIActionMeta)))
+    }),
+    graphql: g.field({
+      type: g.nonNull(NixxieAdminUIGraphQL)
+    }),
+    pageSize: g.field({
+      type: g.nonNull(g.Int)
+    }),
+    initialColumns: g.field({
+      type: g.nonNull(g.list(g.nonNull(g.String)))
+    }),
+    initialSearchFields: g.field({
+      type: g.nonNull(g.list(g.nonNull(g.String)))
+    }),
+    initialSort: g.field({
+      type: NixxieAdminUISort
+    }),
+    initialFilter: g.field({
+      type: g.JSON
+    }),
+    isSingleton: g.field({
+      type: g.nonNull(g.Boolean)
+    }),
+    hideNavigation: g.field({
+      type: g.nonNull(g.Boolean)
+    }),
+    hideCreate: g.field({
+      type: g.nonNull(g.Boolean)
+    }),
+    hideDelete: g.field({
+      type: g.nonNull(g.Boolean)
+    })
+  }
+});
+const adminMeta = g.object()({
+  name: 'NixxieAdminMeta',
+  fields: {
+    lists: g.field({
+      type: g.nonNull(g.list(g.nonNull(NixxieAdminUIListMeta)))
+    }),
+    list: g.field({
+      type: NixxieAdminUIListMeta,
+      args: {
+        key: g.arg({
+          type: g.nonNull(g.String)
+        }),
+        itemId: g.arg({
+          type: g.ID
+        })
+      },
+      async resolve(source, {
+        key,
+        itemId
+      }, context) {
+        if (itemId === null || itemId === undefined) {
+          return {
+            ...source.listsByKey[key],
+            item: null
+          };
+        }
+        // WARNING: do not use sudo
+        const item = await context.db[key].findOne({
+          where: {
+            id: itemId
+          }
+        });
+        if (!item) {
+          return {
+            ...source.listsByKey[key],
+            item: null
+          };
+        }
+        return {
+          ...source.listsByKey[key],
+          item
+        };
+      }
+    })
+  }
+});
+const NixxieMeta = g.object()({
+  name: 'NixxieMeta',
+  fields: {
+    adminMeta: g.field({
+      type: g.nonNull(adminMeta),
+      async resolve({
+        adminMeta
+      }, _, context) {
+        if (context.__internal.sudo) return adminMeta;
+        const isAllowed = await adminMeta.isAccessAllowed(context);
+        if (isAllowed) return adminMeta;
+
+        // TODO: we need better errors
+        throw new Error('Access denied');
+      }
+    })
+  }
+});
+
+const tracer = trace.getTracer('nixxie');
+async function withSpan(name, fn, attrs) {
+  return tracer.startActiveSpan(name, {
+    attributes: attrs
+  }, async span => {
+    try {
+      const result = await fn(span);
+      span.setStatus({
+        code: SpanStatusCode.OK
+      });
+      return result;
+    } catch (err) {
+      span.recordException(err instanceof Error ? err : {
+        message: String(err)
+      });
+      span.setStatus({
+        code: SpanStatusCode.ERROR
+      });
+      throw err;
+    } finally {
+      span.end();
+    }
+  });
+}
+
+async function validate({
+  list,
+  hookArgs
+}) {
+  const messages = [];
+  const fieldsErrors = [];
+  const {
+    operation
+  } = hookArgs;
+
+  // field validation hooks
+  await Promise.all(Object.entries(list.fields).map(async ([fieldKey, field]) => {
+    const addValidationError = msg => void messages.push(`${list.listKey}.${fieldKey}: ${msg}`);
+    const hook = field.hooks.validate[operation];
+    try {
+      var _hookArgs$item, _hookArgs$inputData, _hookArgs$resolvedDat;
+      await hook({
+        ...hookArgs,
+        addValidationError,
+        fieldKey,
+        itemField: (_hookArgs$item = hookArgs.item) === null || _hookArgs$item === void 0 ? void 0 : _hookArgs$item[fieldKey],
+        inputFieldData: (_hookArgs$inputData = hookArgs.inputData) === null || _hookArgs$inputData === void 0 ? void 0 : _hookArgs$inputData[fieldKey],
+        resolvedFieldData: (_hookArgs$resolvedDat = hookArgs.resolvedData) === null || _hookArgs$resolvedDat === void 0 ? void 0 : _hookArgs$resolvedDat[fieldKey]
+      }); // TODO: FIXME
+    } catch (error) {
+      fieldsErrors.push({
+        error,
+        tag: `${list.listKey}.${fieldKey}.hooks.validateInput`
+      });
+    }
+  }));
+  if (fieldsErrors.length) {
+    throw extensionError('validateInput', fieldsErrors);
+  }
+
+  // list validation hooks
+  {
+    const addValidationError = msg => void messages.push(`${list.listKey}: ${msg}`);
+    const hook = list.hooks.validate[operation];
+    try {
+      await hook({
+        ...hookArgs,
+        addValidationError
+      }); // TODO: FIXME
+    } catch (error) {
+      throw extensionError('validateInput', [{
+        error,
+        tag: `${list.listKey}.hooks.validateInput`
+      }]);
+    }
+    if (messages.length) {
+      throw validationFailureError(messages);
+    }
+  }
+}
+async function runSideEffectOnlyHook(list, hookName, args) {
+  const {
+    operation
+  } = args;
+  let shouldRunFieldLevelHook;
+  if (operation === 'delete') {
+    // always run field hooks for delete operations
+    shouldRunFieldLevelHook = () => true;
+  } else {
+    // only run field hooks on if the field was specified in the
+    //   original input for create and update operations.
+    const inputDataKeys = new Set(Object.keys(args.inputData));
+    shouldRunFieldLevelHook = fieldKey => inputDataKeys.has(fieldKey);
+  }
+
+  // field hooks
+  const fieldsErrors = [];
+  await Promise.all(Object.entries(list.fields).map(async ([fieldKey, field]) => {
+    if (shouldRunFieldLevelHook(fieldKey)) {
+      try {
+        var _args$item, _args$inputData, _args$resolvedData, _originalItem;
+        await field.hooks[hookName][operation]({
+          ...args,
+          fieldKey,
+          itemField: (_args$item = args.item) === null || _args$item === void 0 ? void 0 : _args$item[fieldKey],
+          inputFieldData: (_args$inputData = args.inputData) === null || _args$inputData === void 0 ? void 0 : _args$inputData[fieldKey],
+          resolvedFieldData: (_args$resolvedData = args.resolvedData) === null || _args$resolvedData === void 0 ? void 0 : _args$resolvedData[fieldKey],
+          originalItemField: (_originalItem = args.originalItem) === null || _originalItem === void 0 ? void 0 : _originalItem[fieldKey]
+        }); // TODO: FIXME any
+      } catch (error) {
+        fieldsErrors.push({
+          error,
+          tag: `${list.listKey}.${fieldKey}.hooks.${hookName}`
+        });
+      }
+    }
+  }));
+  if (fieldsErrors.length) {
+    throw extensionError(hookName, fieldsErrors);
+  }
+
+  // list hooks
+  try {
+    await list.hooks[hookName][operation](args); // TODO: FIXME any
+  } catch (error) {
+    throw extensionError(hookName, [{
+      error,
+      tag: `${list.listKey}.hooks.${hookName}`
+    }]);
+  }
+}
+
+class RelationshipErrors extends Error {
+  constructor(errors) {
+    super('Multiple relationship errors');
+    this.errors = errors;
+  }
+}
+function getResolvedUniqueWheres(uniqueInputs, context, foreignList, operation) {
+  return uniqueInputs.map(uniqueInput => checkUniqueItemExists(uniqueInput, foreignList, context, operation));
+}
+function resolveRelateToManyForCreateInput(nestedMutationState, context, foreignList, tag) {
+  return async value => {
+    var _value$connect, _value$set, _value$create;
+    if (!Array.isArray(value.connect) && !Array.isArray(value.create) && !Array.isArray(value.set)) {
+      throw userInputError(`You must provide at least one of "set", "connect" or "create" in to-many relationship inputs for "create" operations.`);
+    }
+
+    // Perform queries for the connections
+    const connects = Promise.allSettled(getResolvedUniqueWheres((_value$connect = value.connect) !== null && _value$connect !== void 0 ? _value$connect : [], context, foreignList, 'connect'));
+    const sets = Promise.allSettled(getResolvedUniqueWheres((_value$set = value.set) !== null && _value$set !== void 0 ? _value$set : [], context, foreignList, 'set'));
+
+    // Perform nested mutations for the creations
+    const creates = Promise.allSettled(((_value$create = value.create) !== null && _value$create !== void 0 ? _value$create : []).map(x => nestedMutationState.create(x, foreignList)));
+
+    // Resolve items
+    const [connectResult, createResult, setResult] = await Promise.all([connects, creates, sets]);
+
+    // Collect all the errors
+    const errors = [...connectResult, ...createResult, ...setResult].filter(isRejected);
+    if (errors.length) throw new RelationshipErrors(errors.map(x => ({
+      error: x.reason,
+      tag
+    })));
+    return {
+      connect: [...setResult, ...connectResult, ...createResult].filter(isFulfilled).map(x => x.value)
+    };
+  };
+}
+function resolveRelateToManyForUpdateInput(nestedMutationState, context, foreignList, tag) {
+  return async value => {
+    var _value$connect2, _value$disconnect, _value$set2, _value$create2;
+    if (!Array.isArray(value.connect) && !Array.isArray(value.create) && !Array.isArray(value.disconnect) && !Array.isArray(value.set)) {
+      throw userInputError(`You must provide at least one of "set", "connect", "create" or "disconnect" in to-many relationship inputs for "update" operations.`);
+    }
+    if (value.set && value.disconnect) {
+      throw userInputError(`The "set" and "disconnect" fields cannot both be provided to to-many relationship inputs for "update" operations.`);
+    }
+
+    // Perform queries for the connections
+    const connects = Promise.allSettled(getResolvedUniqueWheres((_value$connect2 = value.connect) !== null && _value$connect2 !== void 0 ? _value$connect2 : [], context, foreignList, 'connect'));
+    const disconnects = Promise.allSettled(getResolvedUniqueWheres((_value$disconnect = value.disconnect) !== null && _value$disconnect !== void 0 ? _value$disconnect : [], context, foreignList, 'disconnect'));
+    const sets = Promise.allSettled(getResolvedUniqueWheres((_value$set2 = value.set) !== null && _value$set2 !== void 0 ? _value$set2 : [], context, foreignList, 'set'));
+
+    // Perform nested mutations for the creations
+    const creates = Promise.allSettled(((_value$create2 = value.create) !== null && _value$create2 !== void 0 ? _value$create2 : []).map(x => nestedMutationState.create(x, foreignList)));
+
+    // Resolve items
+    const [connectResult, createResult, disconnectResult, setResult] = await Promise.all([connects, creates, disconnects, sets]);
+
+    // Collect all the errors
+    const errors = [...connectResult, ...createResult, ...disconnectResult, ...setResult].filter(isRejected);
+    if (errors.length) throw new RelationshipErrors(errors.map(x => ({
+      error: x.reason,
+      tag
+    })));
+    return {
+      // unlike all the other operations, an empty array isn't a no-op for set
+      set: value.set ? setResult.filter(isFulfilled).map(x => x.value) : undefined,
+      disconnect: disconnectResult.filter(isFulfilled).map(x => x.value),
+      connect: [...connectResult, ...createResult].filter(isFulfilled).map(x => x.value)
+    };
+  };
+}
+
+async function handleCreateAndUpdate(value, nestedMutationState, context, foreignList) {
+  if (value.connect) {
+    return {
+      connect: await checkUniqueItemExists(value.connect, foreignList, context, 'connect')
+    };
+  }
+  if (value.create) {
+    const {
+      id
+    } = await nestedMutationState.create(value.create, foreignList);
+    return {
+      connect: {
+        id
+      }
+    };
+  }
+}
+function resolveRelateToOneForCreateInput(nestedMutationState, context, foreignList) {
+  return async value => {
+    const numOfKeys = Object.keys(value).length;
+    if (numOfKeys !== 1) {
+      throw userInputError(`You must provide "connect" or "create" in to-one relationship inputs for "create" operations.`);
+    }
+    return handleCreateAndUpdate(value, nestedMutationState, context, foreignList);
+  };
+}
+function resolveRelateToOneForUpdateInput(nestedMutationState, context, foreignList) {
+  return async value => {
+    if (Object.keys(value).length !== 1) {
+      throw userInputError(`You must provide one of "connect", "create" or "disconnect" in to-one relationship inputs for "update" operations.`);
+    }
+    if (value.connect || value.create) {
+      return handleCreateAndUpdate(value, nestedMutationState, context, foreignList);
+    }
+    if (value.disconnect) {
+      return {
+        disconnect: true
+      };
+    }
+  };
+}
+
+async function getFilteredItem(list, context, uniqueWhere, accessFilters, operation) {
+  // early exit if they want to exclude everything
+  if (accessFilters === false) {
+    throw accessDeniedError(cannotForItem(operation, list));
+  }
+
+  // merge the filter access control and try to get the item
+  let where = mapUniqueWhereToWhere(uniqueWhere, list);
+  await checkFilterOrderAccess([...traverse(list, where)], context, 'filter');
+  if (typeof accessFilters === 'object') {
+    where = {
+      AND: [where, await resolveWhereInput(accessFilters, list, context)]
+    };
+  }
+  const item = await context.prisma[list.listKey].findFirst({
+    where
+  });
+  if (item !== null) return item;
+  throw accessDeniedError(cannotForItem(operation, list));
+}
+async function createSingle__(inputData, list, context) {
+  return await withSpan(`create ${list.graphql.names.outputTypeNameLower}`, async span => {
+    var _result$id;
+    // throw an accessDeniedError if not allowed
+    await enforceListLevelAccessControl(context, 'create', list, inputData, undefined);
+    await enforceFieldLevelAccessControl(context, 'create', list, inputData, undefined);
+    const {
+      beforeOperation,
+      afterOperation,
+      data
+    } = await resolveInputForCreateOrUpdate(list, context, inputData, undefined);
+
+    // before operation
+    await beforeOperation();
+
+    // operation
+    const result = await context.prisma[list.listKey].create({
+      data: list.isSingleton ? {
+        ...data,
+        id: 1
+      } : data
+    });
+    span.setAttribute('nixxie.result.id', (_result$id = result === null || result === void 0 ? void 0 : result.id) !== null && _result$id !== void 0 ? _result$id : '');
+    return {
+      item: result,
+      afterOperation
+    };
+  }, {
+    'nixxie.list': list.listKey,
+    'nixxie.operation': 'create'
+  });
+}
+var _afterOperations = /*#__PURE__*/new WeakMap();
+var _context = /*#__PURE__*/new WeakMap();
+class NestedMutationState {
+  constructor(context) {
+    _classPrivateFieldInitSpec(this, _afterOperations, []);
+    _classPrivateFieldInitSpec(this, _context, void 0);
+    _classPrivateFieldSet(_context, this, context);
+  }
+  async create(data, list) {
+    const context = _classPrivateFieldGet(_context, this);
+    const operationAccess = await getOperationAccess(list, context, 'create');
+    if (!operationAccess) throw accessDeniedError(cannotForItem('create', list));
+
+    // before operation AND operation
+    const {
+      item,
+      afterOperation
+    } = await createSingle__(data, list, context);
+
+    // after operation
+    _classPrivateFieldGet(_afterOperations, this).push(() => afterOperation(item));
+    return {
+      id: item.id
+    };
+  }
+  async afterOperation() {
+    await promiseAllRejectWithAllErrors(_classPrivateFieldGet(_afterOperations, this).map(async x => x()));
+  }
+}
+async function updateSingle__({
+  where,
+  data: inputData
+}, list, context, accessFilters) {
+  return await withSpan(`update ${list.graphql.names.outputTypeNameLower}`, async span => {
+    var _result$id2;
+    // validate and resolve the input filter
+    const uniqueWhere = await resolveUniqueWhereInput(where, list, context);
+
+    // filter and item access control - throws an AccessDeniedError if not allowed
+    const item = await getFilteredItem(list, context, uniqueWhere, accessFilters, 'update');
+
+    // throw an accessDeniedError if not allowed
+    await enforceListLevelAccessControl(context, 'update', list, inputData !== null && inputData !== void 0 ? inputData : {}, item);
+    await enforceFieldLevelAccessControl(context, 'update', list, inputData !== null && inputData !== void 0 ? inputData : {}, item);
+    const {
+      beforeOperation,
+      afterOperation,
+      data
+    } = await resolveInputForCreateOrUpdate(list, context, inputData !== null && inputData !== void 0 ? inputData : {}, item);
+
+    // before operation
+    await beforeOperation();
+
+    // operation
+    const result = await context.prisma[list.listKey].update({
+      where: {
+        id: item.id
+      },
+      data
+    });
+    span.setAttribute('nixxie.result.id', (_result$id2 = result === null || result === void 0 ? void 0 : result.id) !== null && _result$id2 !== void 0 ? _result$id2 : '');
+
+    // after operation
+    await afterOperation(result);
+    return result;
+  }, {
+    'nixxie.list': list.listKey,
+    'nixxie.operation': 'update'
+  });
+}
+async function deleteSingle__(where, list, context, accessFilters) {
+  return await withSpan(`delete ${list.graphql.names.outputTypeNameLower}`, async span => {
+    var _result$id3;
+    // validate and resolve the input filter
+    const uniqueWhere = await resolveUniqueWhereInput(where, list, context);
+
+    // filter and item access control throw an AccessDeniedError if not allowed
+    // apply access.filter.* controls
+    const item = await getFilteredItem(list, context, uniqueWhere, accessFilters, 'delete');
+    await enforceListLevelAccessControl(context, 'delete', list, {}, item);
+    // WARNING: no field level access control for delete operations
+
+    const hookArgs = {
+      operation: 'delete',
+      listKey: list.listKey,
+      context,
+      item,
+      resolvedData: undefined,
+      inputData: undefined
+    };
+
+    // hooks
+    await validate({
+      list,
+      hookArgs
+    });
+
+    // before operation
+    await runSideEffectOnlyHook(list, 'beforeOperation', hookArgs);
+
+    // operation
+    const result = await context.prisma[list.listKey].delete({
+      where: {
+        id: item.id
+      }
+    });
+    span.setAttribute('nixxie.result.id', (_result$id3 = result === null || result === void 0 ? void 0 : result.id) !== null && _result$id3 !== void 0 ? _result$id3 : '');
+
+    // after operation
+    await runSideEffectOnlyHook(list, 'afterOperation', {
+      ...hookArgs,
+      item: undefined,
+      originalItem: item
+    });
+    return result;
+  }, {
+    'nixxie.list': list.listKey,
+    'nixxie.operation': 'delete'
+  });
+}
+async function actionSingle__(context, list, action, {
+  where,
+  args
+}) {
+  return await withSpan(action.otel, async span => {
+    var _ref;
+    // no before operation hook for actions
+
+    // operation
+    const result = await action.resolve({
+      listKey: list.listKey,
+      actionKey: action.actionKey,
+      where,
+      args
+    }, context);
+    span.setAttribute('nixxie.result.id', (_ref = result === null || result === void 0 ? void 0 : result.id) !== null && _ref !== void 0 ? _ref : '');
+
+    // no after operation hook for actions
+    return result;
+  }, {
+    'nixxie.list': list.listKey,
+    'nixxie.action': action.actionKey
+  });
+}
+
+//
+
+async function createOne(inputData, list, context) {
+  const operationAccess = await getOperationAccess(list, context, 'create');
+  if (!operationAccess) throw accessDeniedError(cannotForItem('create', list));
+
+  // get list-level access control filters
+  //   NOTHING - no filters for create operations
+
+  // operation
+  const {
+    item,
+    afterOperation
+  } = await createSingle__(inputData !== null && inputData !== void 0 ? inputData : {}, list, context);
+
+  // after operation // TODO: move to createSingle__
+  await afterOperation(item);
+  return item;
+}
+async function createMany(inputDatas, list, context) {
+  const operationAccess = await getOperationAccess(list, context, 'create');
+  // WARNING: we do not short-circuit here, we throw for each
+
+  // get list-level access control filters
+  //   NOTHING - no filters for create operations
+
+  return inputDatas.map(async inputData => {
+    // throw for each attempt
+    if (!operationAccess) throw accessDeniedError(cannotForItem('create', list));
+
+    // operation
+    const {
+      item,
+      afterOperation
+    } = await createSingle__(inputData !== null && inputData !== void 0 ? inputData : {}, list, context);
+
+    // after operation // TODO: move to createSingle__
+    await afterOperation(item);
+    return item;
+  });
+}
+async function updateOne(updateInput, list, context) {
+  const operationAccess = await getOperationAccess(list, context, 'update');
+  if (!operationAccess) throw accessDeniedError(cannotForItem('update', list));
+
+  // get list-level access control filters
+  const accessFilters = await getAccessFilters(list, context, 'update');
+  return updateSingle__(updateInput, list, context, accessFilters);
+}
+async function updateMany(updateManyInput, list, context) {
+  const operationAccess = await getOperationAccess(list, context, 'update');
+  // WARNING: we do not short-circuit here, we throw for each
+
+  // get list-level access control filters
+  const accessFilters = await getAccessFilters(list, context, 'update');
+  return updateManyInput.map(async updateInput => {
+    // throw for each attempt
+    if (!operationAccess) throw accessDeniedError(cannotForItem('update', list));
+    return updateSingle__(updateInput, list, context, accessFilters);
+  });
+}
+async function deleteOne(where, list, context) {
+  const operationAccess = await getOperationAccess(list, context, 'delete');
+  if (!operationAccess) throw accessDeniedError(cannotForItem('delete', list));
+
+  // get list-level access control filters
+  const accessFilters = await getAccessFilters(list, context, 'delete');
+  return deleteSingle__(where, list, context, accessFilters);
+}
+async function deleteMany(wheres, list, context) {
+  const operationAccess = await getOperationAccess(list, context, 'delete');
+  // WARNING: we do not short-circuit here, we throw for each
+
+  // get list-level access control filters
+  const accessFilters = await getAccessFilters(list, context, 'delete');
+  return wheres.map(async where => {
+    // throw for each attempt
+    if (!operationAccess) throw accessDeniedError(cannotForItem('delete', list));
+    return deleteSingle__(where, list, context, accessFilters);
+  });
+}
+async function actionOne(input, list, context, action) {
+  const operationAccess = await action.access({
+    context,
+    session: context.session,
+    // TODO: remove in breaking change
+    listKey: list.listKey,
+    actionKey: action.actionKey
+  });
+  if (!operationAccess) throw accessDeniedError(cannotActionForItem(action, list));
+
+  // get list-level access control filters
+  //   NOTHING - no filters for action operations
+
+  return actionSingle__(context, list, action, input);
+}
+async function actionMany(inputs, list, context, action) {
+  const operationAccess = await action.access({
+    context,
+    session: context.session,
+    // TODO: remove in breaking change
+    listKey: list.listKey,
+    actionKey: action.actionKey
+  });
+  // WARNING: we do not short-circuit here, we throw for each
+
+  // get list-level access control filters
+  //   NOTHING - no filters for action operations
+
+  return inputs.map(async ({
+    where,
+    ...args
+  }) => {
+    // throw for each attempt
+    if (!operationAccess) throw accessDeniedError(cannotActionForItem(action, list));
+    return actionSingle__(context, list, action, {
+      where,
+      args
+    });
+  });
+}
+async function getResolvedData(list, hookArgs, nestedMutationState) {
+  const {
+    context,
+    operation
+  } = hookArgs;
+  let resolvedData = hookArgs.inputData;
+
+  // apply non-relationship field type input resolvers
+  const resolverErrors = [];
+  resolvedData = Object.fromEntries(await Promise.all(Object.entries(list.fields).map(async ([fieldKey, field]) => {
+    var _field$input;
+    const inputResolver = (_field$input = field.input) === null || _field$input === void 0 || (_field$input = _field$input[operation]) === null || _field$input === void 0 ? void 0 : _field$input.resolve;
+    if (inputResolver && field.dbField.kind !== 'relation') {
+      try {
+        return [fieldKey, await inputResolver(resolvedData[fieldKey], context, undefined)];
+      } catch (error) {
+        resolverErrors.push({
+          error,
+          tag: `${list.listKey}.${fieldKey}`
+        });
+      }
+    }
+    return [fieldKey, resolvedData[fieldKey]];
+  })));
+  if (resolverErrors.length) throw resolverError(resolverErrors);
+
+  // apply relationship field type input resolvers
+  const relationshipErrors = [];
+  resolvedData = Object.fromEntries(await Promise.all(Object.entries(list.fields).map(async ([fieldKey, field]) => {
+    var _field$input2;
+    const inputResolver = (_field$input2 = field.input) === null || _field$input2 === void 0 || (_field$input2 = _field$input2[operation]) === null || _field$input2 === void 0 ? void 0 : _field$input2.resolve;
+    let input = resolvedData[fieldKey];
+    if (inputResolver && field.dbField.kind === 'relation') {
+      const tag = `${list.listKey}.${fieldKey}`;
+      try {
+        input = await inputResolver(input, context,
+        // this third argument only applies to relationship fields
+        (() => {
+          if (input === undefined) {
+            // no-op: this is what we want
+            return () => undefined;
+          }
+          if (input === null) {
+            // no-op: should this be userinputerror?
+            return () => undefined;
+          }
+          const foreignList = list.lists[field.dbField.list];
+          if (field.dbField.mode === 'many' && operation === 'create') {
+            return resolveRelateToManyForCreateInput(nestedMutationState, context, foreignList, tag);
+          }
+          if (field.dbField.mode === 'many' && operation === 'update') {
+            return resolveRelateToManyForUpdateInput(nestedMutationState, context, foreignList, tag);
+          }
+          if (field.dbField.mode === 'one' && operation === 'create') {
+            return resolveRelateToOneForCreateInput(nestedMutationState, context, foreignList);
+          }
+          if (field.dbField.mode === 'one' && operation === 'update') {
+            return resolveRelateToOneForUpdateInput(nestedMutationState, context, foreignList);
+          }
+          throw new Error('Unknown relationship field type input mode or operation');
+        })());
+      } catch (error) {
+        if (error instanceof RelationshipErrors) {
+          relationshipErrors.push(...error.errors);
+        } else {
+          relationshipErrors.push({
+            error,
+            tag
+          });
+        }
+      }
+    }
+    return [fieldKey, input];
+  })));
+  if (relationshipErrors.length) throw relationshipError(relationshipErrors);
+
+  // field hooks
+  const fieldsErrors = [];
+  resolvedData = Object.fromEntries(await Promise.all(Object.entries(list.fields).map(async ([fieldKey, field]) => {
+    try {
+      return [fieldKey, operation === 'create' ? await field.hooks.resolveInput.create({
+        ...hookArgs,
+        itemField: undefined,
+        inputFieldData: hookArgs.inputData[fieldKey],
+        resolvedData,
+        resolvedFieldData: resolvedData[fieldKey],
+        fieldKey
+      }) : await field.hooks.resolveInput.update({
+        ...hookArgs,
+        itemField: hookArgs.item[fieldKey],
+        inputFieldData: hookArgs.inputData[fieldKey],
+        resolvedData,
+        resolvedFieldData: resolvedData[fieldKey],
+        fieldKey
+      })];
+    } catch (error) {
+      fieldsErrors.push({
+        error,
+        tag: `${list.listKey}.${fieldKey}.hooks.resolveInput`
+      });
+      return [fieldKey, undefined];
+    }
+  })));
+  if (fieldsErrors.length) throw extensionError('resolveInput', fieldsErrors);
+
+  // list hooks
+  try {
+    if (operation === 'create') {
+      resolvedData = await list.hooks.resolveInput.create({
+        ...hookArgs,
+        resolvedData
+      });
+    } else if (operation === 'update') {
+      resolvedData = await list.hooks.resolveInput.update({
+        ...hookArgs,
+        resolvedData
+      });
+    }
+  } catch (error) {
+    throw extensionError('resolveInput', [{
+      error,
+      tag: `${list.listKey}.hooks.resolveInput`
+    }]);
+  }
+  return resolvedData;
+}
+async function resolveInputForCreateOrUpdate(list, context, inputData, item) {
+  const nestedMutationState = new NestedMutationState(context);
+  const baseHookArgs = {
+    context,
+    listKey: list.listKey,
+    inputData,
+    resolvedData: {}
+  };
+  const hookArgs = item === undefined ? {
+    ...baseHookArgs,
+    operation: 'create',
+    item,
+    originalItem: undefined
+  } : {
+    ...baseHookArgs,
+    operation: 'update',
+    item,
+    originalItem: item
+  };
+
+  // Take the original input and resolve all the fields down to what
+  // will be saved into the database.
+  hookArgs.resolvedData = await getResolvedData(list, hookArgs, nestedMutationState);
+
+  // Apply all validation checks
+  await validate({
+    list,
+    hookArgs
+  });
+
+  // Return the full resolved input (ready for prisma level operation),
+  // and the afterOperation hook to be applied
+  return {
+    data: transformForPrismaClient(list, context, hookArgs.resolvedData),
+    beforeOperation: async () => {
+      // before operation
+      await runSideEffectOnlyHook(list, 'beforeOperation', hookArgs);
+    },
+    afterOperation: async updatedItem => {
+      await nestedMutationState.afterOperation();
+
+      // after operation
+      await runSideEffectOnlyHook(list, 'afterOperation', {
+        ...hookArgs,
+        item: updatedItem
+      });
+    }
+  };
+}
+function transformInnerDBField(dbField, context, value) {
+  if (dbField.kind === 'scalar' && dbField.scalar === 'Json' && value === null) {
+    return context.__internal.prisma.DbNull;
+  }
+  return value;
+}
+function transformForPrismaClient(list, context, data) {
+  return Object.fromEntries([...function* () {
+    for (const fieldKey in data) {
+      if (!(fieldKey in list.fields)) {
+        // either the types are wrong, or someone didnt use them, either way, bail out
+        throw new Error(`Attempted to use unknown field "${fieldKey}"`);
+      }
+      const value = data[fieldKey];
+      const {
+        dbField
+      } = list.fields[fieldKey];
+      if (dbField.kind === 'multi') {
+        for (const innerFieldKey in value) {
+          const innerFieldValue = value[innerFieldKey];
+          yield [getDBFieldKeyForFieldOnMultiField(fieldKey, innerFieldKey), transformInnerDBField(dbField.fields[innerFieldKey], context, innerFieldValue)];
+        }
+        continue;
+      }
+      yield [fieldKey, transformInnerDBField(dbField, context, value)];
+    }
+  }()]);
+}
+
+// This is not a thing that I really agree with but it's to make the behaviour consistent with old nixxie.
+// Basically, old nixxie uses Promise.allSettled and then after that maps that into promises that resolve and reject,
+// whereas the new stuff is just like "here are some promises" with no guarantees about the order they will be settled in.
+// That doesn't matter when they all resolve successfully because the order they resolve successfully in
+// doesn't affect anything, If some reject though, the order that they reject in will be the order in the errors array
+// and some of our tests rely on the order of the graphql errors array. They shouldn't, but they do.
+function promisesButSettledWhenAllSettledAndInOrder(promises) {
+  const resultsPromise = Promise.allSettled(promises);
+  return promises.map(async (_, i) => {
+    const result = (await resultsPromise)[i];
+    return result.status === 'fulfilled' ? Promise.resolve(result.value) : Promise.reject(result.reason);
+  });
+}
+function nonNull(t) {
+  if (t === g.Empty) return t;
+  return g.nonNull(t);
+}
+function getMutationsForList(list) {
+  const defaultUniqueWhereInput = list.isSingleton ? {
+    id: '1'
+  } : undefined;
+  const createOne_ = g.field({
+    type: list.graphql.types.output,
+    args: {
+      data: g.arg({
+        type: nonNull(list.graphql.types.create)
+      })
+    },
+    async resolve(_, {
+      data
+    }, context, info) {
+      return await withSpan(`mutation ${info.fieldName}`, async () => {
+        return createOne(data, list, context);
+      }, {
+        'nixxie.list': list.listKey,
+        'nixxie.operation': 'create'
+      });
+    }
+  });
+  const createMany_ = g.field({
+    type: g.list(list.graphql.types.output),
+    args: {
+      data: g.arg({
+        type: g.nonNull(g.list(nonNull(list.graphql.types.create)))
+      })
+    },
+    async resolve(_, {
+      data
+    }, context, info) {
+      return await withSpan(`mutation ${info.fieldName}`, async () => {
+        return promisesButSettledWhenAllSettledAndInOrder(await createMany(data, list, context));
+      }, {
+        'nixxie.list': list.listKey,
+        'nixxie.operation': 'create',
+        'nixxie.many': true
+      });
+    }
+  });
+  const updateOne_ = g.field({
+    type: list.graphql.types.output,
+    args: {
+      where: g.arg({
+        type: g.nonNull(list.graphql.types.uniqueWhere),
+        defaultValue: defaultUniqueWhereInput
+      }),
+      data: g.arg({
+        type: nonNull(list.graphql.types.update)
+      })
+    },
+    async resolve(_, {
+      where,
+      data
+    }, context, info) {
+      return await withSpan(`mutation ${info.fieldName}`, async () => {
+        return updateOne({
+          where,
+          data
+        }, list, context);
+      }, {
+        'nixxie.list': list.listKey,
+        'nixxie.operation': 'update'
+      });
+    }
+  });
+  const updateManyInput = g.inputObject({
+    name: list.graphql.names.updateManyInputName,
+    fields: {
+      where: g.arg({
+        type: g.nonNull(list.graphql.types.uniqueWhere),
+        defaultValue: defaultUniqueWhereInput
+      }),
+      data: g.arg({
+        type: nonNull(list.graphql.types.update)
+      })
+    }
+  });
+  const updateMany_ = g.field({
+    type: g.list(list.graphql.types.output),
+    args: {
+      data: g.arg({
+        type: g.nonNull(g.list(g.nonNull(updateManyInput)))
+      })
+    },
+    async resolve(_, {
+      data
+    }, context, info) {
+      return await withSpan(`mutation ${info.fieldName}`, async () => {
+        return promisesButSettledWhenAllSettledAndInOrder(await updateMany(data, list, context));
+      }, {
+        'nixxie.list': list.listKey,
+        'nixxie.operation': 'update',
+        'nixxie.many': true
+      });
+    }
+  });
+  const deleteOne_ = g.field({
+    type: list.graphql.types.output,
+    args: {
+      where: g.arg({
+        type: g.nonNull(list.graphql.types.uniqueWhere),
+        defaultValue: defaultUniqueWhereInput
+      })
+    },
+    async resolve(_, {
+      where
+    }, context, info) {
+      return await withSpan(`mutation ${info.fieldName}`, async () => {
+        return deleteOne(where, list, context);
+      }, {
+        'nixxie.list': list.listKey,
+        'nixxie.operation': 'delete'
+      });
+    }
+  });
+  const deleteMany_ = g.field({
+    type: g.list(list.graphql.types.output),
+    args: {
+      where: g.arg({
+        type: g.nonNull(g.list(g.nonNull(list.graphql.types.uniqueWhere)))
+      })
+    },
+    async resolve(_, {
+      where
+    }, context, info) {
+      return await withSpan(`mutation ${info.fieldName}`, async () => {
+        return promisesButSettledWhenAllSettledAndInOrder(await deleteMany(where, list, context));
+      }, {
+        'nixxie.list': list.listKey,
+        'nixxie.operation': 'delete',
+        'nixxie.many': true
+      });
+    }
+  });
+  const collectedTypes = [];
+  const {
+    isEnabled
+  } = list.graphql;
+  if (isEnabled.type) {
+    // adding all of these types explicitly isn't strictly necessary but we do it to create a certain order in the schema
+    collectedTypes.push(list.graphql.types.output);
+    if (isEnabled.query || isEnabled.update || isEnabled.delete) {
+      collectedTypes.push(list.graphql.types.uniqueWhere);
+    }
+    if (isEnabled.query) {
+      for (const field of Object.values(list.fields)) {
+        if (isEnabled.query && field.graphql.isEnabled.read && field.unreferencedConcreteInterfaceImplementations) {
+          // this _IS_ actually necessary since they aren't implicitly referenced by other types, unlike the types above
+          collectedTypes.push(...field.unreferencedConcreteInterfaceImplementations);
+        }
+      }
+      collectedTypes.push(list.graphql.types.where);
+      collectedTypes.push(list.graphql.types.orderBy);
+    }
+    if (isEnabled.update) {
+      if (list.graphql.types.update instanceof GInputObjectType) {
+        collectedTypes.push(list.graphql.types.update);
+      }
+      collectedTypes.push(updateManyInput);
+    }
+    if (isEnabled.create) {
+      if (list.graphql.types.create instanceof GInputObjectType) {
+        collectedTypes.push(list.graphql.types.create);
+      }
+    }
+  }
+  return {
+    mutations: {
+      ...(list.graphql.isEnabled.create && {
+        [list.graphql.names.createMutationName]: createOne_,
+        [list.graphql.names.createManyMutationName]: createMany_
+      }),
+      ...(list.graphql.isEnabled.update && {
+        [list.graphql.names.updateMutationName]: updateOne_,
+        [list.graphql.names.updateManyMutationName]: updateMany_
+      }),
+      ...(list.graphql.isEnabled.delete && {
+        [list.graphql.names.deleteMutationName]: deleteOne_,
+        [list.graphql.names.deleteManyMutationName]: deleteMany_
+      }),
+      ...Object.fromEntries(function* () {
+        for (const action of list.actions) {
+          yield [action.graphql.names.one, g.field({
+            type: list.graphql.types.output,
+            args: {
+              where: g.arg({
+                type: g.nonNull(list.graphql.types.uniqueWhere),
+                defaultValue: defaultUniqueWhereInput
+              }),
+              ...action.graphql.types.arguments
+            },
+            async resolve(_, {
+              where,
+              ...args
+            }, context, info) {
+              return await withSpan(`mutation ${info.fieldName}`, async () => {
+                return actionOne({
+                  where,
+                  args
+                }, list, context, action);
+              }, {
+                'nixxie.list': list.listKey,
+                'nixxie.action': action.actionKey
+              });
+            }
+          })];
+          yield [action.graphql.names.many, g.field({
+            type: g.list(list.graphql.types.output),
+            args: {
+              data: g.arg({
+                type: g.nonNull(g.list(g.nonNull(action.graphql.types.args)))
+              })
+            },
+            async resolve(_, {
+              data
+            }, context, info) {
+              return await withSpan(`mutation ${info.fieldName}`, async () => {
+                return promisesButSettledWhenAllSettledAndInOrder(await actionMany(data, list, context, action));
+              }, {
+                'nixxie.list': list.listKey,
+                'nixxie.action': action.actionKey,
+                'nixxie.many': true
+              });
+            }
+          })];
+        }
+      }())
+    },
+    types: collectedTypes
+  };
+}
+
+function getQueriesForList(list) {
+  if (!list.graphql.isEnabled.query) return {};
+  const findOne$1 = g.field({
+    type: list.graphql.types.output,
+    args: {
+      where: g.arg({
+        type: g.nonNull(list.graphql.types.uniqueWhere),
+        defaultValue: list.isSingleton ? {
+          id: '1'
+        } : undefined
+      })
+    },
+    async resolve(_, args, context, info) {
+      return await withSpan(`query ${info.fieldName}`, async () => {
+        return findOne(args, list, context, info);
+      }, {
+        'nixxie.list': list.listKey
+      });
+    }
+  });
+  const findMany$1 = g.field({
+    type: g.list(g.nonNull(list.graphql.types.output)),
+    args: list.graphql.types.findManyArgs,
+    async resolve(_, args, context, info) {
+      return await withSpan(`query ${info.fieldName}`, async () => {
+        return findMany(args, list, context, info);
+      }, {
+        'nixxie.list': list.listKey
+      });
+    }
+  });
+  const countQuery = g.field({
+    type: g.Int,
+    args: {
+      where: g.arg({
+        type: g.nonNull(list.graphql.types.where),
+        defaultValue: list.isSingleton ? {
+          id: {
+            equals: '1'
+          }
+        } : {}
+      })
+    },
+    async resolve(_, args, context, info) {
+      return await withSpan(`query ${info.fieldName}`, async () => {
+        return count(args, list, context, info);
+      }, {
+        'nixxie.list': list.listKey
+      });
+    }
+  });
+  return {
+    [list.graphql.names.itemQueryName]: findOne$1,
+    [list.graphql.names.listQueryName]: findMany$1,
+    [list.graphql.names.listQueryCountName]: countQuery
+  };
+}
+
+function getGraphQLSchema(lists, extraFields, sudo) {
+  const query = g.object()({
+    name: 'Query',
+    fields: Object.assign({}, ...Object.values(lists).map(list => getQueriesForList(list)), extraFields.query)
+  });
+  const collectedTypes = [];
+  const mutation = g.object()({
+    name: 'Mutation',
+    fields: Object.assign({}, ...Object.values(lists).map(list => {
+      const {
+        mutations,
+        types
+      } = getMutationsForList(list);
+      collectedTypes.push(...types);
+      return mutations;
+    }), extraFields.mutation)
+  });
+  return new GraphQLSchema({
+    query,
+    mutation,
+    types: [...collectedTypes, g.JSON, mutation],
+    extensions: {
+      sudo
+    }
+  });
+}
+function createGraphQLSchema(config, lists, adminMeta, sudo) {
+  var _config$graphql$exten, _config$graphql, _config$graphql$exten2;
+  const graphQLSchema = getGraphQLSchema(lists, {
+    mutation: {},
+    query: adminMeta ? {
+      nixxie: g.field({
+        type: g.nonNull(NixxieMeta),
+        resolve: () => ({
+          adminMeta
+        })
+      })
+    } : {}
+  }, sudo);
+
+  // merge in the user defined graphQL API
+  return (_config$graphql$exten = (_config$graphql = config.graphql) === null || _config$graphql === void 0 || (_config$graphql$exten2 = _config$graphql.extendGraphqlSchema) === null || _config$graphql$exten2 === void 0 ? void 0 : _config$graphql$exten2.call(_config$graphql, graphQLSchema)) !== null && _config$graphql$exten !== void 0 ? _config$graphql$exten : graphQLSchema;
+}
+
+// TODO: this cannot be changed for now, circular dependency with getSystemPaths, getEsbuildConfig
+function getBuiltNixxieConfigurationPath(cwd) {
+  return path.join(cwd, '.nixxie/config.js');
+}
+function posixify(s) {
+  return s.split(path.sep).join('/');
+}
+function getSystemPaths(cwd, config) {
+  var _config$types, _config$db, _config$graphql;
+  const prismaClientPath = config.db.prismaClientPath === '@prisma/client' ? null : config.db.prismaClientPath ? path.join(cwd, config.db.prismaClientPath) : null;
+  const builtTypesPath = (_config$types = config.types) !== null && _config$types !== void 0 && _config$types.path ? path.join(cwd, config.types.path) // TODO: enforce initConfig before getSystemPaths
+  : path.join(cwd, 'node_modules/.nixxie/types.ts');
+  const builtPrismaPath = (_config$db = config.db) !== null && _config$db !== void 0 && _config$db.prismaSchemaPath ? path.join(cwd, config.db.prismaSchemaPath) // TODO: enforce initConfig before getSystemPaths
+  : path.join(cwd, 'schema.prisma');
+  const relativePrismaPath = prismaClientPath ? `./${posixify(path.relative(path.dirname(builtTypesPath), prismaClientPath))}` : '@prisma/client';
+  const builtGraphqlPath = (_config$graphql = config.graphql) !== null && _config$graphql !== void 0 && _config$graphql.schemaPath ? path.join(cwd, config.graphql.schemaPath) // TODO: enforce initConfig before getSystemPaths
+  : path.join(cwd, 'schema.graphql');
+  return {
+    config: getBuiltNixxieConfigurationPath(cwd),
+    admin: path.join(cwd, '.nixxie/admin'),
+    prisma: prismaClientPath !== null && prismaClientPath !== void 0 ? prismaClientPath : '@prisma/client',
+    types: {
+      relativePrismaPath
+    },
+    schema: {
+      types: builtTypesPath,
+      prisma: builtPrismaPath,
+      graphql: builtGraphqlPath
+    }
+  };
+}
+function getInternalGraphQLSchema(config) {
+  // omit `graphql.omit`
+  const withoutOmit = {
+    ...config,
+    lists: Object.fromEntries(Object.entries(config.lists).map(([listKey, list]) => {
+      return [listKey, {
+        ...list,
+        graphql: {
+          ...(list.graphql || {}),
+          omit: false
+        },
+        fields: Object.fromEntries(Object.entries(list.fields).map(([fieldKey, field]) => {
+          if (fieldKey.startsWith('__group')) return [fieldKey, field];
+          return [fieldKey, data => {
+            const f = field(data);
+            return {
+              ...f,
+              graphql: {
+                ...(f.graphql || {}),
+                omit: false
+              },
+              // WARNING: this bypasses access control checks for filtering and ordering on the internal schema
+              isFilterable: true,
+              // TODO: remove when moved to .access.filter and .omit.filter
+              isOrderable: true // TODO: remove when moved to .access.filter and .omit.filter
+            };
+          }];
+        }))
+      }];
+    }))
+  };
+  const lists = initialiseLists(withoutOmit);
+  const adminMeta = createAdminMeta(withoutOmit, lists);
+  return createGraphQLSchema(withoutOmit, lists, adminMeta, true);
+}
+function injectNewDefaults(prismaClient, lists) {
+  for (const listKey in lists) {
+    var _dbField$default;
+    const list = lists[listKey];
+
+    // TODO: other fields might use 'random' too
+    const {
+      dbField
+    } = list.fields.id;
+    if ('default' in dbField && ((_dbField$default = dbField.default) === null || _dbField$default === void 0 ? void 0 : _dbField$default.kind) === 'random') {
+      const {
+        bytes,
+        encoding
+      } = dbField.default;
+      prismaClient = prismaClient.$extends({
+        query: {
+          [list.prisma.listKey]: {
+            async create({
+              args,
+              query
+            }) {
+              var _args$data$id;
+              return query({
+                ...args,
+                data: {
+                  ...args.data,
+                  id: (_args$data$id = args.data.id) !== null && _args$data$id !== void 0 ? _args$data$id : randomBytes(bytes).toString(encoding)
+                }
+              });
+            }
+          }
+        }
+      });
+    }
+  }
+  return prismaClient;
+}
+function formatUrl(provider, url) {
+  if (url.startsWith('file:')) {
+    const parsed = new URL(url);
+    if (provider === 'sqlite' && !parsed.searchParams.get('connection_limit')) {
+      // https://github.com/prisma/prisma/issues/9562
+      // https://github.com/prisma/prisma/issues/10403
+      // https://github.com/prisma/prisma/issues/11789
+      parsed.searchParams.set('connection_limit', '1');
+      const [uri] = url.split('?');
+      return `${uri}?${parsed.search}`;
+    }
+  }
+  return url;
+}
+function createSystem(config) {
+  const lists = initialiseLists(config);
+  const adminMeta = createAdminMeta(config, lists);
+  const graphQLSchemas = {
+    public: createGraphQLSchema(config, lists, adminMeta, false),
+    internal: getInternalGraphQLSchema(config)
+  };
+  return {
+    config,
+    graphql: {
+      schemas: graphQLSchemas
+    },
+    adminMeta,
+    lists,
+    getPaths: cwd => getSystemPaths(cwd, config),
+    getNixxie: PM => {
+      const prePrismaClient = new PM.PrismaClient({
+        datasourceUrl: formatUrl(config.db.provider, config.db.url),
+        log: config.db.enableLogging
+      });
+      const prismaClient = config.db.extendPrismaClient(injectNewDefaults(prePrismaClient, lists));
+      const context = createContext({
+        config,
+        lists,
+        graphQLSchemas,
+        prismaClient,
+        prismaTypes: {
+          DbNull: PM.Prisma.DbNull,
+          JsonNull: PM.Prisma.JsonNull
+        }
+      });
+      return {
+        // TODO: replace with server.onStart, remove in breaking change
+        async connect() {
+          var _config$db$onConnect, _config$db2;
+          await prismaClient.$connect();
+          await ((_config$db$onConnect = (_config$db2 = config.db).onConnect) === null || _config$db$onConnect === void 0 ? void 0 : _config$db$onConnect.call(_config$db2, context));
+        },
+        // TODO: only used by tests, remove in breaking change
+        async disconnect() {
+          await prismaClient.$disconnect();
+        },
+        context
+      };
+    }
+  };
+}
+function getContext(config, PrismaModule) {
+  const system = createSystem(config);
+  const {
+    context
+  } = system.getNixxie(PrismaModule);
+  return context;
+}
+
+export { getBuiltNixxieConfigurationPath as a, createSystem as c, getContext as g, withSpan as w };