@directus/api 25.0.0 → 26.0.0

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/meta.js

@@ -33,9 +33,10 @@ export class MetaService {
         return this.filterCount(collection, {});
     }
     async filterCount(collection, query) {
+        const primaryKeyName = this.schema.collections[collection].primary;
         const aggregateQuery = {
             aggregate: {
-                count: ['*'],
+                countDistinct: [primaryKeyName],
             },
             search: query.search ?? null,
             filter: query.filter ?? null,
@@ -52,6 +53,7 @@ export class MetaService {
         const records = await runAst(ast, this.schema, this.accountability, {
             knex: this.knex,
         });
-        return Number((isArray(records) ? records[0]?.['count'] : records?.['count']) ?? 0);
+        return Number((isArray(records) ? records[0]?.['countDistinct'][primaryKeyName] : records?.['countDistinct'][primaryKeyName]) ??
+            0);
     }
 }

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>[]>;

package/dist/services/payload.js

@@ -20,12 +20,14 @@ export class PayloadService {
     helpers;
     collection;
     schema;
+    nested;
     constructor(collection, options) {
         this.accountability = options.accountability || null;
         this.knex = options.knex || getDatabase();
         this.helpers = getHelpers(this.knex);
         this.collection = collection;
         this.schema = options.schema;
+        this.nested = options.nested ?? [];
         return this;
     }
     transformers = {
@@ -346,6 +348,7 @@ export class PayloadService {
                 accountability: this.accountability,
                 knex: this.knex,
                 schema: this.schema,
+                nested: [...this.nested, relation.field],
             });
             const relatedPrimaryKeyField = this.schema.collections[relatedCollection].primary;
             const relatedRecord = payload[relation.field];
@@ -412,6 +415,7 @@ export class PayloadService {
                 accountability: this.accountability,
                 knex: this.knex,
                 schema: this.schema,
+                nested: [...this.nested, relation.field],
             });
             const relatedRecord = payload[relation.field];
             if (['string', 'number'].includes(typeof relatedRecord))
@@ -482,6 +486,7 @@ export class PayloadService {
                 accountability: this.accountability,
                 knex: this.knex,
                 schema: this.schema,
+                nested: [...this.nested, relation.meta.one_field],
             });
             const recordsToUpsert = [];
             const savedPrimaryKeys = [];
