directus 9.22.4 → 9.23.3

package/dist/utils/apply-diff.js

@@ -0,0 +1,256 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNestedMetaUpdate = exports.applyDiff = void 0;
+const deep_diff_1 = require("deep-diff");
+const lodash_1 = require("lodash");
+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) {
+    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,
+        bypassEmitAction: (params) => nestedActionEvents.push(params),
+    };
+    await database.transaction(async (trx) => {
+        const collectionsService = new services_1.CollectionsService({ knex: trx, schema });
+        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?.[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) => {
+                        // 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(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 {
+                            return fieldDiff;
+                        }
+                    });
+                    try {
+                        await collectionsService.createOne({
+                            ...diff[0].rhs,
+                            fields,
+                        }, mutationOptions);
+                    }
+                    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));
+                }
+            }
+        };
+        const deleteCollections = async (collections) => {
+            for (const { collection, diff } of collections) {
+                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 });
+                        for (const relation of relations) {
+                            try {
+                                await relationsService.deleteOne(relation.collection, relation.field, mutationOptions);
+                            }
+                            catch (err) {
+                                logger_1.default.error(`Failed to delete collection "${collection}" due to relation "${relation.collection}.${relation.field}"`);
+                                throw err;
+                            }
+                        }
+                        // clean up deleted relations from existing schema
+                        schema.relations = schema.relations.filter((r) => r.related_collection !== collection && r.collection !== collection);
+                    }
+                    await deleteCollections(getNestedCollectionsToDelete(collection));
+                    try {
+                        await collectionsService.deleteOne(collection, mutationOptions);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to delete collection "${collection}"`);
+                        throw err;
+                    }
+                }
+            }
+        };
+        // Finds all collections that need to be created
+        const filterCollectionsForCreation = ({ diff }) => {
+            // Check new collections only
+            const isNewCollection = diff[0].kind === types_1.DiffKind.NEW;
+            if (!isNewCollection)
+                return false;
+            // Create now if no group
+            const groupName = diff[0].rhs.meta?.group;
+            if (!groupName)
+                return true;
+            // Check if parent collection already exists in schema
+            const parentExists = currentSnapshot.collections.find((c) => c.collection === groupName) !== undefined;
+            // If this is a new collection and the parent collection doesn't exist in current schema ->
+            // Check if the parent collection will be created as part of applying this snapshot ->
+            // If yes -> this collection will be created recursively
+            // If not -> create now
+            // (ex.)
+            // TopLevelCollection - I exist in current schema
+            // 		NestedCollection - I exist in snapshotDiff as a new collection
+            //			TheCurrentCollectionInIteration - I exist in snapshotDiff as a new collection but will be created as part of NestedCollection
+            const parentWillBeCreatedInThisApply = snapshotDiff.collections.filter(({ collection, diff }) => diff[0].kind === types_1.DiffKind.NEW && collection === groupName).length > 0;
+            // Has group, but parent is not new, parent is also not being created in this snapshot apply
+            if (parentExists && !parentWillBeCreatedInThisApply)
+                return true;
+            return false;
+        };
+        // Create top level collections (no group, or highest level in existing group) first,
+        // 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 }) => diff[0].kind === types_1.DiffKind.DELETE && diff[0].lhs.meta?.group === null));
+        for (const { collection, diff } of snapshotDiff.collections) {
+            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;
+                });
+                if (currentCollection) {
+                    try {
+                        const newValues = diff.reduce((acc, currentDiff) => {
+                            (0, deep_diff_1.applyChange)(acc, undefined, currentDiff);
+                            return acc;
+                        }, (0, lodash_1.cloneDeep)(currentCollection));
+                        await collectionsService.updateOne(collection, newValues, mutationOptions);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to update collection "${collection}"`);
+                        throw err;
+                    }
+                }
+            }
+        }
+        const fieldsService = new services_1.FieldsService({
+            knex: trx,
+            schema: await (0, get_schema_1.getSchema)({ database: trx, bypassCache: true }),
+        });
+        for (const { collection, field, diff } of snapshotDiff.fields) {
+            if (diff?.[0].kind === types_1.DiffKind.NEW && !isNestedMetaUpdate(diff?.[0])) {
+                try {
+                    await fieldsService.createField(collection, diff[0].rhs, undefined, mutationOptions);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to create field "${collection}.${field}"`);
+                    throw err;
+                }
+            }
+            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;
+                });
+                if (currentField) {
+                    try {
+                        const newValues = diff.reduce((acc, currentDiff) => {
+                            (0, deep_diff_1.applyChange)(acc, undefined, currentDiff);
+                            return acc;
+                        }, (0, lodash_1.cloneDeep)(currentField));
+                        await fieldsService.updateField(collection, newValues, mutationOptions);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to update field "${collection}.${field}"`);
+                        throw err;
+                    }
+                }
+            }
+            if (diff?.[0].kind === types_1.DiffKind.DELETE && !isNestedMetaUpdate(diff?.[0])) {
+                try {
+                    await fieldsService.deleteField(collection, field, mutationOptions);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to delete field "${collection}.${field}"`);
+                    throw err;
+                }
+                // Field deletion also cleans up the relationship. We should ignore any relationship
+                // changes attached to this now non-existing field
+                snapshotDiff.relations = snapshotDiff.relations.filter((relation) => (relation.collection === collection && relation.field === field) === false);
+            }
+        }
+        const relationsService = new services_1.RelationsService({
+            knex: trx,
+            schema: await (0, get_schema_1.getSchema)({ database: trx, bypassCache: true }),
+        });
+        for (const { collection, field, diff } of snapshotDiff.relations) {
+            const structure = {};
+            for (const diffEdit of diff) {
+                (0, lodash_1.set)(structure, diffEdit.path, undefined);
+            }
+            if (diff?.[0].kind === types_1.DiffKind.NEW) {
+                try {
+                    await relationsService.createOne(diff[0].rhs, mutationOptions);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to create relation "${collection}.${field}"`);
+                    throw err;
+                }
+            }
+            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;
+                });
+                if (currentRelation) {
+                    try {
+                        const newValues = diff.reduce((acc, currentDiff) => {
+                            (0, deep_diff_1.applyChange)(acc, undefined, currentDiff);
+                            return acc;
+                        }, (0, lodash_1.cloneDeep)(currentRelation));
+                        await relationsService.updateOne(collection, field, newValues, mutationOptions);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to update relation "${collection}.${field}"`);
+                        throw err;
+                    }
+                }
+            }
+            if (diff?.[0].kind === types_1.DiffKind.DELETE) {
+                try {
+                    await relationsService.deleteOne(collection, field, mutationOptions);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to delete relation "${collection}.${field}"`);
+                    throw err;
+                }
+            }
+        }
+    });
+    await (0, cache_1.clearSystemCache)();
+    if (nestedActionEvents.length > 0) {
+        const updatedSchema = await (0, get_schema_1.getSchema)({ database, bypassCache: true });
+        for (const nestedActionEvent of nestedActionEvents) {
+            nestedActionEvent.context.schema = updatedSchema;
+            emitter_1.default.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
+        }
+    }
+}
+exports.applyDiff = applyDiff;
+function isNestedMetaUpdate(diff) {
+    if (!diff)
+        return false;
+    if (diff.kind !== types_1.DiffKind.NEW && diff.kind !== types_1.DiffKind.DELETE)
+        return false;
+    if (!diff.path || diff.path.length < 2 || diff.path[0] !== 'meta')
+        return false;
+    return true;
+}
+exports.isNestedMetaUpdate = isNestedMetaUpdate;

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

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

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,18 +20,17 @@ 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;
-    if (query.sort && !(options === null || options === void 0 ? void 0 : options.isInnerQuery) && !(options === null || options === void 0 ? void 0 : options.hasMultiRelationalSort)) {
-        applySort(knex, schema, dbQuery, query.sort, collection, aliasMap);
-    }
     applyLimit(knex, dbQuery, query.limit);
     if (query.offset) {
         applyOffset(knex, dbQuery, query.offset);
     }
     if (query.page && query.limit && query.limit !== -1) {
-        dbQuery.offset(query.limit * (query.page - 1));
+        applyOffset(knex, dbQuery, query.limit * (query.page - 1));
+    }
+    if (query.sort && !options?.isInnerQuery && !options?.hasMultiRelationalSort) {
+        applySort(knex, schema, dbQuery, query.sort, collection, aliasMap);
     }
     if (query.search) {
         applySearch(schema, dbQuery, query.search, collection);
@@ -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),
@@ -170,6 +168,8 @@ function applySort(knex, schema, rootQuery, rootSort, collection, aliasMap, retu
     });
     if (returnRecords)
         return { sortRecords, hasMultiRelationalSort };
