@directus/api 25.0.0 → 25.0.1

package/dist/services/collections.js

@@ -15,6 +15,9 @@ import { getSchema } from '../utils/get-schema.js';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
 import { transaction } from '../utils/transaction.js';
 import { FieldsService } from './fields.js';
+import { buildCollectionAndFieldRelations } from './fields/build-collection-and-field-relations.js';
+import { getCollectionMetaUpdates } from './fields/get-collection-meta-updates.js';
+import { getCollectionRelationList } from './fields/get-collection-relation-list.js';
 import { ItemsService } from './items.js';
 export class CollectionsService {
     knex;
@@ -478,7 +481,18 @@ export class CollectionsService {
                         accountability: this.accountability,
                         schema: this.schema,
                     });
-                    await trx('directus_fields').delete().where('collection', '=', collectionKey);
+                    const fieldItemsService = new ItemsService('directus_fields', {
+                        knex: trx,
+                        accountability: this.accountability,
+                        schema: this.schema,
+                    });
+                    await fieldItemsService.deleteByQuery({
+                        filter: {
+                            collection: { _eq: collectionKey },
+                        },
+                    }, {
+                        bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
+                    });
                     await trx('directus_presets').delete().where('collection', '=', collectionKey);
                     const revisionsToDelete = await trx
                         .select('id')
