@directus/api 25.0.1 → 26.0.1

package/dist/services/graphql/resolvers/system.js

@@ -1,11 +1,10 @@
 import { useEnv } from '@directus/env';
 import { toBoolean } from '@directus/utils';
 import { GraphQLBoolean, GraphQLEnumType, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, } from 'graphql';
-import { GraphQLJSON, ObjectTypeComposer, SchemaComposer, toInputObjectType } from 'graphql-compose';
+import { GraphQLJSON, SchemaComposer, toInputObjectType } from 'graphql-compose';
 import getDatabase from '../../../database/index.js';
 import { fetchAccountabilityCollectionAccess } from '../../../permissions/modules/fetch-accountability-collection-access/fetch-accountability-collection-access.js';
 import { fetchAccountabilityPolicyGlobals } from '../../../permissions/modules/fetch-accountability-policy-globals/fetch-accountability-policy-globals.js';
-import { getGraphQLType } from '../../../utils/get-graphql-type.js';
 import { CollectionsService } from '../../collections.js';
 import { FieldsService } from '../../fields.js';
 import { FilesService } from '../../files.js';
@@ -18,6 +17,9 @@ import { GraphQLService } from '../index.js';
 import { generateSchema } from '../schema/index.js';
 import { getQuery } from '../schema/parse-query.js';
 import { replaceFragmentsInSelections } from '../utils/replace-fragments.js';
+import { getCollectionType } from './get-collection-type.js';
+import { getFieldType } from './get-field-type.js';
+import { getRelationType } from './get-relation-type.js';
 import { resolveSystemAdmin } from './system-admin.js';
 import { globalResolvers } from './system-global.js';
 const env = useEnv();
@@ -187,47 +189,8 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
             },
         },
     });
-    const Collection = schemaComposer.createObjectTC({
-        name: 'directus_collections',
-    });
-    const Field = schemaComposer.createObjectTC({
-        name: 'directus_fields',
-    });
-    const Relation = schemaComposer.createObjectTC({
-        name: 'directus_relations',
-    });
-    const Extension = schemaComposer.createObjectTC({
-        name: 'directus_extensions',
-    });
-    const composers = {
-        Collection,
-        Field,
-        Relation,
-        Extension,
-    };
     if ('directus_collections' in schema.read.collections) {
-        Collection.addFields({
-            collection: GraphQLString,
-            meta: schemaComposer.createObjectTC({
-                name: 'directus_collections_meta',
-                fields: Object.values(schema.read.collections['directus_collections'].fields).reduce((acc, field) => {
-                    acc[field.field] = {
-                        type: field.nullable
-                            ? getGraphQLType(field.type, field.special)
-                            : new GraphQLNonNull(getGraphQLType(field.type, field.special)),
-                        description: field.note,
-                    };
-                    return acc;
-                }, {}),
-            }),
-            schema: schemaComposer.createObjectTC({
-                name: 'directus_collections_schema',
-                fields: {
-                    name: GraphQLString,
-                    comment: GraphQLString,
-                },
-            }),
-        });
+        const Collection = getCollectionType(schemaComposer, schema, 'read');
         schemaComposer.Query.addFields({
             collections: {
                 type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(Collection.getType()))),
@@ -255,45 +218,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
         });
     }
     if ('directus_fields' in schema.read.collections) {
-        Field.addFields({
-            collection: GraphQLString,
-            field: GraphQLString,
-            type: GraphQLString,
-            meta: schemaComposer.createObjectTC({
-                name: 'directus_fields_meta',
-                fields: Object.values(schema.read.collections['directus_fields'].fields).reduce((acc, field) => {
-                    acc[field.field] = {
-                        type: field.nullable
-                            ? getGraphQLType(field.type, field.special)
-                            : new GraphQLNonNull(getGraphQLType(field.type, field.special)),
-                        description: field.note,
-                    };
-                    return acc;
-                }, {}),
-            }),
-            schema: schemaComposer.createObjectTC({
-                name: 'directus_fields_schema',
-                fields: {
-                    name: GraphQLString,
-                    table: GraphQLString,
-                    data_type: GraphQLString,
-                    default_value: GraphQLString,
-                    max_length: GraphQLInt,
-                    numeric_precision: GraphQLInt,
-                    numeric_scale: GraphQLInt,
-                    is_generated: GraphQLBoolean,
-                    generation_expression: GraphQLString,
-                    is_indexed: GraphQLBoolean,
-                    is_nullable: GraphQLBoolean,
-                    is_unique: GraphQLBoolean,
-                    is_primary_key: GraphQLBoolean,
-                    has_auto_increment: GraphQLBoolean,
-                    foreign_key_column: GraphQLString,
-                    foreign_key_table: GraphQLString,
-                    comment: GraphQLString,
-                },
-            }),
-        });
+        const Field = getFieldType(schemaComposer, schema, 'read');
         schemaComposer.Query.addFields({
             fields: {
                 type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(Field.getType()))),
@@ -335,33 +260,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
         });
     }
     if ('directus_relations' in schema.read.collections) {
-        Relation.addFields({
-            collection: GraphQLString,
-            field: GraphQLString,
-            related_collection: GraphQLString,
-            schema: schemaComposer.createObjectTC({
-                name: 'directus_relations_schema',
-                fields: {
-                    table: new GraphQLNonNull(GraphQLString),
-                    column: new GraphQLNonNull(GraphQLString),
-                    foreign_key_table: new GraphQLNonNull(GraphQLString),
-                    foreign_key_column: new GraphQLNonNull(GraphQLString),
-                    constraint_name: GraphQLString,
-                    on_update: new GraphQLNonNull(GraphQLString),
-                    on_delete: new GraphQLNonNull(GraphQLString),
-                },
-            }),
-            meta: schemaComposer.createObjectTC({
-                name: 'directus_relations_meta',
-                fields: Object.values(schema.read.collections['directus_relations'].fields).reduce((acc, field) => {
-                    acc[field.field] = {
-                        type: getGraphQLType(field.type, field.special),
-                        description: field.note,
-                    };
-                    return acc;
-                }, {}),
-            }),
-        });
+        const Relation = getRelationType(schemaComposer, schema, 'read');
         schemaComposer.Query.addFields({
             relations: {
                 type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(Relation.getType()))),
@@ -402,7 +301,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
             },
         });
     }
