directus 9.22.4 → 9.23.1

package/dist/utils/get-milliseconds.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMilliseconds = void 0;
+const ms_1 = __importDefault(require("ms"));
+function getMilliseconds(value, fallback = undefined) {
+    var _a;
+    if ((typeof value !== 'string' && typeof value !== 'number') || value === '') {
+        return fallback;
+    }
+    return (_a = (0, ms_1.default)(String(value))) !== null && _a !== void 0 ? _a : fallback;
+}
+exports.getMilliseconds = getMilliseconds;

package/dist/utils/get-milliseconds.test.d.ts

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

package/dist/utils/get-snapshot-diff.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSnapshotDiff = void 0;
 const deep_diff_1 = require("deep-diff");
 const lodash_1 = require("lodash");
+const types_1 = require("../types");
+const sanitize_schema_1 = require("./sanitize-schema");
 function getSnapshotDiff(current, after) {
     const diffedSnapshot = {
         collections: (0, lodash_1.orderBy)([
@@ -10,7 +12,7 @@ function getSnapshotDiff(current, after) {
                 const afterCollection = after.collections.find((afterCollection) => afterCollection.collection === currentCollection.collection);
                 return {
                     collection: currentCollection.collection,
-                    diff: (0, deep_diff_1.diff)(currentCollection, afterCollection),
+                    diff: (0, deep_diff_1.diff)((0, sanitize_schema_1.sanitizeCollection)(currentCollection), (0, sanitize_schema_1.sanitizeCollection)(afterCollection)),
                 };
             }),
             ...after.collections
@@ -20,16 +22,18 @@ function getSnapshotDiff(current, after) {
             })
                 .map((afterCollection) => ({
                 collection: afterCollection.collection,
-                diff: (0, deep_diff_1.diff)(undefined, afterCollection),
+                diff: (0, deep_diff_1.diff)(undefined, (0, sanitize_schema_1.sanitizeCollection)(afterCollection)),
             })),
         ].filter((obj) => Array.isArray(obj.diff)), 'collection'),
         fields: (0, lodash_1.orderBy)([
             ...current.fields.map((currentField) => {
+                var _a, _b;
                 const afterField = after.fields.find((afterField) => afterField.collection === currentField.collection && afterField.field === currentField.field);
+                const isAutoIncrementPrimaryKey = !!((_a = currentField.schema) === null || _a === void 0 ? void 0 : _a.is_primary_key) && !!((_b = currentField.schema) === null || _b === void 0 ? void 0 : _b.has_auto_increment);
                 return {
                     collection: currentField.collection,
                     field: currentField.field,
-                    diff: (0, deep_diff_1.diff)(currentField, afterField),
+                    diff: (0, deep_diff_1.diff)((0, sanitize_schema_1.sanitizeField)(currentField, isAutoIncrementPrimaryKey), (0, sanitize_schema_1.sanitizeField)(afterField, isAutoIncrementPrimaryKey)),
                 };
             }),
             ...after.fields
@@ -40,7 +44,7 @@ function getSnapshotDiff(current, after) {
                 .map((afterField) => ({
                 collection: afterField.collection,
                 field: afterField.field,
-                diff: (0, deep_diff_1.diff)(undefined, afterField),
+                diff: (0, deep_diff_1.diff)(undefined, (0, sanitize_schema_1.sanitizeField)(afterField)),
             })),
         ].filter((obj) => Array.isArray(obj.diff)), ['collection']),
         relations: (0, lodash_1.orderBy)([
@@ -50,7 +54,7 @@ function getSnapshotDiff(current, after) {
                     collection: currentRelation.collection,
                     field: currentRelation.field,
                     related_collection: currentRelation.related_collection,
-                    diff: (0, deep_diff_1.diff)(currentRelation, afterRelation),
+                    diff: (0, deep_diff_1.diff)((0, sanitize_schema_1.sanitizeRelation)(currentRelation), (0, sanitize_schema_1.sanitizeRelation)(afterRelation)),
                 };
             }),
             ...after.relations
@@ -62,7 +66,7 @@ function getSnapshotDiff(current, after) {
                 collection: afterRelation.collection,
                 field: afterRelation.field,
                 related_collection: afterRelation.related_collection,
-                diff: (0, deep_diff_1.diff)(undefined, afterRelation),
+                diff: (0, deep_diff_1.diff)(undefined, (0, sanitize_schema_1.sanitizeRelation)(afterRelation)),
             })),
         ].filter((obj) => Array.isArray(obj.diff)), ['collection']),
     };
