directus 9.10.0 → 9.12.0

package/dist/services/webhooks.js

@@ -1,40 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebhooksService = void 0;
-const webhooks_1 = require("../webhooks");
 const items_1 = require("./items");
+const messenger_1 = require("../messenger");
 class WebhooksService extends items_1.ItemsService {
     constructor(options) {
         super('directus_webhooks', options);
+        this.messenger = (0, messenger_1.getMessenger)();
     }
     async createOne(data, opts) {
         const result = await super.createOne(data, opts);
-        await (0, webhooks_1.register)();
+        this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
     async createMany(data, opts) {
         const result = await super.createMany(data, opts);
-        await (0, webhooks_1.register)();
+        this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
     async updateOne(key, data, opts) {
         const result = await super.updateOne(key, data, opts);
-        await (0, webhooks_1.register)();
+        this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
     async updateMany(keys, data, opts) {
         const result = await super.updateMany(keys, data, opts);
-        await (0, webhooks_1.register)();
+        this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
     async deleteOne(key, opts) {
         const result = await super.deleteOne(key, opts);
-        await (0, webhooks_1.register)();
+        this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
     async deleteMany(keys, opts) {
         const result = await super.deleteMany(keys, opts);
-        await (0, webhooks_1.register)();
+        this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
 }

package/dist/types/events.d.ts

@@ -0,0 +1,18 @@
+import { ActionHandler, FilterHandler, InitHandler } from '@directus/shared/types';
+import { ScheduledTask } from 'node-cron';
+export declare type EventHandler = {
+    type: 'filter';
+    name: string;
+    handler: FilterHandler;
+} | {
+    type: 'action';
+    name: string;
+    handler: ActionHandler;
+} | {
+    type: 'init';
+    name: string;
+    handler: InitHandler;
+} | {
+    type: 'schedule';
+    task: ScheduledTask;
+};

package/dist/types/events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -1,8 +1,8 @@
-export * from './activity';
 export * from './assets';
 export * from './ast';
 export * from './auth';
 export * from './collection';
+export * from './events';
 export * from './files';
 export * from './graphql';
 export * from './items';

package/dist/types/index.js

@@ -10,11 +10,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./activity"), exports);
 __exportStar(require("./assets"), exports);
 __exportStar(require("./ast"), exports);
 __exportStar(require("./auth"), exports);
 __exportStar(require("./collection"), exports);
+__exportStar(require("./events"), exports);
 __exportStar(require("./files"), exports);
 __exportStar(require("./graphql"), exports);
 __exportStar(require("./items"), exports);

package/dist/utils/apply-query.js

@@ -4,15 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyAggregate = exports.applySearch = exports.applyFilter = exports.applySort = void 0;
-const utils_1 = require("@directus/shared/utils");
 const lodash_1 = require("lodash");
 const nanoid_1 = require("nanoid");
 const uuid_validate_1 = __importDefault(require("uuid-validate"));
 const helpers_1 = require("../database/helpers");
-const exceptions_1 = require("../exceptions");
+const invalid_query_1 = require("../exceptions/invalid-query");
 const get_column_1 = require("./get-column");
 const get_column_path_1 = require("./get-column-path");
 const get_relation_info_1 = require("./get-relation-info");
+const utils_1 = require("@directus/shared/utils");
 const generateAlias = (0, nanoid_1.customAlphabet)('abcdefghijklmnopqrstuvwxyz', 5);
 /**
  * Apply the Query to a given Knex query builder instance
@@ -65,7 +65,7 @@ function addJoin({ path, collection, aliasMap, rootQuery, subQuery, schema, rela
         if (relationType === 'a2o') {
             const pathScope = pathParts[0].split(':')[1];
             if (!pathScope) {
-                throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
+                throw new invalid_query_1.InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
             }
             rootQuery.leftJoin({ [alias]: pathScope }, (joinClause) => {
                 joinClause
@@ -92,7 +92,7 @@ function addJoin({ path, collection, aliasMap, rootQuery, subQuery, schema, rela
             else if (relationType === 'a2o') {
                 const pathScope = pathParts[0].split(':')[1];
                 if (!pathScope) {
-                    throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
+                    throw new invalid_query_1.InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
                 }
                 parent = pathScope;
             }
@@ -314,24 +314,48 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             if (operator === '_neq') {
                 dbQuery[logical].whereNot(selectionRaw, compareValue);
             }
+            if (operator === '_ieq') {
+                dbQuery[logical].whereRaw(`LOWER(??) = ?`, [selectionRaw, `${compareValue.toLowerCase()}`]);
+            }
+            if (operator === '_nieq') {
+                dbQuery[logical].whereRaw(`LOWER(??) <> ?`, [selectionRaw, `${compareValue.toLowerCase()}`]);
+            }
             if (operator === '_contains') {
                 dbQuery[logical].where(selectionRaw, 'like', `%${compareValue}%`);
             }
             if (operator === '_ncontains') {
                 dbQuery[logical].whereNot(selectionRaw, 'like', `%${compareValue}%`);
             }
+            if (operator === '_icontains') {
+                dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}%`]);
+            }
+            if (operator === '_nicontains') {
+                dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}%`]);
+            }
             if (operator === '_starts_with') {
                 dbQuery[logical].where(key, 'like', `${compareValue}%`);
             }
             if (operator === '_nstarts_with') {
                 dbQuery[logical].whereNot(key, 'like', `${compareValue}%`);
             }
+            if (operator === '_istarts_with') {
+                dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `${compareValue.toLowerCase()}%`]);
+            }
+            if (operator === '_nistarts_with') {
+                dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `${compareValue.toLowerCase()}%`]);
+            }
             if (operator === '_ends_with') {
                 dbQuery[logical].where(key, 'like', `%${compareValue}`);
             }
             if (operator === '_nends_with') {
                 dbQuery[logical].whereNot(key, 'like', `%${compareValue}`);
             }
+            if (operator === '_iends_with') {
+                dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}`]);
+            }
+            if (operator === '_niends_with') {
+                dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}`]);
+            }
             if (operator === '_gt') {
                 dbQuery[logical].where(selectionRaw, '>', compareValue);
             }
@@ -418,6 +442,9 @@ function applyAggregate(dbQuery, aggregate, collection) {
             if (operation === 'avgDistinct') {
                 dbQuery.avgDistinct(`${collection}.${field}`, { as: `avgDistinct->${field}` });
             }
+            if (operation === 'countAll') {
+                dbQuery.count('*', { as: 'countAll' });
+            }
             if (operation === 'count') {
                 if (field === '*') {
                     dbQuery.count('*', { as: 'count' });

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

@@ -1,7 +1,7 @@
-import { Snapshot, SnapshotDiff, SnapshotField } from '../types';
-import { Knex } from 'knex';
-import { Diff } from 'deep-diff';
 import { SchemaOverview } from '@directus/shared/types';
+import { Diff } from 'deep-diff';
+import { Knex } from 'knex';
+import { Snapshot, SnapshotDiff, SnapshotField } from '../types';
 export declare function applySnapshot(snapshot: Snapshot, options?: {
     database?: Knex;
     schema?: SchemaOverview;

package/dist/utils/apply-snapshot.js

@@ -4,13 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNestedMetaUpdate = exports.applySnapshot = void 0;
-const get_snapshot_1 = require("./get-snapshot");
-const get_snapshot_diff_1 = require("./get-snapshot-diff");
-const database_1 = __importDefault(require("../database"));
-const get_schema_1 = require("./get-schema");
-const services_1 = require("../services");
 const lodash_1 = require("lodash");
+const database_1 = __importDefault(require("../database"));
 const logger_1 = __importDefault(require("../logger"));
+const services_1 = require("../services");
+const get_schema_1 = require("./get-schema");
+const get_snapshot_1 = require("./get-snapshot");
+const get_snapshot_diff_1 = require("./get-snapshot-diff");
 async function applySnapshot(snapshot, options) {
     var _a, _b, _c, _d;
     const database = (_a = options === null || options === void 0 ? void 0 : options.database) !== null && _a !== void 0 ? _a : (0, database_1.default)();
@@ -19,55 +19,70 @@ async function applySnapshot(snapshot, options) {
     const snapshotDiff = (_d = options === null || options === void 0 ? void 0 : options.diff) !== null && _d !== void 0 ? _d : (0, get_snapshot_diff_1.getSnapshotDiff)(current, snapshot);
     await database.transaction(async (trx) => {
         const collectionsService = new services_1.CollectionsService({ knex: trx, schema });
-        for (const { collection, diff } of snapshotDiff.collections) {
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
-                try {
-                    await collectionsService.deleteOne(collection);
-                }
-                catch (err) {
-                    logger_1.default.error(`Failed to delete collection "${collection}"`);
-                    throw err;
+        const getNestedCollectionsToCreate = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => { var _a, _b; return ((_b = (_a = diff[0].rhs) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.group) === currentLevelCollection; });
+        const getNestedCollectionsToDelete = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => { var _a, _b; return ((_b = (_a = diff[0].lhs) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.group) === currentLevelCollection; });
+        const createCollections = async (collections) => {
+            for (const { collection, diff } of collections) {
+                if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N' && diff[0].rhs) {
+                    // We'll nest the to-be-created fields in the same collection creation, to prevent
+                    // creating a collection without a primary key
+                    const fields = snapshotDiff.fields
+                        .filter((fieldDiff) => fieldDiff.collection === collection)
+                        .map((fieldDiff) => fieldDiff.diff[0].rhs)
+                        .map((fieldDiff) => {
+                        // Casts field type to UUID when applying SQLite-based schema on other databases.
+                        // This is needed because SQLite snapshots UUID fields as char with length 36, and
+                        // it will fail when trying to create relation between char field to UUID field
+                        if (!fieldDiff.schema ||
+                            fieldDiff.schema.data_type !== 'char' ||
+                            fieldDiff.schema.max_length !== 36 ||
+                            !fieldDiff.schema.foreign_key_table ||
+                            !fieldDiff.schema.foreign_key_column) {
+                            return fieldDiff;
+                        }
+                        const matchingForeignKeyTable = schema.collections[fieldDiff.schema.foreign_key_table];
+                        if (!matchingForeignKeyTable)
+                            return fieldDiff;
+                        const matchingForeignKeyField = matchingForeignKeyTable.fields[fieldDiff.schema.foreign_key_column];
+                        if (!matchingForeignKeyField || matchingForeignKeyField.type !== 'uuid')
+                            return fieldDiff;
+                        return (0, lodash_1.merge)(fieldDiff, { type: 'uuid', schema: { data_type: 'uuid', max_length: null } });
+                    });
+                    try {
+                        await collectionsService.createOne({
+                            ...diff[0].rhs,
+                            fields,
+                        });
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to create collection "${collection}"`);
+                        throw err;
+                    }
+                    // Now that the fields are in for this collection, we can strip them from the field edits
+                    snapshotDiff.fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection !== collection);
+                    await createCollections(getNestedCollectionsToCreate(collection));
                 }
             }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N' && diff[0].rhs) {
-                // We'll nest the to-be-created fields in the same collection creation, to prevent
-                // creating a collection without a primary key
-                const fields = snapshotDiff.fields
-                    .filter((fieldDiff) => fieldDiff.collection === collection)
-                    .map((fieldDiff) => fieldDiff.diff[0].rhs)
-                    .map((fieldDiff) => {
-                    // Casts field type to UUID when applying SQLite-based schema on other databases.
-                    // This is needed because SQLite snapshots UUID fields as char with length 36, and
-                    // it will fail when trying to create relation between char field to UUID field
-                    if (!fieldDiff.schema ||
-                        fieldDiff.schema.data_type !== 'char' ||
-                        fieldDiff.schema.max_length !== 36 ||
-                        !fieldDiff.schema.foreign_key_table ||
-                        !fieldDiff.schema.foreign_key_column) {
-                        return fieldDiff;
+        };
+        const deleteCollections = async (collections) => {
+            for (const { collection, diff } of collections) {
+                if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
+                    await deleteCollections(getNestedCollectionsToDelete(collection));
+                    try {
+                        await collectionsService.deleteOne(collection);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to delete collection "${collection}"`);
+                        throw err;
                     }
-                    const matchingForeignKeyTable = schema.collections[fieldDiff.schema.foreign_key_table];
-                    if (!matchingForeignKeyTable)
-                        return fieldDiff;
-                    const matchingForeignKeyField = matchingForeignKeyTable.fields[fieldDiff.schema.foreign_key_column];
-                    if (!matchingForeignKeyField || matchingForeignKeyField.type !== 'uuid')
-                        return fieldDiff;
-                    return (0, lodash_1.merge)(fieldDiff, { type: 'uuid', schema: { data_type: 'uuid', max_length: null } });
-                });
-                try {
-                    await collectionsService.createOne({
-                        ...diff[0].rhs,
-                        fields,
-                    });
-                }
-                catch (err) {
-                    logger_1.default.error(`Failed to create collection "${collection}"`);
-                    throw err;
                 }
-                // Now that the fields are in for this collection, we can strip them from the field
-                // edits
-                snapshotDiff.fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection !== collection);
             }
+        };
+        // create top level collections (no group) first, then continue with nested collections recursively
+        await createCollections(snapshotDiff.collections.filter(({ diff }) => { var _a; return diff[0].kind === 'N' && ((_a = diff[0].rhs.meta) === null || _a === void 0 ? void 0 : _a.group) === null; }));
+        // delete top level collections (no group) first, then continue with nested collections recursively
+        await deleteCollections(snapshotDiff.collections.filter(({ diff }) => { var _a; return diff[0].kind === 'D' && ((_a = diff[0].lhs.meta) === null || _a === void 0 ? void 0 : _a.group) === null; }));
+        for (const { collection, diff } of snapshotDiff.collections) {
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E' || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'A') {
                 const newValues = snapshot.collections.find((field) => {
                     return field.collection === collection;

package/dist/utils/construct-flow-tree.d.ts

@@ -0,0 +1,2 @@
+import { Flow, FlowRaw } from '@directus/shared/types';
+export declare function constructFlowTree(flow: FlowRaw): Flow;

package/dist/utils/construct-flow-tree.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructFlowTree = void 0;
+const lodash_1 = require("lodash");
+function constructFlowTree(flow) {
+    var _a;
+    const rootOperation = (_a = flow.operations.find((operation) => operation.id === flow.operation)) !== null && _a !== void 0 ? _a : null;
+    const operationTree = constructOperationTree(rootOperation, flow.operations);
+    const flowTree = {
+        ...(0, lodash_1.omit)(flow, 'operations'),
+        operation: operationTree,
+    };
+    return flowTree;
+}
+exports.constructFlowTree = constructFlowTree;
+function constructOperationTree(root, operations) {
+    if (root === null) {
+        return null;
+    }
+    const resolveOperation = root.resolve !== null ? operations.find((operation) => operation.id === root.resolve) : null;
+    const rejectOperation = root.reject !== null ? operations.find((operation) => operation.id === root.reject) : null;
+    if (resolveOperation === undefined || rejectOperation === undefined) {
+        throw new Error('Undefined reference in operations');
+    }
+    const operationTree = {
+        ...(0, lodash_1.omit)(root, 'flow'),
+        resolve: constructOperationTree(resolveOperation, operations),
+        reject: constructOperationTree(rejectOperation, operations),
+    };
+    return operationTree;
+}

package/dist/utils/get-accountability-for-role.d.ts

@@ -0,0 +1,7 @@
+import { Accountability, SchemaOverview } from '@directus/shared/types';
+import { Knex } from 'knex';
+export declare function getAccountabilityForRole(role: null | string, context: {
+    accountability: null | Accountability;
+    schema: SchemaOverview;
+    database: Knex;
+}): Promise<Accountability>;

package/dist/utils/get-accountability-for-role.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountabilityForRole = void 0;
+const get_permissions_1 = require("./get-permissions");
+const exceptions_1 = require("../exceptions");
+async function getAccountabilityForRole(role, context) {
+    let generatedAccountability = context.accountability;
+    if (role === null) {
+        generatedAccountability = {
+            role: null,
+            user: null,
+            admin: false,
+            app: false,
+        };
+        generatedAccountability.permissions = await (0, get_permissions_1.getPermissions)(generatedAccountability, context.schema);
+    }
+    else {
+        const roleInfo = await context.database
+            .select(['app_access', 'admin_access'])
+            .from('directus_roles')
+            .where({ id: role })
+            .first();
+        if (!roleInfo) {
+            throw new exceptions_1.InvalidConfigException(`Configured role "${role}" isn't a valid role ID or doesn't exist.`);
+        }
+        generatedAccountability = {
+            role,
+            user: null,
+            admin: roleInfo.admin_access === 1 || roleInfo.admin_access === '1' || roleInfo.admin_access === true,
+            app: roleInfo.app_access === 1 || roleInfo.app_access === '1' || roleInfo.app_access === true,
+        };
+        generatedAccountability.permissions = await (0, get_permissions_1.getPermissions)(generatedAccountability, context.schema);
+    }
+    return generatedAccountability;
+}
+exports.getAccountabilityForRole = getAccountabilityForRole;

package/dist/utils/get-ast-from-query.js

@@ -80,12 +80,6 @@ async function getASTFromQuery(collection, query, schema, options) {
                 if (name in query.alias) {
                     name = query.alias[fieldKey];
                 }
-                // check for junction alias (it is one of the value instead of the key)
-                if (Object.values(query.alias).includes(name)) {
-                    const aliasKey = Object.keys(query.alias).find((key) => { var _a; return ((_a = query.alias) === null || _a === void 0 ? void 0 : _a[key]) === name; });
-                    if (aliasKey && fieldKey !== aliasKey)
-                        name = aliasKey;
-                }
             }
             const isRelational = name.includes('.') ||
                 // We'll always treat top level o2m fields as a related item. This is an alias field, otherwise it won't return
@@ -93,7 +87,7 @@ async function getASTFromQuery(collection, query, schema, options) {
                 !!schema.relations.find((relation) => { var _a; return relation.related_collection === parentCollection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === name; });
             if (isRelational) {
                 // field is relational
-                const parts = name.split('.');
+                const parts = fieldKey.split('.');
                 let rootField = parts[0];
                 let collectionScope = null;
                 // a2o related collection scoped field selector `fields=sections.section_id:headings.title`

package/dist/utils/get-default-value.js

@@ -3,9 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const get_local_type_1 = __importDefault(require("./get-local-type"));
-const logger_1 = __importDefault(require("../logger"));
 const env_1 = __importDefault(require("../env"));
+const logger_1 = __importDefault(require("../logger"));
+const get_local_type_1 = __importDefault(require("./get-local-type"));
+const parse_json_1 = require("./parse-json");
 function getDefaultValue(column) {
     var _a;
     const type = (0, get_local_type_1.default)(column);
@@ -59,7 +60,7 @@ function castToObject(value) {
         return value;
     if (typeof value === 'string') {
         try {
-            return JSON.parse(value);
+            return (0, parse_json_1.parseJSON)(value);
         }
         catch (err) {
             if (env_1.default.NODE_ENV === 'development') {

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

@@ -1,2 +1,2 @@
-import { Permission, Accountability, SchemaOverview } from '@directus/shared/types';
+import { Accountability, Permission, SchemaOverview } from '@directus/shared/types';
 export declare function getPermissions(accountability: Accountability, schema: SchemaOverview): Promise<Permission[]>;

package/dist/utils/get-permissions.js

@@ -6,15 +6,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPermissions = void 0;
 const utils_1 = require("@directus/shared/utils");
 const lodash_1 = require("lodash");
+const object_hash_1 = __importDefault(require("object-hash"));
+const cache_1 = require("../cache");
 const database_1 = __importDefault(require("../database"));
 const app_access_permissions_1 = require("../database/system-data/app-access-permissions");
+const env_1 = __importDefault(require("../env"));
+const roles_1 = require("../services/roles");
+const users_1 = require("../services/users");
 const merge_permissions_1 = require("../utils/merge-permissions");
 const merge_permissions_for_share_1 = require("./merge-permissions-for-share");
-const users_1 = require("../services/users");
-const roles_1 = require("../services/roles");
-const cache_1 = require("../cache");
-const object_hash_1 = __importDefault(require("object-hash"));
-const env_1 = __importDefault(require("../env"));
+const parse_json_1 = require("./parse-json");
 async function getPermissions(accountability, schema) {
     const database = (0, database_1.default)();
     const { systemCache, cache } = (0, cache_1.getCache)();
@@ -84,19 +85,19 @@ function parsePermissions(permissions) {
     permissions = permissions.map((permissionRaw) => {
         const permission = (0, lodash_1.cloneDeep)(permissionRaw);
         if (permission.permissions && typeof permission.permissions === 'string') {
-            permission.permissions = JSON.parse(permission.permissions);
+            permission.permissions = (0, parse_json_1.parseJSON)(permission.permissions);
         }
         else if (permission.permissions === null) {
             permission.permissions = {};
         }
         if (permission.validation && typeof permission.validation === 'string') {
-            permission.validation = JSON.parse(permission.validation);
+            permission.validation = (0, parse_json_1.parseJSON)(permission.validation);
         }
         else if (permission.validation === null) {
             permission.validation = {};
         }
         if (permission.presets && typeof permission.presets === 'string') {
-            permission.presets = JSON.parse(permission.presets);
+            permission.presets = (0, parse_json_1.parseJSON)(permission.presets);
         }
         else if (permission.presets === null) {
             permission.presets = {};

package/dist/utils/get-schema.js

@@ -17,6 +17,7 @@ const logger_1 = __importDefault(require("../logger"));
 const services_1 = require("../services");
 const get_default_value_1 = __importDefault(require("./get-default-value"));
 const get_local_type_1 = __importDefault(require("./get-local-type"));
+const parse_json_1 = require("./parse-json");
 async function getSchema(options) {
     const database = (options === null || options === void 0 ? void 0 : options.database) || (0, database_1.default)();
     const schemaInspector = (0, schema_1.default)(database);
@@ -119,7 +120,7 @@ async function getDatabaseSchema(database, schemaInspector) {
         const type = (existing && (0, get_local_type_1.default)(column, { special })) || 'alias';
         let validation = (_a = field.validation) !== null && _a !== void 0 ? _a : null;
         if (validation && typeof validation === 'string')
-            validation = JSON.parse(validation);
+            validation = (0, parse_json_1.parseJSON)(validation);
         result.collections[field.collection].fields[field.field] = {
             field: field.field,
             defaultValue: (_b = existing === null || existing === void 0 ? void 0 : existing.defaultValue) !== null && _b !== void 0 ? _b : null,

package/dist/utils/get-snapshot.js

@@ -16,17 +16,23 @@ async function getSnapshot(options) {
     const collectionsService = new services_1.CollectionsService({ knex: database, schema });
     const fieldsService = new services_1.FieldsService({ knex: database, schema });
     const relationsService = new services_1.RelationsService({ knex: database, schema });
-    const [collections, fields, relations] = await Promise.all([
+    const [collectionsRaw, fieldsRaw, relationsRaw] = await Promise.all([
         collectionsService.readByQuery(),
         fieldsService.readAll(),
         relationsService.readAll(),
     ]);
+    const collectionsFiltered = collectionsRaw.filter((item) => excludeSystem(item));
+    const fieldsFiltered = fieldsRaw.filter((item) => excludeSystem(item)).map(omitID);
+    const relationsFiltered = relationsRaw.filter((item) => excludeSystem(item)).map(omitID);
+    const collectionsSorted = (0, lodash_1.sortBy)((0, lodash_1.mapValues)(collectionsFiltered, sortDeep), ['collection']);
+    const fieldsSorted = (0, lodash_1.sortBy)((0, lodash_1.mapValues)(fieldsFiltered, sortDeep), ['collection', 'field']);
+    const relationsSorted = (0, lodash_1.sortBy)((0, lodash_1.mapValues)(relationsFiltered, sortDeep), ['collection', 'field']);
     return {
         version: 1,
         directus: package_json_1.version,
-        collections: collections.filter((item) => excludeSystem(item)),
-        fields: fields.filter((item) => excludeSystem(item)).map(omitID),
-        relations: relations.filter((item) => excludeSystem(item)).map(omitID),
+        collections: collectionsSorted,
+        fields: fieldsSorted,
+        relations: relationsSorted,
     };
 }
 exports.getSnapshot = getSnapshot;
@@ -39,3 +45,15 @@ function excludeSystem(item) {
 function omitID(item) {
     return (0, lodash_1.omit)(item, 'meta.id');
 }
+function sortDeep(raw) {
+    if ((0, lodash_1.isPlainObject)(raw)) {
+        const mapped = (0, lodash_1.mapValues)(raw, sortDeep);
+        const pairs = (0, lodash_1.toPairs)(mapped);
+        const sorted = (0, lodash_1.sortBy)(pairs);
+        return (0, lodash_1.fromPairs)(sorted);
+    }
+    if ((0, lodash_1.isArray)(raw)) {
+        return (0, lodash_1.sortBy)(raw);
+    }
+    return raw;
+}

package/dist/utils/operation-options.d.ts

@@ -0,0 +1,3 @@
+export declare function applyOperationOptions(options: Record<string, any>, data: Record<string, any>): Record<string, any>;
+export declare function optionToObject<T>(option: T): Exclude<T, string>;
+export declare function optionToString(option: unknown): string;

package/dist/utils/operation-options.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionToString = exports.optionToObject = exports.applyOperationOptions = void 0;
+const micromustache_1 = require("micromustache");
+const parse_json_1 = require("./parse-json");
+function resolveFn(path, scope) {
+    if (!scope)
+        return undefined;
+    const value = (0, micromustache_1.get)(scope, path);
+    return typeof value === 'object' ? JSON.stringify(value) : value;
+}
+function renderMustache(item, scope) {
+    if (typeof item === 'string') {
+        return (0, micromustache_1.renderFn)(item, resolveFn, scope, { explicit: true });
+    }
+    else if (Array.isArray(item)) {
+        return item.map((element) => renderMustache(element, scope));
+    }
+    else if (typeof item === 'object' && item !== null) {
+        return Object.fromEntries(Object.entries(item).map(([key, value]) => [key, renderMustache(value, scope)]));
+    }
+    else {
+        return item;
+    }
+}
+function applyOperationOptions(options, data) {
+    return Object.fromEntries(Object.entries(options).map(([key, value]) => {
+        if (typeof value === 'string') {
+            const single = value.match(/^\{\{\s*([^}\s]+)\s*\}\}$/);
+            if (single !== null) {
+                return [key, (0, micromustache_1.get)(data, single[1])];
+            }
+        }
+        return [key, renderMustache(value, data)];
+    }));
+}
+exports.applyOperationOptions = applyOperationOptions;
+function optionToObject(option) {
+    return typeof option === 'string' ? (0, parse_json_1.parseJSON)(option) : option;
+}
+exports.optionToObject = optionToObject;
+function optionToString(option) {
+    return typeof option === 'object' ? JSON.stringify(option) : String(option);
+}
+exports.optionToString = optionToString;

package/dist/utils/parse-json.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Run JSON.parse, but ignore `__proto__` properties. This prevents prototype pollution attacks
+ */
+export declare function parseJSON(input: string): any;
+export declare function noproto<T>(key: string, value: T): T | void;