@directus/api 25.0.0 → 26.0.0

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/graphql/resolvers/get-collection-type.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaComposer } from 'graphql-compose';
+import type { Schema } from '../schema/index.js';
+export declare function getCollectionType(schemaComposer: SchemaComposer, schema: Schema, action: 'read' | 'write'): import("graphql-compose").ObjectTypeComposer<any, any>;

package/dist/services/graphql/resolvers/get-collection-type.js

@@ -0,0 +1,34 @@
+import { GraphQLNonNull, GraphQLString } from 'graphql';
+import { getGraphQLType } from '../../../utils/get-graphql-type.js';
+export function getCollectionType(schemaComposer, schema, action) {
+    const prefix = action === 'read' ? '' : 'write_';
+    const Collection = schemaComposer.createObjectTC({
+        name: `${prefix}directus_collections`,
+    });
+    if ('directus_collections' in schema.read.collections === false) {
+        return Collection;
+    }
+    Collection.addFields({
+        collection: GraphQLString,
+        meta: schemaComposer.createObjectTC({
+            name: `${prefix}directus_collections_meta`,
+            fields: Object.values(schema.read.collections['directus_collections'].fields).reduce((acc, field) => {
+                acc[field.field] = {
+                    type: field.nullable || action === 'write'
+                        ? getGraphQLType(field.type, field.special)
+                        : new GraphQLNonNull(getGraphQLType(field.type, field.special)),
+                    description: field.note,
+                };
+                return acc;
+            }, {}),
+        }),
+        schema: schemaComposer.createObjectTC({
+            name: `${prefix}directus_collections_schema`,
+            fields: {
+                name: GraphQLString,
+                comment: GraphQLString,
+            },
+        }),
+    });
+    return Collection;
+}

package/dist/services/graphql/resolvers/get-field-type.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaComposer } from 'graphql-compose';
+import type { Schema } from '../schema/index.js';
+export declare function getFieldType(schemaComposer: SchemaComposer, schema: Schema, action: 'read' | 'write'): import("graphql-compose").ObjectTypeComposer<any, any>;

package/dist/services/graphql/resolvers/get-field-type.js

@@ -0,0 +1,51 @@
+import { GraphQLBoolean, GraphQLInt, GraphQLNonNull, GraphQLString } from 'graphql';
+import { getGraphQLType } from '../../../utils/get-graphql-type.js';
+export function getFieldType(schemaComposer, schema, action) {
+    const prefix = action === 'read' ? '' : 'write_';
+    const Field = schemaComposer.createObjectTC({
+        name: `${prefix}directus_fields`,
+    });
+    if ('directus_fields' in schema.read.collections === false) {
+        return Field;
+    }
+    Field.addFields({
+        collection: GraphQLString,
+        field: GraphQLString,
+        type: GraphQLString,
+        meta: schemaComposer.createObjectTC({
+            name: `${prefix}directus_fields_meta`,
+            fields: Object.values(schema.read.collections['directus_fields'].fields).reduce((acc, field) => {
+                acc[field.field] = {
+                    type: field.nullable || action === 'write'
+                        ? getGraphQLType(field.type, field.special)
+                        : new GraphQLNonNull(getGraphQLType(field.type, field.special)),
+                    description: field.note,
+                };
+                return acc;
+            }, {}),
+        }),
+        schema: schemaComposer.createObjectTC({
+            name: `${prefix}directus_fields_schema`,
+            fields: {
+                name: GraphQLString,
+                table: GraphQLString,
+                data_type: GraphQLString,
+                default_value: GraphQLString,
+                max_length: GraphQLInt,
+                numeric_precision: GraphQLInt,
+                numeric_scale: GraphQLInt,
+                is_generated: GraphQLBoolean,
+                generation_expression: GraphQLString,
+                is_indexed: GraphQLBoolean,
+                is_nullable: GraphQLBoolean,
+                is_unique: GraphQLBoolean,
+                is_primary_key: GraphQLBoolean,
+                has_auto_increment: GraphQLBoolean,
+                foreign_key_column: GraphQLString,
+                foreign_key_table: GraphQLString,
+                comment: GraphQLString,
+            },
+        }),
+    });
+    return Field;
+}

package/dist/services/graphql/resolvers/get-relation-type.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaComposer } from 'graphql-compose';
+import type { Schema } from '../schema/index.js';
+export declare function getRelationType(schemaComposer: SchemaComposer, schema: Schema, action: 'read' | 'write'): import("graphql-compose").ObjectTypeComposer<any, any>;

package/dist/services/graphql/resolvers/get-relation-type.js

