@directus/api 30.0.0 → 32.0.0

package/dist/utils/sanitize-schema.js

@@ -6,8 +6,6 @@ import { pick } from 'lodash-es';
  * @returns sanitized collection
  */
 export function sanitizeCollection(collection) {
-    if (!collection)
-        return collection;
     return pick(collection, ['collection', 'fields', 'meta', 'schema.name']);
 }
 /**
@@ -18,8 +16,6 @@ export function sanitizeCollection(collection) {
  * @returns sanitized field
  */
 export function sanitizeField(field, sanitizeAllSchema = false) {
-    if (!field)
-        return field;
     const defaultPaths = ['collection', 'field', 'type', 'meta', 'name', 'children'];
     const pickedPaths = sanitizeAllSchema
         ? defaultPaths
@@ -71,8 +67,6 @@ export function sanitizeColumn(column) {
  * @returns sanitized relation
  */
 export function sanitizeRelation(relation) {
-    if (!relation)
-        return relation;
     return pick(relation, [
         'collection',
         'field',
@@ -87,3 +81,12 @@ export function sanitizeRelation(relation) {
         'schema.on_delete',
     ]);
 }
+/**
+ * Pick certain specific system field properties that should be compared when performing diff
+ *
+ * @param field field to sanitize
+ * @returns sanitized system field
+ */
+export function sanitizeSystemField(field) {
+    return pick(field, ['collection', 'field', 'schema.is_indexed']);
+}

package/dist/utils/schedule.js

@@ -1,29 +1,25 @@
-import cron from 'cron-parser';
-import schedule from 'node-schedule';
+import { CronJob, validateCronExpression } from 'cron';
 import { SynchronizedClock } from '../synchronization.js';
 export function validateCron(rule) {
-    try {
-        cron.parseExpression(rule);
-    }
-    catch {
-        return false;
-    }
-    return true;
+    return validateCronExpression(rule).valid;
 }
 export function scheduleSynchronizedJob(id, rule, cb) {
     const clock = new SynchronizedClock(`${id}:${rule}`);
-    const job = schedule.scheduleJob(rule, async (fireDate) => {
-        const nextInvocation = job.nextInvocation();
-        if (!nextInvocation)
-            return;
-        const nextTimestamp = nextInvocation.getTime();
-        const wasSet = await clock.set(nextTimestamp);
-        if (wasSet) {
-            await cb(fireDate);
-        }
+    const job = CronJob.from({
+        cronTime: rule,
+        onTick: async (fireDate) => {
+            // Get next execution time for synchronization
+            const nextDate = job.nextDate();
+            const nextTimestamp = nextDate.toMillis();
+            const wasSet = await clock.set(nextTimestamp);
+            if (wasSet) {
+                await cb(fireDate);
+            }
+        },
+        start: true,
     });
     const stop = async () => {
-        job.cancel();
+        job.stop();
         await clock.reset();
     };
     return { stop };

package/dist/utils/validate-diff.js

@@ -31,6 +31,13 @@ const applyJoiSchema = Joi.object({
             diff: Joi.array().items(deepDiffSchema).required(),
         }))
             .required(),
+        systemFields: Joi.array()
+            .items(Joi.object({
+            collection: Joi.string().required(),
+            field: Joi.string().required(),
+            diff: Joi.array().items(deepDiffSchema).required(),
+        }))
+            .required(),
         relations: Joi.array()
             .items(Joi.object({
             collection: Joi.string().required(),
@@ -53,6 +60,7 @@ export function validateApplyDiff(applyDiff, currentSnapshotWithHash) {
     // No changes to apply
     if (applyDiff.diff.collections.length === 0 &&
         applyDiff.diff.fields.length === 0 &&
+        applyDiff.diff.systemFields.length === 0 &&
         applyDiff.diff.relations.length === 0) {
         return false;
     }
@@ -97,6 +105,29 @@ export function validateApplyDiff(applyDiff, currentSnapshotWithHash) {
             }
         }
     }
+    for (const diffSystemField of applyDiff.diff.systemFields) {
+        const systemField = `${diffSystemField.collection}.${diffSystemField.field}`;
+        if (!diffSystemField.diff[0])
+            continue;
+        if (diffSystemField.diff[0].kind !== DiffKind.EDIT) {
+            let action = 'update array'; // DiffKind.ARRAY
+            if (diffSystemField.diff[0].kind === DiffKind.NEW) {
+                action = 'create';
+            }
+            else if (diffSystemField.diff[0].kind === DiffKind.DELETE) {
+                action = 'delete';
+            }
+            throw new InvalidPayloadError({
+                reason: `Provided diff is trying to ${action} field "${systemField}" but this action is not supported. Please generate a new diff and try again`,
+            });
+        }
+        const pathString = diffSystemField.diff[0].path?.join('.') ?? '';
+        if (pathString.length === 0 || pathString !== 'schema.is_indexed') {
+            throw new InvalidPayloadError({
+                reason: `Provided diff is trying to alter property "${pathString}" on "${systemField}" but currently only "schema.is_indexed" is supported. Please generate a new diff and try again`,
+            });
+        }
+    }
     for (const diffRelation of applyDiff.diff.relations) {
         let relation = `${diffRelation.collection}.${diffRelation.field}`;
         if (diffRelation.related_collection)

package/dist/utils/validate-snapshot.js

@@ -33,6 +33,13 @@ const snapshotJoiSchema = Joi.object({
             .valid(...TYPES, ...ALIAS_TYPES)
             .allow(null),
     })),
+    systemFields: Joi.array().items(Joi.object({
+        collection: Joi.string(),
+        field: Joi.string(),
+        schema: Joi.object({
+            is_indexed: Joi.bool(),
+        }),
+    })),
     relations: Joi.array().items(Joi.object({
         collection: Joi.string(),
         field: Joi.string(),

package/dist/utils/versioning/deep-map-with-schema.d.ts

@@ -0,0 +1,23 @@
+import type { CollectionOverview, FieldOverview, Relation, SchemaOverview } from '@directus/types';
+import { type RelationInfo } from '../get-relation-info.js';
+/**
+ * Allows to deep map the data like a response or delta changes with collection, field and relation context for each entry.
+ * Bottom to Top depth first mapping of values.
+ */
+export declare function deepMapWithSchema(object: Record<string, any>, callback: (entry: [key: string | number, value: unknown], context: {
+    collection: CollectionOverview;
+    field: FieldOverview;
+    relation: Relation | null;
+    leaf: boolean;
+    relationType: RelationInfo['relationType'] | null;
+    object: Record<string, any>;
+}) => [key: string | number, value: unknown] | undefined, context: {
+    schema: SchemaOverview;
+    collection: string;
+    relationInfo?: RelationInfo;
+}, options?: {
+    /** If set to true, non-existent fields will be included in the mapping and will have a value of undefined */
+    mapNonExistentFields?: boolean;
+    /** If set to true, it will map the "create", "update" and "delete" syntax for o2m relations found in deltas */
+    detailedUpdateSyntax?: boolean;
+}): any;

package/dist/utils/versioning/deep-map-with-schema.js

@@ -0,0 +1,81 @@
+import { isPlainObject } from 'lodash-es';
+import assert from 'node:assert';
+import { getRelationInfo } from '../get-relation-info.js';
+import { InvalidQueryError } from '@directus/errors';
+/**
+ * Allows to deep map the data like a response or delta changes with collection, field and relation context for each entry.
+ * Bottom to Top depth first mapping of values.
+ */
+export function deepMapWithSchema(object, callback, context, options) {
+    const collection = context.schema.collections[context.collection];
+    assert(isPlainObject(object) && typeof object === 'object' && object !== null, `DeepMapResponse only works on objects, received ${JSON.stringify(object)}`);
+    let fields;
+    if (options?.mapNonExistentFields) {
+        fields = Object.entries(collection.fields);
+    }
+    else {
+        fields = Object.keys(object).map((key) => [key, collection.fields[key]]);
+    }
+    return Object.fromEntries(fields
+        .map(([key, field]) => {
+        let value = object[key];
+        if (!field)
+            return [key, value];
+        const relationInfo = getRelationInfo(context.schema.relations, collection.collection, field.field);
+        let leaf = true;
+        if (relationInfo.relation && typeof value === 'object' && value !== null && isPlainObject(object)) {
+            switch (relationInfo.relationType) {
+                case 'm2o':
+                    value = deepMapWithSchema(value, callback, {
+                        schema: context.schema,
+                        collection: relationInfo.relation.related_collection,
+                        relationInfo,
+                    }, options);
+                    leaf = false;
+                    break;
+                case 'o2m': {
+                    function map(childValue) {
+                        if (isPlainObject(childValue) && typeof childValue === 'object' && childValue !== null) {
+                            leaf = false;
+                            return deepMapWithSchema(childValue, callback, {
+                                schema: context.schema,
+                                collection: relationInfo.relation.collection,
+                                relationInfo,
+                            }, options);
+                        }
+                        else
+                            return childValue;
+                    }
+                    if (Array.isArray(value)) {
+                        value = value.map(map);
+                    }
+                    else if (options?.detailedUpdateSyntax && isPlainObject(value)) {
+                        value = {
+                            create: value['create']?.map(map),
+                            update: value['update']?.map(map),
+                            delete: value['delete']?.map(map),
+                        };
+                    }
+                    break;
+                }
+                case 'a2o': {
+                    const related_collection = object[relationInfo.relation.meta.one_collection_field];
+                    if (!related_collection) {
+                        throw new InvalidQueryError({
+                            reason: `When selecting '${collection.collection}.${field.field}', the field '${collection.collection}.${relationInfo.relation.meta.one_collection_field}' has to be selected when using versioning and m2a relations `,
+                        });
+                    }
+                    value = deepMapWithSchema(value, callback, {
+                        schema: context.schema,
+                        collection: related_collection,
+                        relationInfo,
+                    }, options);
+                    leaf = false;
+                    break;
+                }
+            }
+        }
+        return callback([key, value], { collection, field, ...relationInfo, leaf, object });
+    })
+        .filter((f) => f));
+}

package/dist/utils/versioning/handle-version.d.ts

@@ -1,3 +1,3 @@
-import type { Item, PrimaryKey, Query, QueryOptions } from '@directus/types';
+import type { PrimaryKey, Query, QueryOptions } from '@directus/types';
 import type { ItemsService as ItemsServiceType } from '../../services/index.js';
-export declare function handleVersion(self: ItemsServiceType, key: PrimaryKey, queryWithKey: Query, opts?: QueryOptions): Promise<(Item | undefined)[]>;
+export declare function handleVersion(self: ItemsServiceType, key: PrimaryKey, queryWithKey: Query, opts?: QueryOptions): Promise<any>;

package/dist/utils/versioning/handle-version.js

@@ -1,7 +1,7 @@
 import { ForbiddenError } from '@directus/errors';
-import { deepMapResponse } from '../deep-map-response.js';
 import { transaction } from '../transaction.js';
-import { mergeVersionsRaw } from './merge-version-data.js';
+import { deepMapWithSchema } from './deep-map-with-schema.js';
+import { splitRecursive } from './split-recursive.js';
 export async function handleVersion(self, key, queryWithKey, opts) {
     const { VersionsService } = await import('../../services/versions.js');
     const { ItemsService } = await import('../../services/items.js');
@@ -15,19 +15,21 @@ export async function handleVersion(self, key, queryWithKey, opts) {
             accountability: self.accountability,
             knex: self.knex,
         });
-        const versionData = await versionsService.getVersionSaves(queryWithKey.version, self.collection, key);
-        if (!versionData || versionData.length === 0)
-            return [originalData[0]];
-        return [mergeVersionsRaw(originalData[0], versionData)];
+        const version = await versionsService.getVersionSave(queryWithKey.version, self.collection, key);
+        return Object.assign(originalData[0], version?.delta);
     }
-    let results = [];
+    let result;
     const versionsService = new VersionsService({
         schema: self.schema,
         accountability: self.accountability,
         knex: self.knex,
     });
     const createdIDs = {};
-    const versionData = await versionsService.getVersionSaves(queryWithKey.version, self.collection, key);
+    const version = await versionsService.getVersionSave(queryWithKey.version, self.collection, key, false);
+    if (!version) {
+        throw new ForbiddenError();
+    }
+    const { delta } = version;
     await transaction(self.knex, async (trx) => {
         const itemsServiceAdmin = new ItemsService(self.collection, {
             schema: self.schema,
@@ -36,57 +38,59 @@ export async function handleVersion(self, key, queryWithKey, opts) {
             },
             knex: trx,
         });
-        await Promise.all((versionData ?? []).map((data) => {
-            return itemsServiceAdmin.updateOne(key, data, {
+        if (delta) {
+            const { rawDelta, defaultOverwrites } = splitRecursive(delta);
+            await itemsServiceAdmin.updateOne(key, rawDelta, {
                 emitEvents: false,
                 autoPurgeCache: false,
                 skipTracking: true,
+                overwriteDefaults: defaultOverwrites,
                 onItemCreate: (collection, pk) => {
                     if (collection in createdIDs === false)
                         createdIDs[collection] = [];
                     createdIDs[collection].push(pk);
                 },
             });
-        }));
+        }
         const itemsServiceUser = new ItemsService(self.collection, {
             schema: self.schema,
             accountability: self.accountability,
             knex: trx,
         });
-        results = await itemsServiceUser.readByQuery(queryWithKey, opts);
+        result = (await itemsServiceUser.readByQuery(queryWithKey, opts))[0];
         await trx.rollback();
     });
-    results = results.map((result) => {
-        return deepMapResponse(result, ([key, value], context) => {
-            if (context.relationType === 'm2o' || context.relationType === 'a2o') {
-                const ids = createdIDs[context.relation.related_collection];
-                const match = ids?.find((id) => String(id) === String(value));
-                if (match) {
-                    return [key, null];
-                }
-            }
-            else if (context.relationType === 'o2m' && Array.isArray(value)) {
-                const ids = createdIDs[context.relation.collection];
-                return [
-                    key,
-                    value.map((val) => {
-                        const match = ids?.find((id) => String(id) === String(val));
-                        if (match) {
-                            return null;
-                        }
-                        return val;
-                    }),
-                ];
+    if (!result) {
+        throw new ForbiddenError();
+    }
+    return deepMapWithSchema(result, ([key, value], context) => {
+        if (context.relationType === 'm2o' || context.relationType === 'a2o') {
+            const ids = createdIDs[context.relation.related_collection];
+            const match = ids?.find((id) => String(id) === String(value));
+            if (match) {
+                return [key, null];
             }
-            if (context.field.field === context.collection.primary) {
-                const ids = createdIDs[context.collection.collection];
-                const match = ids?.find((id) => String(id) === String(value));
-                if (match) {
-                    return [key, null];
-                }
+        }
+        else if (context.relationType === 'o2m' && Array.isArray(value)) {
+            const ids = createdIDs[context.relation.collection];
+            return [
+                key,
+                value.map((val) => {
+                    const match = ids?.find((id) => String(id) === String(val));
+                    if (match) {
+                        return null;
+                    }
+                    return val;
+                }),
+            ];
+        }
+        if (context.field.field === context.collection.primary) {
+            const ids = createdIDs[context.collection.collection];
+            const match = ids?.find((id) => String(id) === String(value));
+            if (match) {
+                return [key, null];
             }
-            return [key, value];
-        }, { collection: self.collection, schema: self.schema });
-    });
-    return results;
+        }
+        return [key, value];
+    }, { collection: self.collection, schema: self.schema });
 }

package/dist/utils/versioning/split-recursive.d.ts

@@ -0,0 +1,4 @@
+export declare function splitRecursive(object: unknown): {
+    rawDelta: Record<string, any>;
+    defaultOverwrites: Record<string, any> | undefined;
+};

package/dist/utils/versioning/split-recursive.js

@@ -0,0 +1,27 @@
+import { isPlainObject } from 'lodash-es';
+export function splitRecursive(object) {
+    if (isPlainObject(object) && typeof object === 'object' && object !== null) {
+        const { _user, _date, ...rest } = object;
+        const defaultOverwrites = { _user, _date };
+        for (const key in rest) {
+            const { rawDelta, defaultOverwrites: innerDefaultOverwrites } = splitRecursive(rest[key]);
+            rest[key] = rawDelta;
+            if (innerDefaultOverwrites)
+                defaultOverwrites[key] = innerDefaultOverwrites;
+        }
+        return { rawDelta: rest, defaultOverwrites };
+    }
+    else if (Array.isArray(object)) {
+        const rest = [];
+        const defaultOverwrites = [];
+        for (const key in object) {
+            const { rawDelta, defaultOverwrites: innerDefaultOverwrites } = splitRecursive(object[key]);
+            rest[key] = rawDelta;
+            if (innerDefaultOverwrites)
+                defaultOverwrites[key] = innerDefaultOverwrites;
+        }
+        object.map((value) => splitRecursive(value));
+        return { rawDelta: rest, defaultOverwrites };
+    }
+    return { rawDelta: object, defaultOverwrites: undefined };
+}

package/dist/websocket/controllers/hooks.js

@@ -1,3 +1,4 @@
+import { systemCollectionNames } from '@directus/system-data';
 import { useBus } from '../../bus/index.js';
 import emitter from '../../emitter.js';
 let actionsRegistered = false;
@@ -7,26 +8,17 @@ export function registerWebSocketEvents() {
     actionsRegistered = true;
     registerActionHooks([
         'items',
-        'access',
-        'activity',
-        'collections',
-        'dashboards',
-        'flows',
-        'folders',
-        'notifications',
-        'operations',
-        'panels',
-        'permissions',
-        'policies',
-        'presets',
-        'revisions',
-        'roles',
-        'settings',
-        'shares',
-        'translations',
-        'users',
-        'versions',
-        'webhooks',
+        ...systemCollectionNames
+            .filter((collection) => ![
+            'directus_migrations',
+            // manually registered below
+            'directus_fields',
+            'directus_relations',
+            'directus_files',
+            // excluded for security reasons
+            'directus_sessions',
+        ].includes(collection))
+            .map((collection) => collection.replace('directus_', '')),
     ]);
     registerFieldsHooks();
     registerFilesHooks();

package/dist/websocket/messages.d.ts

@@ -12,7 +12,7 @@ export declare const WebSocketResponse: z.ZodDiscriminatedUnion<[z.ZodObject<{
         code: z.ZodString;
         message: z.ZodString;
     }, z.core.$loose>;
-}, z.core.$loose>]>;
+}, z.core.$loose>], "status">;
 export type WebSocketResponse = z.infer<typeof WebSocketResponse>;
 export declare const ConnectionParams: z.ZodObject<{
     access_token: z.ZodOptional<z.ZodString>;
@@ -49,7 +49,7 @@ export declare const WebSocketSubscribeMessage: z.ZodDiscriminatedUnion<[z.ZodOb
 }, z.core.$loose>, z.ZodObject<{
     uid: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     type: z.ZodLiteral<"unsubscribe">;
-}, z.core.$loose>]>;
+}, z.core.$loose>], "type">;
 export type WebSocketSubscribeMessage = z.infer<typeof WebSocketSubscribeMessage>;
 export declare const WebSocketLogsMessage: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"subscribe">;
@@ -108,7 +108,7 @@ export declare const WebSocketEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
     collection: z.ZodString;
     payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     keys: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-}, z.core.$strip>]>;
+}, z.core.$strip>], "action">;
 export type WebSocketEvent = z.infer<typeof WebSocketEvent>;
 export declare const AuthMode: z.ZodUnion<readonly [z.ZodLiteral<"public">, z.ZodLiteral<"handshake">, z.ZodLiteral<"strict">]>;
 export type AuthMode = z.infer<typeof AuthMode>;