@directus/api 23.0.0 → 23.1.1

package/dist/permissions/utils/merge-permissions.js

@@ -0,0 +1,118 @@
+import { flatten, intersection, isEqual, merge, omit, uniq } from 'lodash-es';
+// Adapted from https://github.com/directus/directus/blob/141b8adbf4dd8e06530a7929f34e3fc68a522053/api/src/utils/merge-permissions.ts#L4
+/**
+ * Merges multiple permission lists into a flat list of unique permissions.
+ * @param strategy `and` or `or` deduplicate permissions while `intersection` makes sure only common permissions across all lists are kept and overlapping permissions are merged through `and`.
+ * @param permissions List of permission lists to merge.
+ * @returns A flat list of unique permissions.
+ */
+export function mergePermissions(strategy, ...permissions) {
+    let allPermissions;
+    // Only keep permissions that are common to all lists
+    if (strategy === 'intersection') {
+        const permissionKeys = permissions.map((permissions) => {
+            return new Set(permissions.map((permission) => `${permission.collection}__${permission.action}`));
+        });
+        const intersectionKeys = permissionKeys.reduce((acc, val) => {
+            return new Set([...acc].filter((x) => val.has(x)));
+        }, permissionKeys[0]);
+        const deduplicateSubpermissions = permissions.map((permissions) => {
+            return mergePermissions('or', permissions);
+        });
+        allPermissions = flatten(deduplicateSubpermissions).filter((permission) => {
+            return intersectionKeys.has(`${permission.collection}__${permission.action}`);
+        });
+        strategy = 'and';
+    }
+    else {
+        allPermissions = flatten(permissions);
+    }
+    const mergedPermissions = allPermissions
+        .reduce((acc, val) => {
+        const key = `${val.collection}__${val.action}`;
+        const current = acc.get(key);
+        acc.set(key, current ? mergePermission(strategy, current, val) : val);
+        return acc;
+    }, new Map())
+        .values();
+    return Array.from(mergedPermissions);
+}
+export function mergePermission(strategy, currentPerm, newPerm) {
+    const logicalKey = `_${strategy}`;
+    let { permissions, validation, fields, presets } = currentPerm;
+    if (newPerm.permissions) {
+        if (currentPerm.permissions && Object.keys(currentPerm.permissions)[0] === logicalKey) {
+            permissions = {
+                [logicalKey]: [
+                    ...currentPerm.permissions[logicalKey],
+                    newPerm.permissions,
+                ],
+            };
+        }
+        else if (currentPerm.permissions) {
+            // Empty {} supersedes other permissions in _OR merge
+            if (strategy === 'or' && (isEqual(currentPerm.permissions, {}) || isEqual(newPerm.permissions, {}))) {
+                permissions = {};
+            }
+            else {
+                permissions = {
+                    [logicalKey]: [currentPerm.permissions, newPerm.permissions],
+                };
+            }
+        }
+        else {
+            permissions = {
+                [logicalKey]: [newPerm.permissions],
+            };
+        }
+    }
+    if (newPerm.validation) {
+        if (currentPerm.validation && Object.keys(currentPerm.validation)[0] === logicalKey) {
+            validation = {
+                [logicalKey]: [
+                    ...currentPerm.validation[logicalKey],
+                    newPerm.validation,
+                ],
+            };
+        }
+        else if (currentPerm.validation) {
+            // Empty {} supersedes other validations in _OR merge
+            if (strategy === 'or' && (isEqual(currentPerm.validation, {}) || isEqual(newPerm.validation, {}))) {
+                validation = {};
+            }
+            else {
+                validation = {
+                    [logicalKey]: [currentPerm.validation, newPerm.validation],
+                };
+            }
+        }
+        else {
+            validation = {
+                [logicalKey]: [newPerm.validation],
+            };
+        }
+    }
+    if (newPerm.fields) {
+        if (Array.isArray(currentPerm.fields) && strategy === 'or') {
+            fields = uniq([...currentPerm.fields, ...newPerm.fields]);
+        }
+        else if (Array.isArray(currentPerm.fields) && strategy === 'and') {
+            fields = intersection(currentPerm.fields, newPerm.fields);
+        }
+        else {
+            fields = newPerm.fields;
+        }
+        if (fields.includes('*'))
+            fields = ['*'];
+    }
+    if (newPerm.presets) {
+        presets = merge({}, presets, newPerm.presets);
+    }
+    return omit({
+        ...currentPerm,
+        permissions,
+        validation,
+        fields,
+        presets,
+    }, ['id', 'system']);
+}

package/dist/services/activity.d.ts