@@ -70,7 +74,7 @@ function getSnapshotDiff(current, after) {
      * When you delete a collection, we don't have to individually drop all the fields/relations as well
      */
     const deletedCollections = diffedSnapshot.collections
-        .filter((collection) => { var _a; return ((_a = collection.diff) === null || _a === void 0 ? void 0 : _a[0].kind) === 'D'; })
+        .filter((collection) => { var _a; return ((_a = collection.diff) === null || _a === void 0 ? void 0 : _a[0].kind) === types_1.DiffKind.DELETE; })
         .map(({ collection }) => collection);
     diffedSnapshot.fields = diffedSnapshot.fields.filter((field) => deletedCollections.includes(field.collection) === false);
     diffedSnapshot.relations = diffedSnapshot.relations.filter((relation) => deletedCollections.includes(relation.collection) === false);

package/dist/utils/get-snapshot.js

@@ -1,17 +1,39 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSnapshot = void 0;
-const database_1 = __importDefault(require("../database"));
+const database_1 = __importStar(require("../database"));
 const get_schema_1 = require("./get-schema");
 const services_1 = require("../services");
 const package_json_1 = require("../../package.json");
 const lodash_1 = require("lodash");
+const sanitize_schema_1 = require("./sanitize-schema");
 async function getSnapshot(options) {
     var _a, _b;
     const database = (_a = options === null || options === void 0 ? void 0 : options.database) !== null && _a !== void 0 ? _a : (0, database_1.default)();
+    const vendor = (0, database_1.getDatabaseClient)(database);
     const schema = (_b = options === null || options === void 0 ? void 0 : options.schema) !== null && _b !== void 0 ? _b : (await (0, get_schema_1.getSchema)({ database, bypassCache: true }));
     const collectionsService = new services_1.CollectionsService({ knex: database, schema });
     const fieldsService = new services_1.FieldsService({ knex: database, schema });
@@ -30,9 +52,10 @@ async function getSnapshot(options) {
     return {
         version: 1,
         directus: package_json_1.version,
-        collections: collectionsSorted,
-        fields: fieldsSorted,
-        relations: relationsSorted,
+        vendor,
+        collections: collectionsSorted.map((collection) => (0, sanitize_schema_1.sanitizeCollection)(collection)),
+        fields: fieldsSorted.map((field) => (0, sanitize_schema_1.sanitizeField)(field)),
+        relations: relationsSorted.map((relation) => (0, sanitize_schema_1.sanitizeRelation)(relation)),
     };
 }
 exports.getSnapshot = getSnapshot;

package/dist/utils/get-versioned-hash.d.ts

@@ -0,0 +1 @@
+export declare function getVersionedHash(item: Record<string, any>): string;

package/dist/utils/get-versioned-hash.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVersionedHash = void 0;
+const object_hash_1 = __importDefault(require("object-hash"));
+const package_json_1 = require("../../package.json");
+function getVersionedHash(item) {
+    return (0, object_hash_1.default)({ item, version: package_json_1.version });
+}
+exports.getVersionedHash = getVersionedHash;

package/dist/utils/get-versioned-hash.test.d.ts

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

package/dist/utils/map-values-deep.d.ts

@@ -0,0 +1 @@
+export declare function mapValuesDeep(obj: Record<string, any>, fn: (key: string, value: any) => any): Record<string, any>;

package/dist/utils/map-values-deep.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapValuesDeep = void 0;
+function mapValuesDeep(obj, fn) {
+    return recurse(obj);
+    function recurse(obj, prefix = '') {
+        if (Array.isArray(obj)) {
+            return obj.map((value, index) => {
+                if (typeof value === 'object' && value !== null) {
+                    return recurse(value, prefix + `[${index}]`);
+                }
+                else {
+                    return fn(prefix + `[${index}]`, value);
+                }
+            });
+        }
+        else {
+            return Object.fromEntries(Object.entries(obj).map(([key, value]) => {
+                if (typeof value === 'object' && value !== null) {
+                    return [key, recurse(value, prefix + (prefix ? '.' : '') + key)];
+                }
+                else {
+                    return [key, fn(prefix + (prefix ? '.' : '') + key, value)];
+                }
+            }));
+        }
+    }
+}
+exports.mapValuesDeep = mapValuesDeep;

package/dist/utils/map-values-deep.test.d.ts

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

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

@@ -0,0 +1,30 @@
+import { Field, Relation } from '@directus/shared/types';
+import { 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/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/url.js

@@ -49,12 +49,8 @@ class Url {
         const host = (_a = this.host) !== null && _a !== void 0 ? _a : '';
         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/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,114 @@
+"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(),
+            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) {
+    var _a, _b, _c, _d, _e, _f;
+    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 (((_a = diffCollection.diff[0]) === null || _a === void 0 ? void 0 : _a.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 (((_b = diffCollection.diff[0]) === null || _b === void 0 ? void 0 : _b.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 (((_c = diffField.diff[0]) === null || _c === void 0 ? void 0 : _c.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 (((_d = diffField.diff[0]) === null || _d === void 0 ? void 0 : _d.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 (((_e = diffRelation.diff[0]) === null || _e === void 0 ? void 0 : _e.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 (((_f = diffRelation.diff[0]) === null || _f === void 0 ? void 0 : _f.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-query.js

@@ -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;

package/dist/utils/validate-snapshot.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSnapshot = void 0;
+const package_json_1 = require("../../package.json");
+const exceptions_1 = require("../exceptions");
+const database_1 = require("../database");
+const joi_1 = __importDefault(require("joi"));
+const constants_1 = require("@directus/shared/constants");
+const constants_2 = require("../constants");
+const types_1 = require("../types");
+const snapshotJoiSchema = joi_1.default.object({
+    version: joi_1.default.number().valid(1).required(),
+    directus: joi_1.default.string().required(),
+    vendor: joi_1.default.string()
+        .valid(...types_1.DatabaseClients)
+        .optional(),
+    collections: joi_1.default.array().items(joi_1.default.object({
+        collection: joi_1.default.string(),
+        meta: joi_1.default.any(),
+        schema: joi_1.default.object({
+            name: joi_1.default.string(),
+        }),
+    })),
+    fields: joi_1.default.array().items(joi_1.default.object({
+        collection: joi_1.default.string(),
+        field: joi_1.default.string(),
+        meta: joi_1.default.any(),
+        schema: joi_1.default.object({
+            default_value: joi_1.default.any(),
+            max_length: [joi_1.default.number(), joi_1.default.string(), joi_1.default.valid(null)],
+            is_nullable: joi_1.default.bool(),
+        })
+            .unknown()
+            .allow(null),
+        type: joi_1.default.string()
+            .valid(...constants_1.TYPES, ...constants_2.ALIAS_TYPES)
+            .allow(null),
+    })),
+    relations: joi_1.default.array().items(joi_1.default.object({
+        collection: joi_1.default.string(),
+        field: joi_1.default.string(),
+        meta: joi_1.default.any(),
+        related_collection: joi_1.default.any(),
+        schema: joi_1.default.any(),
+    })),
+});
+/**
+ * Validates the snapshot against the current instance.
+ **/
+function validateSnapshot(snapshot, force = false) {
+    const { error } = snapshotJoiSchema.validate(snapshot);
+    if (error)
+        throw new exceptions_1.InvalidPayloadException(error.message);
+    // Bypass checks when "force" option is enabled
+    if (force)
+        return;
+    if (snapshot.directus !== package_json_1.version) {
+        throw new exceptions_1.InvalidPayloadException(`Provided snapshot's directus version ${snapshot.directus} does not match the current instance's version ${package_json_1.version}. You can bypass this check by passing the "force" query parameter.`);
+    }
+    if (!snapshot.vendor) {
+        throw new exceptions_1.InvalidPayloadException('Provided snapshot does not contain the "vendor" property. You can bypass this check by passing the "force" query parameter.');
+    }
+    const currentVendor = (0, database_1.getDatabaseClient)();
+    if (snapshot.vendor !== currentVendor) {
+        throw new exceptions_1.InvalidPayloadException(`Provided snapshot's vendor ${snapshot.vendor} does not match the current instance's vendor ${currentVendor}. You can bypass this check by passing the "force" query parameter.`);
+    }
+}
+exports.validateSnapshot = validateSnapshot;

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

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

package/dist/utils/with-timeout.d.ts

@@ -0,0 +1 @@
+export declare const withTimeout: <T extends (...args: any[]) => Promise<unknown>>(prom: T, ms: number, err?: Error) => T;

package/dist/utils/with-timeout.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTimeout = void 0;
+const withTimeout = (prom, ms, err = new Error('Promise execution timed out')) => {
+    return ((...args) => {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                reject(err);
+            }, ms);
+            prom(...args)
+                .then(resolve)
+                .catch(reject);
+        });
+    });
+};
+exports.withTimeout = withTimeout;

package/dist/webhooks.js

@@ -7,9 +7,10 @@ exports.unregister = exports.register = exports.reload = exports.init = void 0;
 const database_1 = __importDefault(require("./database"));
 const emitter_1 = __importDefault(require("./emitter"));
 const logger_1 = __importDefault(require("./logger"));
+const messenger_1 = require("./messenger");
+const index_1 = require("./request/index");
 const services_1 = require("./services");
 const get_schema_1 = require("./utils/get-schema");
-const messenger_1 = require("./messenger");
 const job_queue_1 = require("./utils/job-queue");
 let registered = [];
 const reloadQueue = new job_queue_1.JobQueue();
@@ -52,9 +53,9 @@ function unregister() {
 exports.unregister = unregister;
 function createHandler(webhook, event) {
     return async (meta, context) => {
-        const axios = (await import('axios')).default;
         if (webhook.collections.includes(meta.collection) === false)
             return;
+        const axios = await (0, index_1.getAxios)();
         const webhookPayload = {
             event,
             accountability: context.accountability