directus 9.22.4 → 9.23.3

package/dist/utils/merge-permissions-for-share.js

@@ -53,7 +53,6 @@ function mergePermissionsForShare(currentPermissions, accountability, schema) {
 }
 exports.mergePermissionsForShare = mergePermissionsForShare;
 function traverse(schema, rootItemPrimaryKeyField, rootItemPrimaryKey, currentCollection, parentCollections = [], path = []) {
-    var _a, _b, _c;
     const permissions = [];
     // If there's already a permissions rule for the collection we're currently checking, we'll shortcircuit.
     // This prevents infinite loop in recursive relationships, like articles->related_articles->articles, or
@@ -82,7 +81,7 @@ function traverse(schema, rootItemPrimaryKeyField, rootItemPrimaryKey, currentCo
             });
             permissions.push(...traverse(schema, rootItemPrimaryKeyField, rootItemPrimaryKey, relation.collection, [...parentCollections, currentCollection], [...path, relation.field]));
         }
-        if (type === 'a2o' && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_allowed_collections)) {
+        if (type === 'a2o' && relation.meta?.one_allowed_collections) {
             for (const collection of relation.meta.one_allowed_collections) {
                 permissions.push({
                     collection,
@@ -95,8 +94,8 @@ function traverse(schema, rootItemPrimaryKeyField, rootItemPrimaryKey, currentCo
                 collection: relation.related_collection,
                 permissions: getFilterForPath(type, [...path, `$FOLLOW(${relation.collection},${relation.field})`], rootItemPrimaryKeyField, rootItemPrimaryKey),
             });
-            if ((_b = relation.meta) === null || _b === void 0 ? void 0 : _b.one_field) {
-                permissions.push(...traverse(schema, rootItemPrimaryKeyField, rootItemPrimaryKey, relation.related_collection, [...parentCollections, currentCollection], [...path, (_c = relation.meta) === null || _c === void 0 ? void 0 : _c.one_field]));
+            if (relation.meta?.one_field) {
+                permissions.push(...traverse(schema, rootItemPrimaryKeyField, rootItemPrimaryKey, relation.related_collection, [...parentCollections, currentCollection], [...path, relation.meta?.one_field]));
             }
         }
     }

package/dist/utils/merge-permissions.d.ts

@@ -1,14 +1,14 @@
 /// <reference types="lodash" />
-import { Permission } from '@directus/shared/types';
+import type { Permission } from '@directus/shared/types';
 export declare function mergePermissions(strategy: 'and' | 'or', ...permissions: Permission[][]): Permission[];
 export declare function mergePermission(strategy: 'and' | 'or', currentPerm: Permission, newPerm: Permission): import("lodash").Omit<{
     permissions: import("@directus/shared/types").Filter | null;
     validation: import("@directus/shared/types").Filter | null;
     fields: string[] | null;
     presets: Record<string, any> | null;
-    id?: number | undefined;
+    id?: number;
     role: string | null;
     collection: string;
     action: import("@directus/shared/types").PermissionsAction;
-    system?: true | undefined;
+    system?: true;
 }, "id" | "system">;

package/dist/utils/redact-header-cookies.d.ts

@@ -0,0 +1 @@
+export declare function redactHeaderCookie(cookieHeader: string, cookieNames: string[]): string;

package/dist/utils/redact-header-cookies.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactHeaderCookie = void 0;
+function redactHeaderCookie(cookieHeader, cookieNames) {
+    for (const cookieName of cookieNames) {
+        const re = new RegExp(`(${cookieName}=)([^;]+)`);
+        cookieHeader = cookieHeader.replace(re, `$1--redacted--`);
+    }
+    return cookieHeader;
+}
+exports.redactHeaderCookie = redactHeaderCookie;

package/dist/utils/redact-header-cookies.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/reduce-schema.d.ts

@@ -1,4 +1,4 @@
-import { Permission, PermissionsAction, SchemaOverview } from '@directus/shared/types';
+import type { Permission, PermissionsAction, SchemaOverview } from '@directus/shared/types';
 /**
  * Reduces the schema based on the included permissions. The resulting object is the schema structure, but with only
  * the allowed collections/fields/relations included based on the permissions.

package/dist/utils/reduce-schema.js

@@ -10,12 +10,13 @@ const lodash_1 = require("lodash");
  * @returns Reduced schema
  */
 function reduceSchema(schema, permissions, actions = ['create', 'read', 'update', 'delete']) {
-    var _a, _b, _c;
     const reduced = {
         collections: {},
         relations: [],
     };
-    const allowedFieldsInCollection = (_a = permissions === null || permissions === void 0 ? void 0 : permissions.filter((permission) => actions.includes(permission.action)).reduce((acc, permission) => {
+    const allowedFieldsInCollection = permissions
+        ?.filter((permission) => actions.includes(permission.action))
+        .reduce((acc, permission) => {
         if (!acc[permission.collection]) {
             acc[permission.collection] = [];
         }
@@ -23,20 +24,20 @@ function reduceSchema(schema, permissions, actions = ['create', 'read', 'update'
             acc[permission.collection] = (0, lodash_1.uniq)([...acc[permission.collection], ...permission.fields]);
         }
         return acc;
-    }, {})) !== null && _a !== void 0 ? _a : {};
+    }, {}) ?? {};
     for (const [collectionName, collection] of Object.entries(schema.collections)) {
-        if (!(permissions === null || permissions === void 0 ? void 0 : permissions.some((permission) => permission.collection === collectionName && actions.includes(permission.action)))) {
+        if (!permissions?.some((permission) => permission.collection === collectionName && actions.includes(permission.action))) {
             continue;
         }
         const fields = {};
         for (const [fieldName, field] of Object.entries(schema.collections[collectionName].fields)) {
-            if (!((_b = allowedFieldsInCollection[collectionName]) === null || _b === void 0 ? void 0 : _b.includes('*')) &&
-                !((_c = allowedFieldsInCollection[collectionName]) === null || _c === void 0 ? void 0 : _c.includes(fieldName))) {
+            if (!allowedFieldsInCollection[collectionName]?.includes('*') &&
+                !allowedFieldsInCollection[collectionName]?.includes(fieldName)) {
                 continue;
             }
-            const o2mRelation = schema.relations.find((relation) => { var _a; return relation.related_collection === collectionName && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === fieldName; });
+            const o2mRelation = schema.relations.find((relation) => relation.related_collection === collectionName && relation.meta?.one_field === fieldName);
             if (o2mRelation &&
-                !(permissions === null || permissions === void 0 ? void 0 : permissions.some((permission) => permission.collection === o2mRelation.collection && actions.includes(permission.action)))) {
+                !permissions?.some((permission) => permission.collection === o2mRelation.collection && actions.includes(permission.action))) {
                 continue;
             }
             fields[fieldName] = field;
@@ -47,7 +48,6 @@ function reduceSchema(schema, permissions, actions = ['create', 'read', 'update'
         };
     }
     reduced.relations = schema.relations.filter((relation) => {
-        var _a, _b, _c;
         let collectionsAllowed = true;
         let fieldsAllowed = true;
         if (Object.keys(allowedFieldsInCollection).includes(relation.collection) === false) {
@@ -59,7 +59,7 @@ function reduceSchema(schema, permissions, actions = ['create', 'read', 'update'
                 allowedFieldsInCollection[relation.related_collection].length === 0)) {
             collectionsAllowed = false;
         }
-        if (((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_allowed_collections) &&
+        if (relation.meta?.one_allowed_collections &&
             relation.meta.one_allowed_collections.every((collection) => Object.keys(allowedFieldsInCollection).includes(collection)) === false) {
             collectionsAllowed = false;
         }
@@ -69,10 +69,10 @@ function reduceSchema(schema, permissions, actions = ['create', 'read', 'update'
             fieldsAllowed = false;
         }
         if (relation.related_collection &&
-            ((_b = relation.meta) === null || _b === void 0 ? void 0 : _b.one_field) &&
+            relation.meta?.one_field &&
             (!allowedFieldsInCollection[relation.related_collection] ||
                 (allowedFieldsInCollection[relation.related_collection].includes('*') === false &&
-                    allowedFieldsInCollection[relation.related_collection].includes((_c = relation.meta) === null || _c === void 0 ? void 0 : _c.one_field) === false))) {
+                    allowedFieldsInCollection[relation.related_collection].includes(relation.meta?.one_field) === false))) {
             fieldsAllowed = false;
         }
         return collectionsAllowed && fieldsAllowed;

package/dist/utils/sanitize-query.d.ts

@@ -1,2 +1,2 @@
-import { Accountability, Query } from '@directus/shared/types';
+import type { Accountability, Query } from '@directus/shared/types';
 export declare function sanitizeQuery(rawQuery: Record<string, any>, accountability?: Accountability | null): Query;

package/dist/utils/sanitize-query.js

@@ -59,7 +59,7 @@ function sanitizeQuery(rawQuery, accountability) {
 exports.sanitizeQuery = sanitizeQuery;
 function sanitizeFields(rawFields) {
     if (!rawFields)
-        return;
+        return null;
     let fields = [];
     if (typeof rawFields === 'string')
         fields = rawFields.split(',');

package/dist/utils/sanitize-schema.d.ts

@@ -0,0 +1,30 @@
+import type { Field, Relation } from '@directus/shared/types';
+import type { Collection } from '../types';
+/**
+ * Pick certain database vendor specific collection properties that should be compared when performing diff
+ *
+ * @param collection collection to sanitize
+ * @returns sanitized collection
+ *
+ * @see {@link https://github.com/knex/knex-schema-inspector/blob/master/lib/types/table.ts}
+ */
+export declare function sanitizeCollection(collection: Collection | undefined): Partial<Collection> | undefined;
+/**
+ * Pick certain database vendor specific field properties that should be compared when performing diff
+ *
+ * @param field field to sanitize
+ * @param sanitizeAllSchema Whether or not the whole field schema should be sanitized. Mainly used to prevent modifying autoincrement fields
+ * @returns sanitized field
+ *
+ * @see {@link https://github.com/knex/knex-schema-inspector/blob/master/lib/types/column.ts}
+ */
+export declare function sanitizeField(field: Field | undefined, sanitizeAllSchema?: boolean): Partial<Field> | undefined;
+/**
+ * Pick certain database vendor specific relation properties that should be compared when performing diff
+ *
+ * @param relation relation to sanitize
+ * @returns sanitized relation
+ *
+ * @see {@link https://github.com/knex/knex-schema-inspector/blob/master/lib/types/foreign-key.ts}
+ */
+export declare function sanitizeRelation(relation: Relation | undefined): Partial<Relation> | undefined;

package/dist/utils/sanitize-schema.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeRelation = exports.sanitizeField = exports.sanitizeCollection = void 0;
+const lodash_1 = require("lodash");
+/**
+ * Pick certain database vendor specific collection properties that should be compared when performing diff
+ *
+ * @param collection collection to sanitize
+ * @returns sanitized collection
+ *
+ * @see {@link https://github.com/knex/knex-schema-inspector/blob/master/lib/types/table.ts}
+ */
+function sanitizeCollection(collection) {
+    if (!collection)
+        return collection;
+    return (0, lodash_1.pick)(collection, ['collection', 'fields', 'meta', 'schema.name']);
+}
+exports.sanitizeCollection = sanitizeCollection;
+/**
+ * Pick certain database vendor specific field properties that should be compared when performing diff
+ *
+ * @param field field to sanitize
+ * @param sanitizeAllSchema Whether or not the whole field schema should be sanitized. Mainly used to prevent modifying autoincrement fields
+ * @returns sanitized field
+ *
+ * @see {@link https://github.com/knex/knex-schema-inspector/blob/master/lib/types/column.ts}
+ */
+function sanitizeField(field, sanitizeAllSchema = false) {
+    if (!field)
+        return field;
+    const defaultPaths = ['collection', 'field', 'type', 'meta', 'name', 'children'];
+    const pickedPaths = sanitizeAllSchema
+        ? defaultPaths
+        : [
+            ...defaultPaths,
+            'schema.name',
+            'schema.table',
+            'schema.data_type',
+            'schema.default_value',
+            'schema.max_length',
+            'schema.numeric_precision',
+            'schema.numeric_scale',
+            'schema.is_nullable',
+            'schema.is_unique',
+            'schema.is_primary_key',
+            'schema.is_generated',
+            'schema.generation_expression',
+            'schema.has_auto_increment',
+            'schema.foreign_key_table',
+            'schema.foreign_key_column',
+        ];
+    return (0, lodash_1.pick)(field, pickedPaths);
+}
+exports.sanitizeField = sanitizeField;
+/**
+ * Pick certain database vendor specific relation properties that should be compared when performing diff
+ *
+ * @param relation relation to sanitize
+ * @returns sanitized relation
+ *
+ * @see {@link https://github.com/knex/knex-schema-inspector/blob/master/lib/types/foreign-key.ts}
+ */
+function sanitizeRelation(relation) {
+    if (!relation)
+        return relation;
+    return (0, lodash_1.pick)(relation, [
+        'collection',
+        'field',
+        'related_collection',
+        'meta',
+        'schema.table',
+        'schema.column',
+        'schema.foreign_key_table',
+        'schema.foreign_key_column',
+        'schema.constraint_name',
+        'schema.on_update',
+        'schema.on_delete',
+    ]);
+}
+exports.sanitizeRelation = sanitizeRelation;

package/dist/utils/sanitize-schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/should-skip-cache.d.ts

@@ -0,0 +1,7 @@
+import type { Request } from 'express';
+/**
+ * Whether to skip caching for the current request
+ *
+ * @param req Express request object
+ */
+export declare function shouldSkipCache(req: Request): boolean;

package/dist/utils/should-skip-cache.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldSkipCache = void 0;
+const env_1 = require("../env");
+const url_1 = require("./url");
+/**
+ * Whether to skip caching for the current request
+ *
+ * @param req Express request object
+ */
+function shouldSkipCache(req) {
+    const env = (0, env_1.getEnv)();
+    // Always skip cache for requests coming from the data studio based on Referer header
+    const adminUrl = new url_1.Url(env.PUBLIC_URL).addPath('admin').toString();
+    if (req.get('Referer')?.startsWith(adminUrl))
+        return true;
+    if (env.CACHE_SKIP_ALLOWED && req.get('cache-control')?.includes('no-store'))
+        return true;
+    return false;
+}
+exports.shouldSkipCache = shouldSkipCache;

package/dist/utils/should-skip-cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/track.js

@@ -4,14 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.track = void 0;
-const ms_1 = __importDefault(require("ms"));
 const node_machine_id_1 = require("node-machine-id");
 const os_1 = __importDefault(require("os"));
 // @ts-ignore
+const utils_1 = require("@directus/shared/utils");
 const package_json_1 = require("../../package.json");
 const env_1 = __importDefault(require("../env"));
 const logger_1 = __importDefault(require("../logger"));
-const utils_1 = require("@directus/shared/utils");
+const get_milliseconds_1 = require("./get-milliseconds");
 async function track(event) {
     const axios = (await import('axios')).default;
     if (env_1.default.TELEMETRY !== false) {
@@ -48,7 +48,7 @@ async function getEnvInfo(event) {
         },
         cache: {
             enabled: env_1.default.CACHE_ENABLED,
-            ttl: (0, ms_1.default)(env_1.default.CACHE_TTL),
+            ttl: (0, get_milliseconds_1.getMilliseconds)(env_1.default.CACHE_TTL),
             store: env_1.default.CACHE_STORE,
         },
         storage: {

package/dist/utils/transformations.d.ts

@@ -1,4 +1,4 @@
-import { File, Transformation, TransformationParams, TransformationPreset } from '../types';
+import type { File, Transformation, TransformationParams, TransformationPreset } from '../types';
 export declare function resolvePreset(input: TransformationParams | TransformationPreset, file: File): Transformation[];
 /**
  * Try to extract a file format from an array of `Transformation`'s.

package/dist/utils/transformations.js

@@ -4,9 +4,8 @@ exports.maybeExtractFormat = exports.resolvePreset = void 0;
 const lodash_1 = require("lodash");
 // Extract transforms from a preset
 function resolvePreset(input, file) {
-    var _a;
     // Do the format conversion last
-    return [extractResize(input), ...((_a = input.transforms) !== null && _a !== void 0 ? _a : []), extractToFormat(input, file)].filter((transform) => transform !== undefined);
+    return [extractResize(input), ...(input.transforms ?? []), extractToFormat(input, file)].filter((transform) => transform !== undefined);
 }
 exports.resolvePreset = resolvePreset;
 function extractOptions(keys, numberKeys = [], booleanKeys = []) {
@@ -49,9 +48,8 @@ function extractResize(input) {
  * Try to extract a file format from an array of `Transformation`'s.
  */
 function maybeExtractFormat(transforms) {
-    var _a;
     const toFormats = transforms.filter((t) => t[0] === 'toFormat');
     const lastToFormat = toFormats[toFormats.length - 1];
-    return lastToFormat ? (_a = lastToFormat[1]) === null || _a === void 0 ? void 0 : _a.toString() : undefined;
+    return lastToFormat ? lastToFormat[1]?.toString() : undefined;
 }
 exports.maybeExtractFormat = maybeExtractFormat;

package/dist/utils/url.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Url = void 0;
 const url_1 = require("url");
 class Url {
+    protocol;
+    host;
+    port;
+    path;
+    query;
+    hash;
     constructor(url) {
         const parsedUrl = new url_1.URL(url, 'http://localhost');
         const isProtocolRelative = /^\/\//.test(url);
@@ -44,17 +50,12 @@ class Url {
         return this;
     }
     toString({ rootRelative } = { rootRelative: false }) {
-        var _a;
         const protocol = this.protocol !== null ? `${this.protocol}:` : '';
-        const host = (_a = this.host) !== null && _a !== void 0 ? _a : '';
+        const host = this.host ?? '';
         const port = this.port !== null ? `:${this.port}` : '';
         const origin = `${this.host !== null ? `${protocol}//` : ''}${host}${port}`;
-        const path = `/${this.path.join('/')}`;
-        const query = Object.keys(this.query).length !== 0
-            ? `?${Object.entries(this.query)
-                .map(([k, v]) => `${k}=${v}`)
-                .join('&')}`
-            : '';
+        const path = this.path.length ? `/${this.path.join('/')}` : '';
+        const query = Object.keys(this.query).length !== 0 ? `?${new URLSearchParams(this.query).toString()}` : '';
         const hash = this.hash !== null ? `#${this.hash}` : '';
         return `${!rootRelative ? origin : ''}${path}${query}${hash}`;
     }

package/dist/utils/url.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/user-name.d.ts

@@ -1,2 +1,2 @@
-import { User } from '@directus/shared/types';
+import type { User } from '@directus/shared/types';
 export declare function userName(user: Partial<User>): string;

package/dist/utils/validate-diff.d.ts

@@ -0,0 +1,7 @@
+import { SnapshotDiffWithHash, SnapshotWithHash } from '../types/snapshot';
+/**
+ * Validates the diff against the current schema snapshot.
+ *
+ * @returns True if the diff can be applied (valid & not empty).
+ */
+export declare function validateApplyDiff(applyDiff: SnapshotDiffWithHash, currentSnapshotWithHash: SnapshotWithHash): boolean;

package/dist/utils/validate-diff.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateApplyDiff = void 0;
+const joi_1 = __importDefault(require("joi"));
+const index_1 = require("../index");
+const snapshot_1 = require("../types/snapshot");
+const deepDiffSchema = joi_1.default.object({
+    kind: joi_1.default.string()
+        .valid(...Object.values(snapshot_1.DiffKind))
+        .required(),
+    path: joi_1.default.array().items(joi_1.default.string()),
+    lhs: joi_1.default.object().when('kind', { is: [snapshot_1.DiffKind.DELETE, snapshot_1.DiffKind.EDIT], then: joi_1.default.required() }),
+    rhs: joi_1.default.object().when('kind', { is: [snapshot_1.DiffKind.NEW, snapshot_1.DiffKind.EDIT], then: joi_1.default.required() }),
+    index: joi_1.default.number().when('kind', { is: snapshot_1.DiffKind.ARRAY, then: joi_1.default.required() }),
+    item: joi_1.default.link('/').when('kind', { is: snapshot_1.DiffKind.ARRAY, then: joi_1.default.required() }),
+});
+const applyJoiSchema = joi_1.default.object({
+    hash: joi_1.default.string().required(),
+    diff: joi_1.default.object({
+        collections: joi_1.default.array()
+            .items(joi_1.default.object({
+            collection: joi_1.default.string().required(),
+            diff: joi_1.default.array().items(deepDiffSchema).required(),
+        }))
+            .required(),
+        fields: joi_1.default.array()
+            .items(joi_1.default.object({
+            collection: joi_1.default.string().required(),
+            field: joi_1.default.string().required(),
+            diff: joi_1.default.array().items(deepDiffSchema).required(),
+        }))
+            .required(),
+        relations: joi_1.default.array()
+            .items(joi_1.default.object({
+            collection: joi_1.default.string().required(),
+            field: joi_1.default.string().required(),
+            related_collection: joi_1.default.string().allow(null),
+            diff: joi_1.default.array().items(deepDiffSchema).required(),
+        }))
+            .required(),
+    }).required(),
+});
+/**
+ * Validates the diff against the current schema snapshot.
+ *
+ * @returns True if the diff can be applied (valid & not empty).
+ */
+function validateApplyDiff(applyDiff, currentSnapshotWithHash) {
+    const { error } = applyJoiSchema.validate(applyDiff);
+    if (error)
+        throw new index_1.InvalidPayloadException(error.message);
+    // No changes to apply
+    if (applyDiff.diff.collections.length === 0 &&
+        applyDiff.diff.fields.length === 0 &&
+        applyDiff.diff.relations.length === 0) {
+        return false;
+    }
+    // Diff can be applied due to matching hash
+    if (applyDiff.hash === currentSnapshotWithHash.hash)
+        return true;
+    for (const diffCollection of applyDiff.diff.collections) {
+        const collection = diffCollection.collection;
+        if (diffCollection.diff[0]?.kind === snapshot_1.DiffKind.NEW) {
+            const existingCollection = currentSnapshotWithHash.collections.find((c) => c.collection === diffCollection.collection);
+            if (existingCollection) {
+                throw new index_1.InvalidPayloadException(`Provided diff is trying to create collection "${collection}" but it already exists. Please generate a new diff and try again.`);
+            }
+        }
+        else if (diffCollection.diff[0]?.kind === snapshot_1.DiffKind.DELETE) {
+            const existingCollection = currentSnapshotWithHash.collections.find((c) => c.collection === diffCollection.collection);
+            if (!existingCollection) {
+                throw new index_1.InvalidPayloadException(`Provided diff is trying to delete collection "${collection}" but it does not exist. Please generate a new diff and try again.`);
+            }
+        }
+    }
+    for (const diffField of applyDiff.diff.fields) {
+        const field = `${diffField.collection}.${diffField.field}`;
+        if (diffField.diff[0]?.kind === snapshot_1.DiffKind.NEW) {
+            const existingField = currentSnapshotWithHash.fields.find((f) => f.collection === diffField.collection && f.field === diffField.field);
+            if (existingField) {
+                throw new index_1.InvalidPayloadException(`Provided diff is trying to create field "${field}" but it already exists. Please generate a new diff and try again.`);
+            }
+        }
+        else if (diffField.diff[0]?.kind === snapshot_1.DiffKind.DELETE) {
+            const existingField = currentSnapshotWithHash.fields.find((f) => f.collection === diffField.collection && f.field === diffField.field);
+            if (!existingField) {
+                throw new index_1.InvalidPayloadException(`Provided diff is trying to delete field "${field}" but it does not exist. 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)
+            relation += `-> ${diffRelation.related_collection}`;
+        if (diffRelation.diff[0]?.kind === snapshot_1.DiffKind.NEW) {
+            const existingRelation = currentSnapshotWithHash.relations.find((r) => r.collection === diffRelation.collection && r.field === diffRelation.field);
+            if (existingRelation) {
+                throw new index_1.InvalidPayloadException(`Provided diff is trying to create relation "${relation}" but it already exists. Please generate a new diff and try again.`);
+            }
+        }
+        else if (diffRelation.diff[0]?.kind === snapshot_1.DiffKind.DELETE) {
+            const existingRelation = currentSnapshotWithHash.relations.find((r) => r.collection === diffRelation.collection && r.field === diffRelation.field);
+            if (!existingRelation) {
+                throw new index_1.InvalidPayloadException(`Provided diff is trying to delete relation "${relation}" but it does not exist. Please generate a new diff and try again.`);
+            }
+        }
+    }
+    throw new index_1.InvalidPayloadException(`Provided hash does not match the current instance's schema hash, indicating the schema has changed after this diff was generated. Please generate a new diff and try again.`);
+}
+exports.validateApplyDiff = validateApplyDiff;

package/dist/utils/validate-diff.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/validate-keys.d.ts

@@ -1,5 +1,5 @@
-import { SchemaOverview } from '@directus/shared/types';
-import { PrimaryKey } from '../types';
+import type { SchemaOverview } from '@directus/shared/types';
+import type { PrimaryKey } from '../types';
 /**
  * Validate keys based on its type
  */

package/dist/utils/validate-keys.js

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateKeys = void 0;
-const exceptions_1 = require("../exceptions");
 const uuid_validate_1 = __importDefault(require("uuid-validate"));
+const exceptions_1 = require("../exceptions");
 /**
  * Validate keys based on its type
  */

package/dist/utils/validate-query.d.ts

@@ -1,2 +1,2 @@
-import { Query } from '@directus/shared/types';
+import type { Query } from '@directus/shared/types';
 export declare function validateQuery(query: Query): Query;

package/dist/utils/validate-query.js

@@ -6,10 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateQuery = void 0;
 const joi_1 = __importDefault(require("joi"));
 const lodash_1 = require("lodash");
-const exceptions_1 = require("../exceptions");
 const wellknown_1 = require("wellknown");
-const calculate_field_depth_1 = require("./calculate-field-depth");
 const env_1 = __importDefault(require("../env"));
+const exceptions_1 = require("../exceptions");
+const calculate_field_depth_1 = require("./calculate-field-depth");
 const querySchema = joi_1.default.object({
     fields: joi_1.default.array().items(joi_1.default.string()),
     group: joi_1.default.array().items(joi_1.default.string()),
@@ -20,7 +20,7 @@ const querySchema = joi_1.default.object({
     page: joi_1.default.number().integer().min(0),
     meta: joi_1.default.array().items(joi_1.default.string().valid('total_count', 'filter_count')),
     search: joi_1.default.string(),
-    export: joi_1.default.string().valid('json', 'csv', 'xml'),
+    export: joi_1.default.string().valid('csv', 'json', 'xml', 'yaml'),
     aggregate: joi_1.default.object(),
     deep: joi_1.default.object(),
     alias: joi_1.default.object(),

package/dist/utils/validate-query.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/validate-snapshot.d.ts

@@ -0,0 +1,5 @@
+import { Snapshot } from '../types';
+/**
+ * Validates the snapshot against the current instance.
+ **/
+export declare function validateSnapshot(snapshot: Snapshot, force?: boolean): void;