@@ -1,11 +1,5 @@
-import type { Item, PrimaryKey } from '@directus/types';
-import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
+import type { AbstractServiceOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
-import { NotificationsService } from './notifications.js';
-import { UsersService } from './users.js';
 export declare class ActivityService extends ItemsService {
-    notificationsService: NotificationsService;
-    usersService: UsersService;
     constructor(options: AbstractServiceOptions);
-    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
 }

package/dist/services/activity.js

@@ -1,109 +1,6 @@
-import { Action } from '@directus/constants';
-import { useEnv } from '@directus/env';
-import { ErrorCode, isDirectusError } from '@directus/errors';
-import { uniq } from 'lodash-es';
-import { useLogger } from '../logger/index.js';
-import { fetchRolesTree } from '../permissions/lib/fetch-roles-tree.js';
-import { fetchGlobalAccess } from '../permissions/modules/fetch-global-access/fetch-global-access.js';
-import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
-import { createDefaultAccountability } from '../permissions/utils/create-default-accountability.js';
-import { isValidUuid } from '../utils/is-valid-uuid.js';
-import { Url } from '../utils/url.js';
-import { userName } from '../utils/user-name.js';
 import { ItemsService } from './items.js';
-import { NotificationsService } from './notifications.js';
-import { UsersService } from './users.js';
-const env = useEnv();
-const logger = useLogger();
 export class ActivityService extends ItemsService {
-    notificationsService;
-    usersService;
     constructor(options) {
         super('directus_activity', options);
-        this.notificationsService = new NotificationsService({ schema: this.schema });
-        this.usersService = new UsersService({ schema: this.schema });
-    }
-    async createOne(data, opts) {
-        if (data['action'] === Action.COMMENT && typeof data['comment'] === 'string') {
-            const usersRegExp = new RegExp(/@[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/gi);
-            const mentions = uniq(data['comment'].match(usersRegExp) ?? []);
-            const sender = await this.usersService.readOne(this.accountability.user, {
-                fields: ['id', 'first_name', 'last_name', 'email'],
-            });
-            for (const mention of mentions) {
-                const userID = mention.substring(1);
-                const user = await this.usersService.readOne(userID, {
-                    fields: ['id', 'first_name', 'last_name', 'email', 'role'],
-                });
-                const roles = await fetchRolesTree(user['role'], this.knex);
-                const globalAccess = await fetchGlobalAccess({ user: user['id'], roles, ip: null }, this.knex);
-                const accountability = createDefaultAccountability({
-                    user: userID,
-                    role: user['role']?.id ?? null,
-                    roles,
-                    ...globalAccess,
-                });
-                const usersService = new UsersService({ schema: this.schema, accountability });
-                try {
-                    if (this.accountability) {
-                        await validateAccess({
-                            accountability: this.accountability,
-                            action: 'read',
-                            collection: data['collection'],
-                            primaryKeys: [data['item']],
-                        }, {
-                            knex: this.knex,
-                            schema: this.schema,
-                        });
-                    }
-                    const templateData = await usersService.readByQuery({
-                        fields: ['id', 'first_name', 'last_name', 'email'],
-                        filter: { id: { _in: mentions.map((mention) => mention.substring(1)) } },
-                    });
-                    const userPreviews = templateData.reduce((acc, user) => {
-                        acc[user['id']] = `<em>${userName(user)}</em>`;
-                        return acc;
-                    }, {});
-                    let comment = data['comment'];
-                    for (const mention of mentions) {
-                        const uuid = mention.substring(1);
-                        // We only match on UUIDs in the first place. This is just an extra sanity check.
-                        if (isValidUuid(uuid) === false)
-                            continue;
-                        comment = comment.replace(new RegExp(mention, 'gm'), userPreviews[uuid] ?? '@Unknown User');
-                    }
-                    comment = `> ${comment.replace(/\n+/gm, '\n> ')}`;
-                    const href = new Url(env['PUBLIC_URL'])
-                        .addPath('admin', 'content', data['collection'], data['item'])
-                        .toString();
-                    const message = `
-Hello ${userName(user)},
-
-${userName(sender)} has mentioned you in a comment:
-
-${comment}
-
-<a href="${href}">Click here to view.</a>
-`;
-                    await this.notificationsService.createOne({
-                        recipient: userID,
-                        sender: sender['id'],
-                        subject: `You were mentioned in ${data['collection']}`,
-                        message,
-                        collection: data['collection'],
-                        item: data['item'],
-                    });
-                }
-                catch (err) {
-                    if (isDirectusError(err, ErrorCode.Forbidden)) {
-                        logger.warn(`User ${userID} doesn't have proper permissions to receive notification for this item.`);
-                    }
-                    else {
-                        throw err;
-                    }
-                }
-            }
-        }
-        return super.createOne(data, opts);
     }
 }

package/dist/services/assets.js

@@ -98,7 +98,7 @@ export class AssetsService {
             }
             if (exists) {
                 return {
-                    stream: await storage.location(file.storage).read(assetFilename, range),
+                    stream: await storage.location(file.storage).read(assetFilename, { range }),
                     file,
                     stat: await storage.location(file.storage).stat(assetFilename),
                 };
@@ -121,7 +121,8 @@ export class AssetsService {
                     reason: 'Server too busy',
                 });
             }
-            const readStream = await storage.location(file.storage).read(file.filename_disk, range);
+            const version = file.modified_on !== undefined ? String(Math.round(new Date(file.modified_on).getTime() / 1000)) : undefined;
+            const readStream = await storage.location(file.storage).read(file.filename_disk, { range, version });
             const transformer = getSharpInstance();
             transformer.timeout({
                 seconds: clamp(Math.round(getMilliseconds(env['ASSETS_TRANSFORM_TIMEOUT'], 0) / 1000), 1, 3600),
@@ -151,13 +152,13 @@ export class AssetsService {
                 }
             }
             return {
-                stream: await storage.location(file.storage).read(assetFilename, range),
+                stream: await storage.location(file.storage).read(assetFilename, { range }),
                 stat: await storage.location(file.storage).stat(assetFilename),
                 file,
             };
         }
         else {
-            const readStream = await storage.location(file.storage).read(file.filename_disk, range);
+            const readStream = await storage.location(file.storage).read(file.filename_disk, { range });
             const stat = await storage.location(file.storage).stat(file.filename_disk);
             return { stream: readStream, file, stat };
         }

package/dist/services/authentication.js

@@ -212,13 +212,8 @@ export class AuthenticationService {
             user_auth_data: 'u.auth_data',
             user_role: 'u.role',
             share_id: 'd.id',
-            share_item: 'd.item',
-            share_role: 'd.role',
-            share_collection: 'd.collection',
             share_start: 'd.date_start',
             share_end: 'd.date_end',
-            share_times_used: 'd.times_used',
-            share_max_uses: 'd.max_uses',
         })
             .from('directus_sessions AS s')
             .leftJoin('directus_users AS u', 's.user', 'u.id')