@@ -494,6 +508,22 @@ export class CollectionsService {
                     await trx('directus_activity').delete().where('collection', '=', collectionKey);
                     await trx('directus_permissions').delete().where('collection', '=', collectionKey);
                     await trx('directus_relations').delete().where({ many_collection: collectionKey });
+                    const { collectionRelationTree, fieldToCollectionList } = await buildCollectionAndFieldRelations(this.schema.relations);
+                    const collectionRelationList = getCollectionRelationList(collectionKey, collectionRelationTree);
+                    // only process duplication fields if related collections have them
+                    if (collectionRelationList.size !== 0) {
+                        const collectionMetas = await trx
+                            .select('collection', 'archive_field', 'sort_field', 'item_duplication_fields')
+                            .from('directus_collections')
+                            .whereIn('collection', Array.from(collectionRelationList))
+                            .whereNotNull('item_duplication_fields');
+                        await Promise.all(Object.keys(this.schema.collections[collectionKey]?.fields ?? {}).map(async (fieldKey) => {
+                            const collectionMetaUpdates = getCollectionMetaUpdates(collectionKey, fieldKey, collectionMetas, this.schema.collections, fieldToCollectionList);
+                            for (const meta of collectionMetaUpdates) {
+                                await trx('directus_collections').update(meta.updates).where({ collection: meta.collection });
+                            }
+                        }));
+                    }
                     const relations = this.schema.relations.filter((relation) => {
                         return relation.collection === collectionKey || relation.related_collection === collectionKey;
                     });

package/dist/services/fields/build-collection-and-field-relations.d.ts

@@ -0,0 +1,21 @@
+import type { Relation } from '@directus/types';
+/**
+ * Builds two maps where collectionRelationTree is a map of collection to related collections
+ * and fieldToCollectionList is a map of field:collection to related collection.
+ *
+ * @example
+ * returns {
+ * 		collectionRelationTree: new Map([
+ * 			['B', new Set(['A'])],
+ * 			['A', new Set(['B'])],
+ * 		]),
+ * 		fieldToCollectionList: new Map([
+ * 			['B:b', 'A'],
+ * 			['A:a', 'B'],
+ * 		]),
+ * }
+ */
+export declare function buildCollectionAndFieldRelations(relations: Relation[]): {
+    collectionRelationTree: Map<string, Set<string>>;
+    fieldToCollectionList: Map<string, string>;
+};

package/dist/services/fields/build-collection-and-field-relations.js

@@ -0,0 +1,55 @@
+/**
+ * Builds two maps where collectionRelationTree is a map of collection to related collections
+ * and fieldToCollectionList is a map of field:collection to related collection.
+ *
+ * @example
+ * returns {
+ * 		collectionRelationTree: new Map([
+ * 			['B', new Set(['A'])],
+ * 			['A', new Set(['B'])],
+ * 		]),
+ * 		fieldToCollectionList: new Map([
+ * 			['B:b', 'A'],
+ * 			['A:a', 'B'],
+ * 		]),
+ * }
+ */
+export function buildCollectionAndFieldRelations(relations) {
+    // Map<Collection, Set<RelatedCollection>>
+    const collectionRelationTree = new Map();
+    // Map<Field:Collection, RelatedCollection>
+    const fieldToCollectionList = new Map();
+    for (const relation of relations) {
+        let relatedCollections = [];
+        if (relation.related_collection) {
+            relatedCollections.push(relation.related_collection);
+        }
+        else if (relation.meta?.one_collection_field && relation.meta?.one_allowed_collections) {
+            relatedCollections = relation.meta?.one_allowed_collections;
+        }
+        else {
+            // safe guard
+            continue;
+        }
+        for (const relatedCollection of relatedCollections) {
+            let fieldToCollectionListKey = relation.collection + ':' + relation.field;
+            const collectionList = collectionRelationTree.get(relatedCollection) ?? new Set();
+            collectionList.add(relation.collection);
+            // O2M can have outward duplication path
+            if (relation.meta?.one_field) {
+                const relatedfieldToCollectionListKey = relatedCollection + ':' + relation.meta.one_field;
+                const realatedCollectionList = collectionRelationTree.get(relation.collection) ?? new Set();
+                realatedCollectionList.add(relatedCollection);
+                fieldToCollectionList.set(relatedfieldToCollectionListKey, relation.collection);
+                collectionRelationTree.set(relation.collection, realatedCollectionList);
+            }
+            // m2a fields show as field:collection in duplication path
+            if (relation.meta?.one_allowed_collections) {
+                fieldToCollectionListKey += ':' + relatedCollection;
+            }
+            fieldToCollectionList.set(fieldToCollectionListKey, relatedCollection);
+            collectionRelationTree.set(relatedCollection, collectionList);
+        }
+    }
+    return { collectionRelationTree, fieldToCollectionList };
+}

package/dist/services/fields/get-collection-meta-updates.d.ts

@@ -0,0 +1,11 @@
+import type { CollectionsOverview } from '@directus/types';
+import type { Knex } from 'knex';
+export declare function getCollectionMetaUpdates(collection: string, field: string, collectionMetas: {
+    archive_field?: null | string;
+    sort_field?: null | string;
+    item_duplication_fields?: null | string | string[];
+    collection: string;
+}[], collections: CollectionsOverview, fieldToCollectionList: Map<string, string>): {
+    collection: string;
+    updates: Record<string, Knex.Value>;
+}[];

package/dist/services/fields/get-collection-meta-updates.js

@@ -0,0 +1,72 @@
+import { parseJSON } from '@directus/utils';
+export function getCollectionMetaUpdates(collection, field, collectionMetas, collections, fieldToCollectionList) {
+    const collectionMetaUpdates = [];
+    for (const collectionMeta of collectionMetas) {
+        let hasUpdates = false;
+        const meta = {
+            collection: collectionMeta.collection,
+            updates: {},
+        };
+        if (collectionMeta.collection === collection) {
+            if (collectionMeta?.archive_field === field) {
+                meta.updates['archive_field'] = null;
+                hasUpdates = true;
+            }
+            if (collectionMeta?.sort_field === field) {
+                meta.updates['sort_field'] = null;
+                hasUpdates = true;
+            }
+        }
+        if (collectionMeta?.item_duplication_fields) {
+            const itemDuplicationPaths = typeof collectionMeta.item_duplication_fields === 'string'
+                ? parseJSON(collectionMeta.item_duplication_fields)
+                : collectionMeta.item_duplication_fields;
+            const updatedPaths = [];
+            for (const path of itemDuplicationPaths) {
+                const updatedPath = updateItemDuplicationPath(path, collectionMeta.collection, field, collection, collections, fieldToCollectionList);
+                if (updatedPath && updatedPath.length !== 0) {
+                    updatedPaths.push(updatedPath.join('.'));
+                }
+            }
+            // only add updates on change
+            if (updatedPaths.length !== itemDuplicationPaths.length) {
+                meta.updates['item_duplication_fields'] = updatedPaths.length !== 0 ? JSON.stringify(updatedPaths) : null;
+                hasUpdates = true;
+            }
+        }
+        if (hasUpdates) {
+            collectionMetaUpdates.push(meta);
+        }
+    }
+    return collectionMetaUpdates;
+}
+function updateItemDuplicationPath(path, root, field, collection, collections, fieldToCollectionList) {
+    let currentCollection = root;
+    const parts = path.split('.');
+    // if the field name is not present in the path we can skip processing as no possible match
+    if ([field, `.${field}`, `.${field}.`, `${field}.`].some((fieldPart) => path.includes(fieldPart)) === false) {
+        return parts;
+    }
+    const updatedParts = [];
+    for (let index = 0; index < parts.length; index++) {
+        const part = parts[index];
+        // Invalid path for the field that is currently being removed
+        if (currentCollection === collection && part === field)
+            return;
+        const isLastPart = index === parts.length - 1;
+        const isLocalField = typeof collections[currentCollection]?.['fields'][part] !== 'undefined';
+        const nextCollectionNode = fieldToCollectionList.get(`${currentCollection}:${part}`);
+        // Invalid path for old deleted collections
+        if (!nextCollectionNode && !isLastPart)
+            return;
+        // Invalid path for old deleted fields
+        if (!nextCollectionNode && isLastPart && !isLocalField)
+            return;
+        // next/last path is relational
+        if (nextCollectionNode) {
+            currentCollection = nextCollectionNode;
+        }
+        updatedParts.push(part);
+    }
+    return updatedParts;
+}

package/dist/services/fields/get-collection-relation-list.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a list of all related collections for a given collection.
+ * Or in math terms, returns the [strongly connected component](https://en.wikipedia.org/wiki/Strongly_connected_component) that a given node belongs to.
+ */
+export declare function getCollectionRelationList(collection: string, collectionRelationTree: Map<string, Set<string>>): Set<string>;

package/dist/services/fields/get-collection-relation-list.js

@@ -0,0 +1,28 @@
+import { isSystemCollection } from '@directus/system-data';
+/**
+ * Returns a list of all related collections for a given collection.
+ * Or in math terms, returns the [strongly connected component](https://en.wikipedia.org/wiki/Strongly_connected_component) that a given node belongs to.
+ */
+export function getCollectionRelationList(collection, collectionRelationTree) {
+    const collectionRelationList = new Set();
+    traverseCollectionRelationTree(collection);
+    return collectionRelationList;
+    function traverseCollectionRelationTree(root) {
+        const relationTree = collectionRelationTree.get(root);
+        if (!relationTree)
+            return;
+        for (const relationNode of relationTree) {
+            addRelationNode(relationNode);
+        }
+    }
+    function addRelationNode(node) {
+        // system collections cannot have duplication fields and therfore can be skipped
+        if (isSystemCollection(node))
+            return;
+        // skip circular reference and existing linked nodes
+        if (node === collection || collectionRelationList.has(node))
+            return;
+        collectionRelationList.add(node);
+        traverseCollectionRelationTree(node);
+    }
+}

package/dist/services/fields.js

@@ -20,6 +20,9 @@ import { getSchema } from '../utils/get-schema.js';
 import { sanitizeColumn } from '../utils/sanitize-schema.js';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
 import { transaction } from '../utils/transaction.js';
+import { buildCollectionAndFieldRelations } from './fields/build-collection-and-field-relations.js';
+import { getCollectionMetaUpdates } from './fields/get-collection-meta-updates.js';
+import { getCollectionRelationList } from './fields/get-collection-relation-list.js';
 import { ItemsService } from './items.js';
 import { PayloadService } from './payload.js';
 import { RelationsService } from './relations.js';
@@ -556,20 +559,22 @@ export class FieldsService {
                         table.dropColumn(field);
                     });
                 }
