directus 9.23.1 → 9.23.3

package/dist/types/assets.d.ts

@@ -1,4 +1,4 @@
-import { ResizeOptions, Sharp } from 'sharp';
+import type { ResizeOptions, Sharp } from 'sharp';
 export declare const TransformationMethods: readonly ["toFormat", "jpeg", "png", "tiff", "webp", "resize", "extend", "extract", "trim", "rotate", "flip", "flop", "sharpen", "median", "blur", "flatten", "gamma", "negate", "normalise", "normalize", "clahe", "convolve", "threshold", "linear", "recomb", "modulate", "tint", "greyscale", "grayscale", "toColorspace", "toColourspace", "removeAlpha", "ensureAlpha", "extractChannel", "bandbool"];
 type AllowedSharpMethods = Pick<Sharp, (typeof TransformationMethods)[number]>;
 export type TransformationMap = {

package/dist/types/ast.d.ts

@@ -1,4 +1,4 @@
-import { Query, Relation } from '@directus/shared/types';
+import type { Query, Relation } from '@directus/shared/types';
 export type M2ONode = {
     type: 'm2o';
     name: string;

package/dist/types/auth.d.ts

@@ -1,5 +1,5 @@
-import { SchemaOverview } from '@directus/shared/types';
-import { Knex } from 'knex';
+import type { SchemaOverview } from '@directus/shared/types';
+import type { Knex } from 'knex';
 export interface AuthDriverOptions {
     knex: Knex;
     schema: SchemaOverview;

package/dist/types/collection.d.ts

@@ -1,5 +1,5 @@
-import { Table } from 'knex-schema-inspector/dist/types/table';
-import { Field } from '@directus/shared/types';
+import type { Field } from '@directus/shared/types';
+import type { Table } from 'knex-schema-inspector/dist/types/table';
 export type CollectionMeta = {
     collection: string;
     note: string | null;

package/dist/types/events.d.ts

@@ -1,5 +1,5 @@
-import { ActionHandler, FilterHandler, InitHandler } from '@directus/shared/types';
-import { ScheduledTask } from 'node-cron';
+import type { ActionHandler, FilterHandler, InitHandler } from '@directus/shared/types';
+import type { ScheduledTask } from 'node-cron';
 export type EventHandler = {
     type: 'filter';
     name: string;

package/dist/types/graphql.d.ts

@@ -1,5 +1,5 @@
-import { Request, Response } from 'express';
-import { DocumentNode } from 'graphql';
+import type { Request, Response } from 'express';
+import type { DocumentNode } from 'graphql';
 export interface GraphQLParams {
     query: string | null;
     variables: {

package/dist/types/items.d.ts

@@ -2,8 +2,8 @@
  * I know this looks a little silly, but it allows us to explicitly differentiate between when we're
  * expecting an item vs any other generic object.
  */
-import { BaseException } from '@directus/shared/exceptions';
-import { EventContext } from '@directus/shared/types';
+import type { BaseException } from '@directus/shared/exceptions';
+import type { EventContext } from '@directus/shared/types';
 export type Item = Record<string, any>;
 export type PrimaryKey = string | number;
 export type Alterations = {
@@ -31,7 +31,7 @@ export type MutationOptions = {
     /**
      * Allow disabling the emitting of hooks. Useful if a custom hook is fired (like files.upload)
      */
-    emitEvents?: boolean;
+    emitEvents?: boolean | undefined;
     /**
      * To bypass the emitting of action events if emitEvents is enabled
      * Can be used to queue up the nested events from item service's create, update and delete

package/dist/types/services.d.ts

@@ -1,14 +1,14 @@
-import { Knex } from 'knex';
-import { Accountability, Query, SchemaOverview } from '@directus/shared/types';
-import { Item, PrimaryKey } from './items';
+import type { Accountability, Query, SchemaOverview } from '@directus/shared/types';
+import type { Knex } from 'knex';
+import type { Item, PrimaryKey } from './items';
 export type AbstractServiceOptions = {
     knex?: Knex;
-    accountability?: Accountability | null;
+    accountability?: Accountability | null | undefined;
     schema: SchemaOverview;
 };
 export interface AbstractService {
     knex: Knex;
-    accountability: Accountability | null;
+    accountability: Accountability | null | undefined;
     createOne(data: Partial<Item>): Promise<PrimaryKey>;
     createMany(data: Partial<Item>[]): Promise<PrimaryKey[]>;
     readOne(key: PrimaryKey, query?: Query): Promise<Item>;

package/dist/types/snapshot.d.ts

@@ -1,7 +1,7 @@
-import { Collection } from './collection';
-import { Relation, RelationMeta, Field, FieldMeta } from '@directus/shared/types';
-import { Diff } from 'deep-diff';
-import { DatabaseClient } from './database';
+import type { Field, FieldMeta, Relation, RelationMeta } from '@directus/shared/types';
+import type { Diff } from 'deep-diff';
+import type { Collection } from './collection';
+import type { DatabaseClient } from './database';
 export type Snapshot = {
     version: number;
     directus: string;

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

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

package/dist/utils/apply-diff.js

@@ -4,19 +4,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNestedMetaUpdate = exports.applyDiff = void 0;
-const services_1 = require("../services");
-const types_1 = require("../types");
-const get_schema_1 = require("./get-schema");
-const database_1 = __importDefault(require("../database"));
 const deep_diff_1 = require("deep-diff");
 const lodash_1 = require("lodash");
-const logger_1 = __importDefault(require("../logger"));
-const emitter_1 = __importDefault(require("../emitter"));
 const cache_1 = require("../cache");
+const database_1 = __importDefault(require("../database"));
+const emitter_1 = __importDefault(require("../emitter"));
+const logger_1 = __importDefault(require("../logger"));
+const services_1 = require("../services");
+const types_1 = require("../types");
+const get_schema_1 = require("./get-schema");
 async function applyDiff(currentSnapshot, snapshotDiff, 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 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 database = options?.database ?? (0, database_1.default)();
+    const schema = options?.schema ?? (await (0, get_schema_1.getSchema)({ database, bypassCache: true }));
     const nestedActionEvents = [];
     const mutationOptions = {
         autoPurgeSystemCache: false,
@@ -24,24 +23,23 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
     };
     await database.transaction(async (trx) => {
         const collectionsService = new services_1.CollectionsService({ knex: trx, schema });
-        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 getNestedCollectionsToCreate = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => diff[0].rhs?.meta?.group === currentLevelCollection);
+        const getNestedCollectionsToDelete = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => diff[0].lhs?.meta?.group === currentLevelCollection);
         const createCollections = async (collections) => {
             for (const { collection, diff } of collections) {
-                if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.NEW && diff[0].rhs) {
+                if (diff?.[0].kind === types_1.DiffKind.NEW && 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) => {
-                        var _a, _b, _c, _d, _e;
                         // Casts field type to UUID when applying non-PostgreSQL schema onto PostgreSQL database.
                         // This is needed because they snapshots UUID fields as char/varchar with length 36.
-                        if (['char', 'varchar'].includes(String((_a = fieldDiff.schema) === null || _a === void 0 ? void 0 : _a.data_type).toLowerCase()) &&
-                            ((_b = fieldDiff.schema) === null || _b === void 0 ? void 0 : _b.max_length) === 36 &&
-                            (((_c = fieldDiff.schema) === null || _c === void 0 ? void 0 : _c.is_primary_key) ||
-                                (((_d = fieldDiff.schema) === null || _d === void 0 ? void 0 : _d.foreign_key_table) && ((_e = fieldDiff.schema) === null || _e === void 0 ? void 0 : _e.foreign_key_column)))) {
+                        if (['char', 'varchar'].includes(String(fieldDiff.schema?.data_type).toLowerCase()) &&
+                            fieldDiff.schema?.max_length === 36 &&
+                            (fieldDiff.schema?.is_primary_key ||
+                                (fieldDiff.schema?.foreign_key_table && fieldDiff.schema?.foreign_key_column))) {
                             return (0, lodash_1.merge)(fieldDiff, { type: 'uuid', schema: { data_type: 'uuid', max_length: null } });
                         }
                         else {
@@ -66,7 +64,7 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
         };
         const deleteCollections = async (collections) => {
             for (const { collection, diff } of collections) {
-                if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.DELETE) {
+                if (diff?.[0].kind === types_1.DiffKind.DELETE) {
                     const relations = schema.relations.filter((r) => r.related_collection === collection || r.collection === collection);
                     if (relations.length > 0) {
                         const relationsService = new services_1.RelationsService({ knex: trx, schema });
@@ -95,13 +93,12 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
         };
         // Finds all collections that need to be created
         const filterCollectionsForCreation = ({ diff }) => {
-            var _a;
             // Check new collections only
             const isNewCollection = diff[0].kind === types_1.DiffKind.NEW;
             if (!isNewCollection)
                 return false;
             // Create now if no group
-            const groupName = (_a = diff[0].rhs.meta) === null || _a === void 0 ? void 0 : _a.group;
+            const groupName = diff[0].rhs.meta?.group;
             if (!groupName)
                 return true;
             // Check if parent collection already exists in schema
@@ -124,9 +121,9 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
         // then continue with nested collections recursively
         await createCollections(snapshotDiff.collections.filter(filterCollectionsForCreation));
         // 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 === types_1.DiffKind.DELETE && ((_a = diff[0].lhs.meta) === null || _a === void 0 ? void 0 : _a.group) === null; }));
+        await deleteCollections(snapshotDiff.collections.filter(({ diff }) => diff[0].kind === types_1.DiffKind.DELETE && diff[0].lhs.meta?.group === null));
         for (const { collection, diff } of snapshotDiff.collections) {
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.EDIT || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.ARRAY) {
+            if (diff?.[0].kind === types_1.DiffKind.EDIT || diff?.[0].kind === types_1.DiffKind.ARRAY) {
                 const currentCollection = currentSnapshot.collections.find((field) => {
                     return field.collection === collection;
                 });
@@ -150,7 +147,7 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
             schema: await (0, get_schema_1.getSchema)({ database: trx, bypassCache: true }),
         });
         for (const { collection, field, diff } of snapshotDiff.fields) {
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.NEW && !isNestedMetaUpdate(diff === null || diff === void 0 ? void 0 : diff[0])) {
+            if (diff?.[0].kind === types_1.DiffKind.NEW && !isNestedMetaUpdate(diff?.[0])) {
                 try {
                     await fieldsService.createField(collection, diff[0].rhs, undefined, mutationOptions);
                 }
@@ -159,7 +156,7 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
                     throw err;
                 }
             }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.EDIT || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.ARRAY || isNestedMetaUpdate(diff === null || diff === void 0 ? void 0 : diff[0])) {
+            if (diff?.[0].kind === types_1.DiffKind.EDIT || diff?.[0].kind === types_1.DiffKind.ARRAY || isNestedMetaUpdate(diff?.[0])) {
                 const currentField = currentSnapshot.fields.find((snapshotField) => {
                     return snapshotField.collection === collection && snapshotField.field === field;
                 });
@@ -177,7 +174,7 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
                     }
                 }
             }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.DELETE && !isNestedMetaUpdate(diff === null || diff === void 0 ? void 0 : diff[0])) {
+            if (diff?.[0].kind === types_1.DiffKind.DELETE && !isNestedMetaUpdate(diff?.[0])) {
                 try {
                     await fieldsService.deleteField(collection, field, mutationOptions);
                 }
@@ -199,7 +196,7 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
             for (const diffEdit of diff) {
                 (0, lodash_1.set)(structure, diffEdit.path, undefined);
             }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.NEW) {
+            if (diff?.[0].kind === types_1.DiffKind.NEW) {
                 try {
                     await relationsService.createOne(diff[0].rhs, mutationOptions);
                 }
@@ -208,7 +205,7 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
                     throw err;
                 }
             }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.EDIT || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.ARRAY) {
+            if (diff?.[0].kind === types_1.DiffKind.EDIT || diff?.[0].kind === types_1.DiffKind.ARRAY) {
                 const currentRelation = currentSnapshot.relations.find((relation) => {
                     return relation.collection === collection && relation.field === field;
                 });
@@ -226,7 +223,7 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
                     }
                 }
             }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.DELETE) {
+            if (diff?.[0].kind === types_1.DiffKind.DELETE) {
                 try {
                     await relationsService.deleteOne(collection, field, mutationOptions);
                 }

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

@@ -1,5 +1,5 @@
-import { Aggregate, Filter, Query, SchemaOverview } from '@directus/shared/types';
-import { Knex } from 'knex';
+import type { Aggregate, Filter, Query, SchemaOverview } from '@directus/shared/types';
+import type { Knex } from 'knex';
 import { AliasMap } from './get-column-path';
 export declare const generateAlias: (size?: number | undefined) => string;
 /**
@@ -8,7 +8,7 @@ export declare const generateAlias: (size?: number | undefined) => string;
 export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, options?: {
     aliasMap?: AliasMap;
     isInnerQuery?: boolean;
-    hasMultiRelationalSort?: boolean;
+    hasMultiRelationalSort?: boolean | undefined;
 }): {
     query: Knex.QueryBuilder<any, any>;
     hasMultiRelationalFilter: boolean;

package/dist/utils/apply-query.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyAggregate = exports.applySearch = exports.applyFilter = exports.applyOffset = exports.applyLimit = exports.applySort = exports.generateAlias = void 0;
+const utils_1 = require("@directus/shared/utils");
 const lodash_1 = require("lodash");
 const uuid_validate_1 = __importDefault(require("uuid-validate"));
 const helpers_1 = require("../database/helpers");
@@ -11,7 +12,6 @@ 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 strip_function_1 = require("./strip-function");
 // @ts-ignore
 const non_secure_1 = require("nanoid/non-secure");
@@ -20,8 +20,7 @@ exports.generateAlias = (0, non_secure_1.customAlphabet)('abcdefghijklmnopqrstuv
  * Apply the Query to a given Knex query builder instance
  */
 function applyQuery(knex, collection, dbQuery, query, schema, options) {
-    var _a;
-    const aliasMap = (_a = options === null || options === void 0 ? void 0 : options.aliasMap) !== null && _a !== void 0 ? _a : Object.create(null);
+    const aliasMap = options?.aliasMap ?? Object.create(null);
     let hasMultiRelationalFilter = false;
     applyLimit(knex, dbQuery, query.limit);
     if (query.offset) {
@@ -30,7 +29,7 @@ function applyQuery(knex, collection, dbQuery, query, schema, options) {
     if (query.page && query.limit && query.limit !== -1) {
         applyOffset(knex, dbQuery, query.limit * (query.page - 1));
     }
-    if (query.sort && !(options === null || options === void 0 ? void 0 : options.isInnerQuery) && !(options === null || options === void 0 ? void 0 : options.hasMultiRelationalSort)) {
+    if (query.sort && !options?.isInnerQuery && !options?.hasMultiRelationalSort) {
         applySort(knex, schema, dbQuery, query.sort, collection, aliasMap);
     }
     if (query.search) {
@@ -54,7 +53,6 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, kne
     followRelation(path);
     return hasMultiRelational;
     function followRelation(pathParts, parentCollection = collection, parentFields) {
-        var _a, _b, _c;
         /**
          * For A2M fields, the path can contain an optional collection scope <field>:<scope>
          */
@@ -64,12 +62,12 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, kne
             return;
         }
         const existingAlias = parentFields
-            ? (_a = aliasMap[`${parentFields}.${pathParts[0]}`]) === null || _a === void 0 ? void 0 : _a.alias
-            : (_b = aliasMap[pathParts[0]]) === null || _b === void 0 ? void 0 : _b.alias;
+            ? aliasMap[`${parentFields}.${pathParts[0]}`]?.alias
+            : aliasMap[pathParts[0]]?.alias;
         if (!existingAlias) {
             const alias = (0, exports.generateAlias)();
             const aliasKey = parentFields ? `${parentFields}.${pathParts[0]}` : pathParts[0];
-            const aliasedParentCollection = ((_c = aliasMap[parentFields !== null && parentFields !== void 0 ? parentFields : '']) === null || _c === void 0 ? void 0 : _c.alias) || parentCollection;
+            const aliasedParentCollection = aliasMap[parentFields ?? '']?.alias || parentCollection;
             aliasMap[aliasKey] = { alias, collection: '' };
             if (relationType === 'm2o') {
                 rootQuery.leftJoin({ [alias]: relation.related_collection }, `${aliasedParentCollection}.${relation.field}`, `${alias}.${schema.collections[relation.related_collection].primary}`);
@@ -136,7 +134,7 @@ function applySort(knex, schema, rootQuery, rootSort, collection, aliasMap, retu
         if (column.length === 1) {
             const pathRoot = column[0].split(':')[0];
             const { relation, relationType } = (0, get_relation_info_1.getRelationInfo)(relations, collection, pathRoot);
-            if (!relation || ['m2o', 'a2o'].includes(relationType !== null && relationType !== void 0 ? relationType : '')) {
+            if (!relation || ['m2o', 'a2o'].includes(relationType ?? '')) {
                 return {
                     order,
                     column: returnRecords ? column[0] : (0, get_column_1.getColumn)(knex, collection, column[0], false, schema),
@@ -225,7 +223,6 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap)
         }
     }
     function addWhereClauses(knex, dbQuery, filter, collection, logical = 'and') {
-        var _a;
         for (const [key, value] of Object.entries(filter)) {
             if (key === '_or' || key === '_and') {
                 // If the _or array contains an empty object (full permissions), we should short-circuit and ignore all other
@@ -267,7 +264,7 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap)
                             .whereNotNull(column);
                         applyQuery(knex, relation.collection, subQueryKnex, { filter }, schema);
                     };
-                    const childKey = (_a = Object.keys(value)) === null || _a === void 0 ? void 0 : _a[0];
+                    const childKey = Object.keys(value)?.[0];
                     if (childKey === '_none') {
                         dbQuery[logical].whereNotIn(pkField, subQueryBuilder(Object.values(value)[0]));
                         continue;

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

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

package/dist/utils/apply-snapshot.js

@@ -11,13 +11,12 @@ 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)();
-    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 database = options?.database ?? (0, database_1.default)();
+    const schema = options?.schema ?? (await (0, get_schema_1.getSchema)({ database, bypassCache: true }));
     const { systemCache } = (0, cache_1.getCache)();
-    const current = (_c = options === null || options === void 0 ? void 0 : options.current) !== null && _c !== void 0 ? _c : (await (0, get_snapshot_1.getSnapshot)({ database, schema }));
-    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);
+    const current = options?.current ?? (await (0, get_snapshot_1.getSnapshot)({ database, schema }));
+    const snapshotDiff = options?.diff ?? (0, get_snapshot_diff_1.getSnapshotDiff)(current, snapshot);
     await (0, apply_diff_1.applyDiff)(current, snapshotDiff, { database, schema });
-    await (systemCache === null || systemCache === void 0 ? void 0 : systemCache.clear());
+    await systemCache?.clear();
 }
 exports.applySnapshot = applySnapshot;

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

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

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

@@ -3,12 +3,12 @@ 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 rootOperation = flow.operations.find((operation) => operation.id === flow.operation) ?? null;
     const operationTree = constructOperationTree(rootOperation, flow.operations);
     const flowTree = {
         ...(0, lodash_1.omit)(flow, 'operations'),
         operation: operationTree,
+        options: flow.options ?? {},
     };
     return flowTree;
 }

package/dist/utils/filter-items.d.ts

@@ -1,2 +1,2 @@
-import { Query } from '@directus/shared/types';
+import type { Query } from '@directus/shared/types';
 export declare function filterItems(items: Record<string, any>[], filter: Query['filter']): Record<string, any>[];

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

@@ -1,5 +1,5 @@
-import { Accountability, SchemaOverview } from '@directus/shared/types';
-import { Knex } from 'knex';
+import type { Accountability, SchemaOverview } from '@directus/shared/types';
+import type { Knex } from 'knex';
 export declare function getAccountabilityForRole(role: null | string, context: {
     accountability: null | Accountability;
     schema: SchemaOverview;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAccountabilityForRole = void 0;
-const get_permissions_1 = require("./get-permissions");
 const exceptions_1 = require("../exceptions");
+const get_permissions_1 = require("./get-permissions");
 async function getAccountabilityForRole(role, context) {
     let generatedAccountability = context.accountability;
     if (role === null) {

package/dist/utils/get-ast-from-query.d.ts

@@ -1,9 +1,9 @@
 /**
  * Generate an AST based on a given collection and query
  */
-import { Knex } from 'knex';
-import { AST } from '../types';
-import { Query, PermissionsAction, Accountability, SchemaOverview } from '@directus/shared/types';
+import type { Accountability, PermissionsAction, Query, SchemaOverview } from '@directus/shared/types';
+import type { Knex } from 'knex';
+import type { AST } from '../types';
 type GetASTOptions = {
     accountability?: Accountability | null;
     action?: PermissionsAction;