-    resolveSystemAdmin(gql, schemaComposer, composers);
+    resolveSystemAdmin(gql, schema, schemaComposer);
     if ('directus_users' in schema.read.collections) {
         schemaComposer.Query.addFields({
             users_me: {
@@ -412,7 +311,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
                         return null;
                     const service = new UsersService({ schema: gql.schema, accountability: gql.accountability });
                     const selections = replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
-                    const query = getQuery(args, selections || [], info.variableValues, gql.accountability);
+                    const query = await getQuery(args, selections || [], info.variableValues, gql.schema, gql.accountability);
                     return await service.readOne(gql.accountability.user, query);
                 },
             },
@@ -450,7 +349,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
                         schema: gql.schema,
                     });
                     const selections = replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
-                    const query = getQuery(args, selections || [], info.variableValues, gql.accountability);
+                    const query = await getQuery(args, selections || [], info.variableValues, gql.schema, gql.accountability);
                     query.limit = -1;
                     const roles = await service.readMany(gql.accountability.roles, query);
                     return roles;
@@ -498,7 +397,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
                     await service.updateOne(gql.accountability.user, args['data']);
                     if ('directus_users' in ReadCollectionTypes) {
                         const selections = replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
-                        const query = getQuery(args, selections || [], info.variableValues, gql.accountability);
+                        const query = await getQuery(args, selections || [], info.variableValues, gql.schema, gql.accountability);
                         return await service.readOne(gql.accountability.user, query);
                     }
                     return true;
@@ -522,7 +421,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
                     const primaryKey = await service.importOne(args['url'], args['data']);
                     if ('directus_files' in ReadCollectionTypes) {
                         const selections = replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
-                        const query = getQuery(args, selections || [], info.variableValues, gql.accountability);
+                        const query = await getQuery(args, selections || [], info.variableValues, gql.schema, gql.accountability);
                         return await service.readOne(primaryKey, query);
                     }
                     return true;

package/dist/services/graphql/schema/index.js