-                const collectionMeta = await trx
-                    .select('archive_field', 'sort_field')
+                const { collectionRelationTree, fieldToCollectionList } = await buildCollectionAndFieldRelations(this.schema.relations);
+                const collectionRelationList = getCollectionRelationList(collection, collectionRelationTree);
+                const collectionMetaQuery = trx
+                    .queryBuilder()
+                    .select('collection', 'archive_field', 'sort_field', 'item_duplication_fields')
                     .from('directus_collections')
-                    .where({ collection })
-                    .first();
-                const collectionMetaUpdates = {};
-                if (collectionMeta?.archive_field === field) {
-                    collectionMetaUpdates['archive_field'] = null;
-                }
-                if (collectionMeta?.sort_field === field) {
-                    collectionMetaUpdates['sort_field'] = null;
+                    .where({ collection });
+                if (collectionRelationList.size !== 0) {
+                    collectionMetaQuery.orWhere(function () {
+                        this.whereIn('collection', Array.from(collectionRelationList)).whereNotNull('item_duplication_fields');
+                    });
                 }
-                if (Object.keys(collectionMetaUpdates).length > 0) {
-                    await trx('directus_collections').update(collectionMetaUpdates).where({ collection });
+                const collectionMetas = await collectionMetaQuery;
+                const collectionMetaUpdates = getCollectionMetaUpdates(collection, field, collectionMetas, this.schema.collections, fieldToCollectionList);
+                for (const meta of collectionMetaUpdates) {
+                    await trx('directus_collections').update(meta.updates).where({ collection: meta.collection });
                 }
                 // Cleanup directus_fields
                 const metaRow = await trx

package/dist/services/meta.js

@@ -33,9 +33,10 @@ export class MetaService {
         return this.filterCount(collection, {});
     }
     async filterCount(collection, query) {
+        const primaryKeyName = this.schema.collections[collection].primary;
         const aggregateQuery = {
             aggregate: {
-                count: ['*'],
+                countDistinct: [primaryKeyName],
             },
             search: query.search ?? null,
             filter: query.filter ?? null,
@@ -52,6 +53,7 @@ export class MetaService {
         const records = await runAst(ast, this.schema, this.accountability, {
             knex: this.knex,
         });
-        return Number((isArray(records) ? records[0]?.['count'] : records?.['count']) ?? 0);
+        return Number((isArray(records) ? records[0]?.['countDistinct'][primaryKeyName] : records?.['countDistinct'][primaryKeyName]) ??
+            0);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "25.0.0",
+  "version": "25.0.1",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content",
   "keywords": [
     "directus",
@@ -150,29 +150,29 @@
     "ws": "8.18.0",
     "zod": "3.24.1",
     "zod-validation-error": "3.4.0",
+    "@directus/env": "5.0.2",
     "@directus/constants": "13.0.0",
-    "@directus/app": "13.7.0",
-    "@directus/env": "5.0.1",
     "@directus/errors": "2.0.0",
-    "@directus/extensions": "3.0.2",
-    "@directus/extensions-sdk": "13.0.2",
+    "@directus/app": "13.7.1",
+    "@directus/extensions-sdk": "13.0.3",
+    "@directus/extensions": "3.0.3",
     "@directus/format-title": "12.0.0",
-    "@directus/memory": "3.0.1",
-    "@directus/pressure": "3.0.1",
-    "@directus/extensions-registry": "3.0.2",
-    "@directus/storage": "12.0.0",
+    "@directus/extensions-registry": "3.0.3",
+    "@directus/pressure": "3.0.2",
+    "@directus/memory": "3.0.2",
     "@directus/schema": "13.0.0",
     "@directus/specs": "11.1.0",
-    "@directus/storage-driver-azure": "12.0.1",
-    "@directus/storage-driver-gcs": "12.0.1",
-    "@directus/storage-driver-cloudinary": "12.0.1",
-    "@directus/storage-driver-local": "12.0.0",
-    "@directus/storage-driver-supabase": "3.0.1",
-    "@directus/storage-driver-s3": "12.0.1",
-    "@directus/system-data": "3.0.0",
-    "@directus/utils": "13.0.1",
-    "@directus/validation": "2.0.1",
-    "directus": "11.5.0"
+    "@directus/storage": "12.0.0",
+    "@directus/storage-driver-azure": "12.0.2",
+    "@directus/storage-driver-cloudinary": "12.0.2",
+    "@directus/storage-driver-gcs": "12.0.2",
+    "@directus/storage-driver-s3": "12.0.2",
+    "@directus/storage-driver-supabase": "3.0.2",
+    "@directus/system-data": "3.0.1",
+    "@directus/utils": "13.0.2",
+    "@directus/validation": "2.0.2",
+    "directus": "11.5.1",
+    "@directus/storage-driver-local": "12.0.0"
   },
   "devDependencies": {
     "@directus/tsconfig": "3.0.0",