@@ -289,11 +284,7 @@ export class AuthenticationService {
         }
         if (record.share_id) {
             tokenPayload.share = record.share_id;
-            tokenPayload.role = record.share_role;
-            tokenPayload.share_scope = {
-                collection: record.share_collection,
-                item: record.share_item,
-            };
+            tokenPayload.role = null;
             tokenPayload.app_access = false;
             tokenPayload.admin_access = false;
             delete tokenPayload.id;

package/dist/services/collections.js

@@ -155,10 +155,11 @@ export class CollectionsService {
             if (opts?.autoPurgeSystemCache !== false) {
                 await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
             }
+            // Refresh the schema for subsequent reads
+            this.schema = await getSchema();
             if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
-                const updatedSchema = await getSchema();
                 for (const nestedActionEvent of nestedActionEvents) {
-                    nestedActionEvent.context.schema = updatedSchema;
+                    nestedActionEvent.context.schema = this.schema;
                     emitter.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
                 }
             }
@@ -196,10 +197,11 @@ export class CollectionsService {
             if (opts?.autoPurgeSystemCache !== false) {
                 await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
             }
+            // Refresh the schema for subsequent reads
+            this.schema = await getSchema();
             if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
-                const updatedSchema = await getSchema();
                 for (const nestedActionEvent of nestedActionEvents) {
-                    nestedActionEvent.context.schema = updatedSchema;
+                    nestedActionEvent.context.schema = this.schema;
                     emitter.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
                 }
             }

package/dist/services/comments.d.ts

@@ -0,0 +1,31 @@
+import type { Comment, Item, PrimaryKey, Query } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
+import { ActivityService } from './activity.js';
+import { ItemsService, type QueryOptions } from './items.js';
+import { NotificationsService } from './notifications.js';
+import { UsersService } from './users.js';
+type serviceOrigin = 'activity' | 'comments';
+export declare class CommentsService extends ItemsService {
+    activityService: ActivityService;
+    notificationsService: NotificationsService;
+    usersService: UsersService;
+    serviceOrigin: serviceOrigin;
+    constructor(options: AbstractServiceOptions & {
+        serviceOrigin: serviceOrigin;
+    });
+    readOne(key: PrimaryKey, query?: Query, opts?: QueryOptions): Promise<Item>;
+    readByQuery(query: Query, opts?: QueryOptions): Promise<Item[]>;
+    readMany(keys: PrimaryKey[], query?: Query, opts?: QueryOptions): Promise<Item[]>;
+    createOne(data: Partial<Comment>, opts?: MutationOptions): Promise<PrimaryKey>;
+    updateByQuery(query: Query, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateOne(key: PrimaryKey, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    deleteByQuery(query: Query, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    deleteOne(key: PrimaryKey, opts?: MutationOptions): Promise<PrimaryKey>;
+    private processPrimaryKeys;
+    migrateLegacyComment(activityPk: PrimaryKey): Promise<PrimaryKey>;
+    generateQuery(type: serviceOrigin, originalQuery: Query): Query;
+    private sortLegacyResults;
+}
+export {};