@@ -89,7 +89,7 @@ export async function generateSchema(gql, type = 'schema') {
                 action: 'delete',
             }, { schema: gql.schema, knex: gql.knex }),
         };
-        const { ReadCollectionTypes, VersionCollectionTypes } = getReadableTypes(gql, schemaComposer, schema, inconsistentFields);
+        const { ReadCollectionTypes, VersionCollectionTypes } = await getReadableTypes(gql, schemaComposer, schema, inconsistentFields);
         const { CreateCollectionTypes, UpdateCollectionTypes, DeleteCollectionTypes } = getWritableTypes(gql, schemaComposer, schema, inconsistentFields, ReadCollectionTypes);
         const CollectionTypes = {
             CreateCollectionTypes,

package/dist/services/graphql/schema/parse-query.d.ts

@@ -1,7 +1,7 @@
-import type { Accountability, Query } from '@directus/types';
+import type { Accountability, Query, SchemaOverview } from '@directus/types';
 import type { GraphQLResolveInfo, SelectionNode } from 'graphql';
 /**
  * Get a Directus Query object from the parsed arguments (rawQuery) and GraphQL AST selectionSet. Converts SelectionSet into
  * Directus' `fields` query for use in the resolver. Also applies variables where appropriate.
  */
-export declare function getQuery(rawQuery: Query, selections: readonly SelectionNode[], variableValues: GraphQLResolveInfo['variableValues'], accountability?: Accountability | null): Query;
+export declare function getQuery(rawQuery: Query, selections: readonly SelectionNode[], variableValues: GraphQLResolveInfo['variableValues'], schema: SchemaOverview, accountability?: Accountability | null): Promise<Query>;

package/dist/services/graphql/schema/parse-query.js

@@ -7,8 +7,8 @@ import { parseArgs } from './parse-args.js';
  * Get a Directus Query object from the parsed arguments (rawQuery) and GraphQL AST selectionSet. Converts SelectionSet into
  * Directus' `fields` query for use in the resolver. Also applies variables where appropriate.
  */
-export function getQuery(rawQuery, selections, variableValues, accountability) {
-    const query = sanitizeQuery(rawQuery, accountability);
+export async function getQuery(rawQuery, selections, variableValues, schema, accountability) {
+    const query = await sanitizeQuery(rawQuery, schema, accountability);
     const parseAliases = (selections) => {
         const aliases = {};
         for (const selection of selections) {
@@ -20,7 +20,7 @@ export function getQuery(rawQuery, selections, variableValues, accountability) {
         }
         return aliases;
     };
-    const parseFields = (selections, parent) => {
+    const parseFields = async (selections, parent) => {
         const fields = [];
         for (let selection of selections) {
             if ((selection.kind === 'Field' || selection.kind === 'InlineFragment') !== true)
@@ -70,7 +70,7 @@ export function getQuery(rawQuery, selections, variableValues, accountability) {
                     }
                 }
                 else {
-                    children = parseFields(selection.selectionSet.selections, currentAlias ?? current);
+                    children = await parseFields(selection.selectionSet.selections, currentAlias ?? current);
                 }
                 fields.push(...children);
             }
@@ -82,14 +82,14 @@ export function getQuery(rawQuery, selections, variableValues, accountability) {
                     if (!query.deep)
                         query.deep = {};
                     const args = parseArgs(selection.arguments, variableValues);
-                    set(query.deep, currentAlias ?? current, merge({}, get(query.deep, currentAlias ?? current), mapKeys(sanitizeQuery(args, accountability), (_value, key) => `_${key}`)));
+                    set(query.deep, currentAlias ?? current, merge({}, get(query.deep, currentAlias ?? current), mapKeys(await sanitizeQuery(args, schema, accountability), (_value, key) => `_${key}`)));
                 }
             }
         }
         return uniq(fields);
     };
     query.alias = parseAliases(selections);
-    query.fields = parseFields(selections);
+    query.fields = await parseFields(selections);
     if (query.filter)
         query.filter = replaceFuncs(query.filter);
     query.deep = replaceFuncs(query.deep);

package/dist/services/graphql/schema/read.d.ts

@@ -5,8 +5,8 @@ import { type InconsistentFields, type Schema } from './index.js';
 /**
  * Create readable types and attach resolvers for each. Also prepares full filter argument structures
  */
-export declare function getReadableTypes(gql: GraphQLService, schemaComposer: SchemaComposer, schema: Schema, inconsistentFields: InconsistentFields): {
+export declare function getReadableTypes(gql: GraphQLService, schemaComposer: SchemaComposer, schema: Schema, inconsistentFields: InconsistentFields): Promise<{
     ReadCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
     VersionCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
     ReadableCollectionFilterTypes: Record<string, InputTypeComposer<any>>;
-};
+}>;

package/dist/services/graphql/schema/read.js

@@ -14,12 +14,75 @@ import { getTypes } from './get-types.js';
 /**
  * Create readable types and attach resolvers for each. Also prepares full filter argument structures
  */
-export function getReadableTypes(gql, schemaComposer, schema, inconsistentFields) {
+export async function getReadableTypes(gql, schemaComposer, schema, inconsistentFields) {
     const { CollectionTypes: ReadCollectionTypes, VersionTypes: VersionCollectionTypes } = getTypes(schemaComposer, gql.scope, schema, inconsistentFields, 'read');
     const ReadableCollectionFilterTypes = {};
+    const ReadableCollectionQuantifierFilterTypes = {};
     const AggregatedFunctions = {};
     const AggregatedFields = {};
     const AggregateMethods = {};
+    const IDFilterOperators = schemaComposer.createInputTC({
+        name: 'id_filter_operators',
+        fields: {
+            _eq: {
+                type: GraphQLID,
+            },
+            _neq: {
+                type: GraphQLID,
+            },
+            _contains: {
+                type: GraphQLID,
+            },
+            _icontains: {
+                type: GraphQLID,
+            },
+            _ncontains: {
+                type: GraphQLID,
+            },
+            _starts_with: {
+                type: GraphQLID,
+            },
+            _nstarts_with: {
+                type: GraphQLID,
+            },
+            _istarts_with: {
+                type: GraphQLID,
+            },
+            _nistarts_with: {
+                type: GraphQLID,
+            },
+            _ends_with: {
+                type: GraphQLID,
+            },
+            _nends_with: {
+                type: GraphQLID,
+            },
+            _iends_with: {
+                type: GraphQLID,
+            },
+            _niends_with: {
+                type: GraphQLID,
+            },
+            _in: {
+                type: new GraphQLList(GraphQLID),
+            },
+            _nin: {
+                type: new GraphQLList(GraphQLID),
+            },
+            _null: {
+                type: GraphQLBoolean,
+            },
+            _nnull: {
+                type: GraphQLBoolean,
+            },
+            _empty: {
+                type: GraphQLBoolean,
+            },
+            _nempty: {
+                type: GraphQLBoolean,
+            },
+        },
+    });
     const StringFilterOperators = schemaComposer.createInputTC({
         name: 'string_filter_operators',
         fields: {
@@ -356,6 +419,9 @@ export function getReadableTypes(gql, schemaComposer, schema, inconsistentFields
                     case GraphQLHash:
                         filterOperatorType = HashFilterOperators;
                         break;
+                    case GraphQLID:
+                        filterOperatorType = IDFilterOperators;
+                        break;
                     default:
                         filterOperatorType = StringFilterOperators;
                 }
@@ -591,10 +657,21 @@ export function getReadableTypes(gql, schemaComposer, schema, inconsistentFields
             });
         }
     }
+    for (const collection in ReadableCollectionFilterTypes) {
+        const quantifier_collection = ReadableCollectionFilterTypes[collection]?.clone(`${collection}_quantifier_filter`);
+        quantifier_collection?.addFields({
+            _some: ReadableCollectionFilterTypes[collection],
+            _none: ReadableCollectionFilterTypes[collection],
+        });
+        ReadableCollectionQuantifierFilterTypes[collection] = quantifier_collection;
+    }
     for (const relation of schema.read.relations) {
         if (relation.related_collection) {
             if (SYSTEM_DENY_LIST.includes(relation.related_collection))
                 continue;
+            ReadableCollectionQuantifierFilterTypes[relation.collection]?.addFields({
+                [relation.field]: ReadableCollectionFilterTypes[relation.related_collection],
+            });
             ReadableCollectionFilterTypes[relation.collection]?.addFields({
                 [relation.field]: ReadableCollectionFilterTypes[relation.related_collection],
             });
@@ -617,8 +694,11 @@ export function getReadableTypes(gql, schemaComposer, schema, inconsistentFields
                 },
             });
             if (relation.meta?.one_field) {
+                ReadableCollectionQuantifierFilterTypes[relation.related_collection]?.addFields({
+                    [relation.meta.one_field]: ReadableCollectionQuantifierFilterTypes[relation.collection],
+                });
                 ReadableCollectionFilterTypes[relation.related_collection]?.addFields({
-                    [relation.meta.one_field]: ReadableCollectionFilterTypes[relation.collection],
+                    [relation.meta.one_field]: ReadableCollectionQuantifierFilterTypes[relation.collection],
                 });
                 ReadCollectionTypes[relation.related_collection]?.addFieldArgs(relation.meta.one_field, {
                     filter: ReadableCollectionFilterTypes[relation.collection],
@@ -641,8 +721,12 @@ export function getReadableTypes(gql, schemaComposer, schema, inconsistentFields
             }
         }
         else if (relation.meta?.one_allowed_collections) {
+            ReadableCollectionQuantifierFilterTypes[relation.collection]?.removeField('item');
             ReadableCollectionFilterTypes[relation.collection]?.removeField('item');
             for (const collection of relation.meta.one_allowed_collections) {
+                ReadableCollectionQuantifierFilterTypes[relation.collection]?.addFields({
+                    [`item__${collection}`]: ReadableCollectionFilterTypes[collection],
+                });
                 ReadableCollectionFilterTypes[relation.collection]?.addFields({
                     [`item__${collection}`]: ReadableCollectionFilterTypes[collection],
                 });

package/dist/services/graphql/schema-cache.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLSchema } from 'graphql';
-import LRUMapDefault from 'mnemonist/lru-map.js';
-export declare const cache: LRUMapDefault.default<string, string | GraphQLSchema>;
+import { LRUMap } from 'mnemonist';
+export declare const cache: LRUMap<string, string | GraphQLSchema>;

package/dist/services/graphql/schema-cache.js

@@ -1,9 +1,7 @@
 import { useEnv } from '@directus/env';
 import { GraphQLSchema } from 'graphql';
-import LRUMapDefault from 'mnemonist/lru-map.js';
+import { LRUMap } from 'mnemonist';
 import { useBus } from '../../bus/index.js';
-// Workaround for misaligned types in mnemonist package exports
-const LRUMap = LRUMapDefault;
 const env = useEnv();
 const bus = useBus();
 export const cache = new LRUMap(Number(env['GRAPHQL_SCHEMA_CACHE_CAPACITY'] ?? 100));

package/dist/services/graphql/subscription.d.ts

@@ -2,19 +2,19 @@ import type { GraphQLService } from './index.js';
 import type { GraphQLResolveInfo } from 'graphql';
 export declare function bindPubSub(): void;
 export declare function createSubscriptionGenerator(gql: GraphQLService, event: string): (_x: unknown, _y: unknown, _z: unknown, request: GraphQLResolveInfo) => AsyncGenerator<{
-    [x: string]: {
+    [event]: {
         key: string | number;
         data: null;
         event: "delete";
     };
 } | {
-    [x: string]: {
+    [event]: {
         key: string | number;
         data: any;
         event: "create";
     };
 } | {
-    [x: string]: {
+    [event]: {
         key: string | number;
         data: any;
         event: "update";

package/dist/services/graphql/subscription.js

@@ -12,7 +12,7 @@ export function bindPubSub() {
 }
 export function createSubscriptionGenerator(gql, event) {
     return async function* (_x, _y, _z, request) {
-        const fields = parseFields(gql, request);
+        const fields = await parseFields(gql, request);
         const args = parseArguments(request);
         for await (const payload of messages.subscribe(event)) {
             const eventData = payload;
@@ -79,7 +79,7 @@ function createPubSub(emitter) {
         },
     };
 }
-function parseFields(gql, request) {
+async function parseFields(gql, request) {
     const selections = request.fieldNodes[0]?.selectionSet?.selections ?? [];
     const dataSelections = selections.reduce((result, selection) => {
         if (selection.kind === 'Field' &&
@@ -89,7 +89,7 @@ function parseFields(gql, request) {
         }
         return result;
     }, []);
-    const { fields } = getQuery({}, dataSelections, request.variableValues, gql.accountability);
+    const { fields } = await getQuery({}, dataSelections, request.variableValues, gql.schema, gql.accountability);
     return fields ?? [];
 }
 function parseArguments(request) {

package/dist/services/graphql/utils/{aggrgate-query.d.ts → aggregate-query.d.ts}

@@ -1,6 +1,6 @@
-import type { Accountability, Query } from '@directus/types';
+import type { Accountability, Query, SchemaOverview } from '@directus/types';
 import type { SelectionNode } from 'graphql';
 /**
  * Resolve the aggregation query based on the requested aggregated fields
  */
-export declare function getAggregateQuery(rawQuery: Query, selections: readonly SelectionNode[], accountability?: Accountability | null): Query;
+export declare function getAggregateQuery(rawQuery: Query, selections: readonly SelectionNode[], schema: SchemaOverview, accountability?: Accountability | null): Promise<Query>;

package/dist/services/graphql/utils/{aggrgate-query.js → aggregate-query.js}

@@ -1,11 +1,11 @@
-import { replaceFuncs } from './replace-funcs.js';
 import { sanitizeQuery } from '../../../utils/sanitize-query.js';
 import { validateQuery } from '../../../utils/validate-query.js';
+import { replaceFuncs } from './replace-funcs.js';
 /**
  * Resolve the aggregation query based on the requested aggregated fields
  */
-export function getAggregateQuery(rawQuery, selections, accountability) {
-    const query = sanitizeQuery(rawQuery, accountability);
+export async function getAggregateQuery(rawQuery, selections, schema, accountability) {
+    const query = await sanitizeQuery(rawQuery, schema, accountability);
     query.aggregate = {};
     for (let aggregationGroup of selections) {
         if ((aggregationGroup.kind === 'Field') !== true)

package/dist/services/items.d.ts

@@ -18,6 +18,7 @@ export declare class ItemsService<Item extends AnyItem = AnyItem, Collection ext
     eventScope: string;
     schema: SchemaOverview;
     cache: Keyv<any> | null;
+    nested: string[];
     constructor(collection: Collection, options: AbstractServiceOptions);
     /**
      * Create a fork of the current service, allowing instantiation with different options.

package/dist/services/items.js

@@ -26,6 +26,7 @@ export class ItemsService {
     eventScope;
     schema;
     cache;
+    nested;
     constructor(collection, options) {
         this.collection = collection;
         this.knex = options.knex || getDatabase();
@@ -33,6 +34,7 @@ export class ItemsService {
         this.eventScope = isSystemCollection(this.collection) ? this.collection.substring(9) : 'items';
         this.schema = options.schema;
         this.cache = getCache().cache;
+        this.nested = options.nested ?? [];
         return this;
     }
     /**
@@ -43,7 +45,13 @@ export class ItemsService {
         // ItemsService expects `collection` and `options` as parameters,
         // while the other services only expect `options`
         const isItemsService = Service.length === 2;
-        const newOptions = { knex: this.knex, accountability: this.accountability, schema: this.schema, ...options };
+        const newOptions = {
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+            nested: this.nested,
+            ...options,
+        };
         if (isItemsService) {
             return new ItemsService(this.collection, newOptions);
         }
@@ -95,19 +103,15 @@ export class ItemsService {
             .filter((field) => field.alias === true)
             .map((field) => field.field);
         const payload = cloneDeep(data);
+        let actionHookPayload = payload;
         const nestedActionEvents = [];
-        // By wrapping the logic in a transaction, we make sure we automatically roll back all the
-        // changes in the DB if any of the parts contained within throws an error. This also means
-        // that any errors thrown in any nested relational changes will bubble up and cancel the whole
-        // update tree
+        /**
+         * By wrapping the logic in a transaction, we make sure we automatically roll back all the
+         * changes in the DB if any of the parts contained within throws an error. This also means
+         * that any errors thrown in any nested relational changes will bubble up and cancel the whole
+         * update tree
+         */
         const primaryKey = await transaction(this.knex, async (trx) => {
-            const serviceOptions = {
-                accountability: this.accountability,
-                knex: trx,
-                schema: this.schema,
-            };
-            // We're creating new services instances so they can use the transaction as their Knex interface
-            const payloadService = new PayloadService(this.collection, serviceOptions);
             // Run all hooks that are attached to this event so the end user has the chance to augment the
             // item that is about to be saved
             const payloadAfterHooks = opts.emitEvents !== false
@@ -127,6 +131,7 @@ export class ItemsService {
                     action: 'create',
                     collection: this.collection,
                     payload: payloadAfterHooks,
+                    nested: this.nested,
                 }, {
                     knex: trx,
                     schema: this.schema,
@@ -135,6 +140,15 @@ export class ItemsService {
             if (opts.preMutationError) {
                 throw opts.preMutationError;
             }
+            // Ensure the action hook payload has the post filter hook + preset changes
+            actionHookPayload = payloadWithPresets;
+            // We're creating new services instances so they can use the transaction as their Knex interface
+            const payloadService = new PayloadService(this.collection, {
+                accountability: this.accountability,
+                knex: trx,
+                schema: this.schema,
+                nested: this.nested,
+            });
             const { payload: payloadWithM2O, revisions: revisionsM2O, nestedActionEvents: nestedActionEventsM2O, userIntegrityCheckFlags: userIntegrityCheckFlagsM2O, } = await payloadService.processM2O(payloadWithPresets, opts);
             const { payload: payloadWithA2O, revisions: revisionsA2O, nestedActionEvents: nestedActionEventsA2O, userIntegrityCheckFlags: userIntegrityCheckFlagsA2O, } = await payloadService.processA2O(payloadWithM2O, opts);
             const payloadWithoutAliases = pick(payloadWithA2O, without(fields, ...aliases));
@@ -190,7 +204,7 @@ export class ItemsService {
                 primaryKey = result.id;
                 // Set the primary key on the input item, in order for the "after" event hook to be able
                 // to read from it
-                payload[primaryKeyField] = primaryKey;
+                actionHookPayload[primaryKeyField] = primaryKey;
             }
             // At this point, the primary key is guaranteed to be set.
             primaryKey = primaryKey;
@@ -260,7 +274,7 @@ export class ItemsService {
                     ? ['items.create', `${this.collection}.items.create`]
                     : `${this.eventScope}.create`,
                 meta: {
-                    payload,
+                    payload: actionHookPayload,
                     key: primaryKey,
                     collection: this.collection,
                 },
@@ -450,8 +464,6 @@ export class ItemsService {
      * Uses `this.updateMany` under the hood.
      */
     async updateOne(key, data, opts) {
-        const primaryKeyField = this.schema.collections[this.collection].primary;
-        validateKeys(this.schema, this.collection, primaryKeyField, key);
         await this.updateMany([key], data, opts);
         return key;
     }
@@ -553,6 +565,7 @@ export class ItemsService {
                 action: 'update',
                 collection: this.collection,
                 payload: payloadAfterHooks,
+                nested: this.nested,
             }, {
                 knex: this.knex,
                 schema: this.schema,
@@ -566,6 +579,7 @@ export class ItemsService {
                 accountability: this.accountability,
                 knex: trx,
                 schema: this.schema,
+                nested: this.nested,
             });
             const { payload: payloadWithM2O, revisions: revisionsM2O, nestedActionEvents: nestedActionEventsM2O, userIntegrityCheckFlags: userIntegrityCheckFlagsM2O, } = await payloadService.processM2O(payloadWithPresets, opts);
             const { payload: payloadWithA2O, revisions: revisionsA2O, nestedActionEvents: nestedActionEventsA2O, userIntegrityCheckFlags: userIntegrityCheckFlagsA2O, } = await payloadService.processA2O(payloadWithM2O, opts);

package/dist/services/payload.d.ts

@@ -29,6 +29,7 @@ export declare class PayloadService {
     helpers: Helpers;
     collection: string;
     schema: SchemaOverview;
+    nested: string[];
     constructor(collection: string, options: AbstractServiceOptions);
     transformers: Transformers;
     processValues(action: Action, payloads: Partial<Item>[]): Promise<Partial<Item>[]>;