@@ -0,0 +1,39 @@
+import { GraphQLNonNull, GraphQLString } from 'graphql';
+import { getGraphQLType } from '../../../utils/get-graphql-type.js';
+export function getRelationType(schemaComposer, schema, action) {
+    const prefix = action === 'read' ? '' : 'write_';
+    const Relation = schemaComposer.createObjectTC({
+        name: `${prefix}directus_relations`,
+    });
+    if ('directus_relations' in schema.read.collections === false) {
+        return Relation;
+    }
+    Relation.addFields({
+        collection: GraphQLString,
+        field: GraphQLString,
+        related_collection: GraphQLString,
+        schema: schemaComposer.createObjectTC({
+            name: `${prefix}directus_relations_schema`,
+            fields: {
+                table: new GraphQLNonNull(GraphQLString),
+                column: new GraphQLNonNull(GraphQLString),
+                foreign_key_table: new GraphQLNonNull(GraphQLString),
+                foreign_key_column: new GraphQLNonNull(GraphQLString),
+                constraint_name: GraphQLString,
+                on_update: new GraphQLNonNull(GraphQLString),
+                on_delete: new GraphQLNonNull(GraphQLString),
+            },
+        }),
+        meta: schemaComposer.createObjectTC({
+            name: `${prefix}directus_relations_meta`,
+            fields: Object.values(schema.read.collections['directus_relations'].fields).reduce((acc, field) => {
+                acc[field.field] = {
+                    type: getGraphQLType(field.type, field.special),
+                    description: field.note,
+                };
+                return acc;
+            }, {}),
+        }),
+    });
+    return Relation;
+}

package/dist/services/graphql/resolvers/mutation.js

@@ -8,7 +8,7 @@ export async function resolveMutation(gql, args, info) {
     if (gql.scope === 'system')
         collection = `directus_${collection}`;
     const selections = replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
-    const query = getQuery(args, selections || [], info.variableValues, gql.accountability);
+    const query = await getQuery(args, selections || [], info.variableValues, gql.schema, gql.accountability);
     const singleton = collection.endsWith('_batch') === false &&
         collection.endsWith('_items') === false &&
         collection.endsWith('_item') === false &&

package/dist/services/graphql/resolvers/query.js

@@ -2,10 +2,10 @@ import { parseFilterFunctionPath } from '@directus/utils';
 import { omit } from 'lodash-es';
 import { mergeVersionsRaw, mergeVersionsRecursive } from '../../../utils/merge-version-data.js';
 import { VersionsService } from '../../versions.js';
-import { getAggregateQuery } from '../utils/aggrgate-query.js';
-import { replaceFragmentsInSelections } from '../utils/replace-fragments.js';
 import { parseArgs } from '../schema/parse-args.js';
 import { getQuery } from '../schema/parse-query.js';
+import { getAggregateQuery } from '../utils/aggregate-query.js';
+import { replaceFragmentsInSelections } from '../utils/replace-fragments.js';
 /**
  * Generic resolver that's used for every "regular" items/system query. Converts the incoming GraphQL AST / fragments into
  * Directus' query structure which is then executed by the services.
@@ -22,11 +22,11 @@ export async function resolveQuery(gql, info) {
     let versionRaw = false;
     const isAggregate = collection.endsWith('_aggregated') && collection in gql.schema.collections === false;
     if (isAggregate) {
-        query = getAggregateQuery(args, selections, gql.accountability);
+        query = await getAggregateQuery(args, selections, gql.schema, gql.accountability);
         collection = collection.slice(0, -11);
     }
     else {
-        query = getQuery(args, selections, info.variableValues, gql.accountability);
+        query = await getQuery(args, selections, info.variableValues, gql.schema, gql.accountability);
         if (collection.endsWith('_by_id') && collection in gql.schema.collections === false) {
             collection = collection.slice(0, -6);
         }

package/dist/services/graphql/resolvers/system-admin.d.ts

@@ -1,5 +1,5 @@
 import { SchemaComposer } from 'graphql-compose';
 import type { GraphQLParams } from '../../../types/index.js';
 import { GraphQLService } from '../index.js';
-import type { BaseTypeComposers } from './system.js';
-export declare function resolveSystemAdmin(gql: GraphQLService, schemaComposer: SchemaComposer<GraphQLParams['contextValue']>, { Collection, Field, Relation, Extension }: BaseTypeComposers): void;
+import type { Schema } from '../schema/index.js';
+export declare function resolveSystemAdmin(gql: GraphQLService, schema: Schema, schemaComposer: SchemaComposer<GraphQLParams['contextValue']>): void;