@@ -490,15 +495,23 @@ export class PayloadService {
             if (!field || Array.isArray(field)) {
                 const updates = field || []; // treat falsey values as removing all children
                 for (let i = 0; i < updates.length; i++) {
+                    const currentId = parent || payload[currentPrimaryKeyField];
                     const relatedRecord = updates[i];
+                    const relatedId = typeof relatedRecord === 'string' || typeof relatedRecord === 'number'
+                        ? relatedRecord
+                        : relatedRecord[relatedPrimaryKeyField];
                     let record = cloneDeep(relatedRecord);
-                    if (typeof relatedRecord === 'string' || typeof relatedRecord === 'number') {
-                        const existingRecord = await this.knex
+                    let existingRecord;
+                    // No relatedId means it's a new record
+                    if (relatedId) {
+                        existingRecord = await this.knex
                             .select(relatedPrimaryKeyField, relation.field)
                             .from(relation.collection)
-                            .where({ [relatedPrimaryKeyField]: record })
+                            .where({ [relatedPrimaryKeyField]: relatedId })
                             .first();
-                        if (!!existingRecord === false) {
+                    }
+                    if (typeof relatedRecord === 'string' || typeof relatedRecord === 'number') {
+                        if (!existingRecord) {
                             throw new ForbiddenError();
                         }
                         // If the related item is already associated to the current item, and there's no
@@ -507,9 +520,7 @@ export class PayloadService {
                         // for items that aren't actually being updated. NOTE: We use == here, as the
                         // primary key might be reported as a string instead of number, coming from the
                         // http route, and or a bigInteger in the DB
-                        if (isNil(existingRecord[relation.field]) === false &&
-                            (existingRecord[relation.field] == parent ||
-                                existingRecord[relation.field] == payload[currentPrimaryKeyField])) {
+                        if (isNil(existingRecord[relation.field]) === false && existingRecord[relation.field] == currentId) {
                             savedPrimaryKeys.push(existingRecord[relatedPrimaryKeyField]);
                             continue;
                         }
@@ -517,10 +528,10 @@ export class PayloadService {
                             [relatedPrimaryKeyField]: relatedRecord,
                         };
                     }
-                    recordsToUpsert.push({
-                        ...record,
-                        [relation.field]: parent || payload[currentPrimaryKeyField],
-                    });
+                    if (!existingRecord || existingRecord[relation.field] != parent) {
+                        record[relation.field] = currentId;
+                    }
+                    recordsToUpsert.push(record);
                 }
                 savedPrimaryKeys.push(...(await service.upsertMany(recordsToUpsert, {
                     onRevisionCreate: (pk) => revisions.push(pk),
@@ -608,13 +619,17 @@ export class PayloadService {
                     });
                 }
                 if (alterations.update) {
-                    const primaryKeyField = this.schema.collections[relation.collection].primary;
                     for (const item of alterations.update) {
-                        const { [primaryKeyField]: key, ...record } = item;
-                        await service.updateOne(key, {
-                            ...record,
-                            [relation.field]: parent || payload[currentPrimaryKeyField],
-                        }, {
+                        const { [relatedPrimaryKeyField]: key, ...record } = item;
+                        const existingRecord = await this.knex
+                            .select(relatedPrimaryKeyField, relation.field)
+                            .from(relation.collection)
+                            .where({ [relatedPrimaryKeyField]: key })
+                            .first();
+                        if (!existingRecord || existingRecord[relation.field] != parent) {
+                            record[relation.field] = parent || payload[currentPrimaryKeyField];
+                        }
+                        await service.updateOne(key, record, {
                             onRevisionCreate: (pk) => revisions.push(pk),
                             onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                             bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),

package/dist/services/shares.js

@@ -4,6 +4,7 @@ import argon2 from 'argon2';
 import jwt from 'jsonwebtoken';
 import { nanoid } from 'nanoid';
 import { useLogger } from '../logger/index.js';
+import { clearCache as clearPermissionsCache } from '../permissions/cache.js';
 import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { getSecret } from '../utils/get-secret.js';
@@ -13,7 +14,6 @@ import { userName } from '../utils/user-name.js';
 import { ItemsService } from './items.js';
 import { MailService } from './mail/index.js';
 import { UsersService } from './users.js';
-import { clearCache as clearPermissionsCache } from '../permissions/cache.js';
 const env = useEnv();
 const logger = useLogger();
 export class SharesService extends ItemsService {

package/dist/services/specifications.js

@@ -49,7 +49,7 @@ class OASSpecsService {
             permissions = await fetchPermissions({ policies, accountability: this.accountability }, { schema: this.schema, knex: this.knex });
         }
         const tags = await this.generateTags(schemaForSpec);
-        const paths = await this.generatePaths(permissions, tags);
+        const paths = await this.generatePaths(schemaForSpec, permissions, tags);
         const components = await this.generateComponents(schemaForSpec, tags);
         const isDefaultPublicUrl = env['PUBLIC_URL'] === '/';
         const url = isDefaultPublicUrl && host ? host : env['PUBLIC_URL'];
@@ -114,7 +114,7 @@ class OASSpecsService {
         // Filter out the generic Items information
         return tags.filter((tag) => tag.name !== 'Items');
     }
-    async generatePaths(permissions, tags) {
+    async generatePaths(schema, permissions, tags) {
         const paths = {};
         if (!tags)
             return paths;
@@ -195,11 +195,16 @@ class OASSpecsService {
                                                 'application/json': {
                                                     schema: {
                                                         properties: {
-                                                            data: {
-                                                                items: {
+                                                            data: schema.collections[collection]?.singleton
+                                                                ? {
                                                                     $ref: `#/components/schemas/${tag.name}`,
+                                                                }
+                                                                : {
+                                                                    type: 'array',
+                                                                    items: {
+                                                                        $ref: `#/components/schemas/${tag.name}`,
+                                                                    },
                                                                 },
-                                                            },
                                                         },
                                                     },
                                                 },

package/dist/services/tus/lockers.d.ts

@@ -29,7 +29,7 @@ export declare class KvLock implements Lock {
     private acquireTimeout;
     private kv;
     constructor(id: string, lockTimeout?: number, acquireTimeout?: number);
-    lock(cancelReq: RequestRelease): Promise<void>;
+    lock(signal: AbortSignal, cancelReq: RequestRelease): Promise<void>;
     protected acquireLock(id: string, requestRelease: RequestRelease, signal: AbortSignal): Promise<boolean>;
     unlock(): Promise<void>;
 }