+    // Clears the order if any, eg: from MSSQL offset
+    rootQuery.clear('order');
     rootQuery.orderBy(sortRecords);
 }
 exports.applySort = applySort;
@@ -223,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
@@ -265,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;
@@ -333,12 +332,12 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap)
             }
             if (operator === '_empty' || (operator === '_nempty' && compareValue === false)) {
                 dbQuery[logical].andWhere((query) => {
-                    query.where(key, '=', '');
+                    query.whereNull(key).orWhere(key, '=', '');
                 });
             }
             if (operator === '_nempty' || (operator === '_empty' && compareValue === false)) {
                 dbQuery[logical].andWhere((query) => {
-                    query.where(key, '!=', '');
+                    query.whereNotNull(key).orWhere(key, '!=', '');
                 });
             }
             // The following fields however, require a value to be run. If no value is passed, we

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

@@ -1,11 +1,9 @@
-import { SchemaOverview } from '@directus/shared/types';
-import { Diff } from 'deep-diff';
-import { Knex } from 'knex';
-import { Snapshot, SnapshotDiff, SnapshotField } 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;
     current?: Snapshot;
     diff?: SnapshotDiff;
 }): Promise<void>;
-export declare function isNestedMetaUpdate(diff: Diff<SnapshotField | undefined>): boolean;