directus 9.0.1 → 9.2.0

package/dist/database/system-data/fields/users.yaml

@@ -90,6 +90,11 @@ fields:
     special: conceal
     width: half
 
+  - field: email_notifications
+    interface: boolean
+    width: half
+    special: boolean
+
   - field: admin_divider
     interface: presentation-divider
     options:

package/dist/database/system-data/relations/relations.yaml

@@ -82,3 +82,9 @@ data:
   - many_collection: directus_panels
     many_field: user_created
     one_collection: directus_users
+  - many_collection: directus_notifications
+    many_field: recipient
+    one_collection: directus_users
+  - many_collection: directus_notifications
+    many_field: sender
+    one_collection: directus_users

package/dist/env.js

@@ -50,6 +50,7 @@ const defaults = {
     CACHE_SCHEMA: true,
     CACHE_PERMISSIONS: true,
     AUTH_PROVIDERS: '',
+    AUTH_DISABLE_DEFAULT: false,
     EXTENSIONS_PATH: './extensions',
     EMAIL_FROM: 'no-reply@directus.io',
     EMAIL_TRANSPORT: 'sendmail',

package/dist/extensions.js

@@ -31,6 +31,7 @@ const database_1 = __importDefault(require("./database"));
 const emitter_1 = __importDefault(require("./emitter"));
 const env_1 = __importDefault(require("./env"));
 const exceptions = __importStar(require("./exceptions"));
+const sharedExceptions = __importStar(require("@directus/shared/exceptions"));
 const logger_1 = __importDefault(require("./logger"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const get_schema_1 = require("./utils/get-schema");
@@ -231,7 +232,14 @@ class ExtensionManager {
                 }
             },
         };
-        register(registerFunctions, { services, exceptions, env: env_1.default, database: (0, database_1.default)(), logger: logger_1.default, getSchema: get_schema_1.getSchema });
+        register(registerFunctions, {
+            services,
+            exceptions: { ...exceptions, ...sharedExceptions },
+            env: env_1.default,
+            database: (0, database_1.default)(),
+            logger: logger_1.default,
+            getSchema: get_schema_1.getSchema,
+        });
     }
     registerEndpoint(endpoint, router) {
         const endpointPath = path_1.default.resolve(endpoint.path, endpoint.entrypoint || '');
@@ -241,7 +249,14 @@ class ExtensionManager {
         const routeName = typeof mod === 'function' ? endpoint.name : mod.id;
         const scopedRouter = express_1.default.Router();
         router.use(`/${routeName}`, scopedRouter);
-        register(scopedRouter, { services, exceptions, env: env_1.default, database: (0, database_1.default)(), logger: logger_1.default, getSchema: get_schema_1.getSchema });
+        register(scopedRouter, {
+            services,
+            exceptions: { ...exceptions, ...sharedExceptions },
+            env: env_1.default,
+            database: (0, database_1.default)(),
+            logger: logger_1.default,
+            getSchema: get_schema_1.getSchema,
+        });
         this.apiEndpoints.push({
             path: endpointPath,
         });

package/dist/middleware/get-permissions.js

@@ -3,112 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@directus/shared/utils");
-const lodash_1 = require("lodash");
-const database_1 = __importDefault(require("../database"));
-const app_access_permissions_1 = require("../database/system-data/app-access-permissions");
 const async_handler_1 = __importDefault(require("../utils/async-handler"));
-const merge_permissions_1 = require("../utils/merge-permissions");
-const users_1 = require("../services/users");
-const roles_1 = require("../services/roles");
-const cache_1 = require("../cache");
-const object_hash_1 = __importDefault(require("object-hash"));
-const env_1 = __importDefault(require("../env"));
+const get_permissions_1 = require("../utils/get-permissions");
 const getPermissions = (0, async_handler_1.default)(async (req, res, next) => {
-    const database = (0, database_1.default)();
-    const { systemCache } = (0, cache_1.getCache)();
-    let permissions = [];
     if (!req.accountability) {
-        throw new Error('"getPermissions" needs to be used after the "authenticate" middleware');
+        throw new Error('getPermissions middleware needs to be called after authenticate');
     }
-    if (!req.schema) {
-        throw new Error('"getPermissions" needs to be used after the "schema" middleware');
-    }
-    const { user, role, app, admin } = req.accountability;
-    const cacheKey = `permissions-${(0, object_hash_1.default)({ user, role, app, admin })}`;
-    if (env_1.default.CACHE_PERMISSIONS !== false) {
-        const cachedPermissions = await systemCache.get(cacheKey);
-        if (cachedPermissions) {
-            req.accountability.permissions = cachedPermissions;
-            return next();
-        }
-    }
-    if (req.accountability.admin !== true) {
-        const permissionsForRole = await database
-            .select('*')
-            .from('directus_permissions')
-            .where({ role: req.accountability.role });
-        const requiredPermissionData = {
-            $CURRENT_USER: [],
-            $CURRENT_ROLE: [],
-        };
-        permissions = permissionsForRole.map((permissionRaw) => {
-            const permission = (0, lodash_1.cloneDeep)(permissionRaw);
-            if (permission.permissions && typeof permission.permissions === 'string') {
-                permission.permissions = JSON.parse(permission.permissions);
-            }
-            else if (permission.permissions === null) {
-                permission.permissions = {};
-            }
-            if (permission.validation && typeof permission.validation === 'string') {
-                permission.validation = JSON.parse(permission.validation);
-            }
-            else if (permission.validation === null) {
-                permission.validation = {};
-            }
-            if (permission.presets && typeof permission.presets === 'string') {
-                permission.presets = JSON.parse(permission.presets);
-            }
-            else if (permission.presets === null) {
-                permission.presets = {};
-            }
-            if (permission.fields && typeof permission.fields === 'string') {
-                permission.fields = permission.fields.split(',');
-            }
-            else if (permission.fields === null) {
-                permission.fields = [];
-            }
-            const extractPermissionData = (val) => {
-                if (typeof val === 'string' && val.startsWith('$CURRENT_USER.')) {
-                    requiredPermissionData.$CURRENT_USER.push(val.replace('$CURRENT_USER.', ''));
-                }
-                if (typeof val === 'string' && val.startsWith('$CURRENT_ROLE.')) {
-                    requiredPermissionData.$CURRENT_ROLE.push(val.replace('$CURRENT_ROLE.', ''));
-                }
-                return val;
-            };
-            (0, utils_1.deepMap)(permission.permissions, extractPermissionData);
-            (0, utils_1.deepMap)(permission.validation, extractPermissionData);
-            (0, utils_1.deepMap)(permission.presets, extractPermissionData);
-            return permission;
-        });
-        if (req.accountability.app === true) {
-            permissions = (0, merge_permissions_1.mergePermissions)(permissions, app_access_permissions_1.appAccessMinimalPermissions.map((perm) => ({ ...perm, role: req.accountability.role })));
-        }
-        const usersService = new users_1.UsersService({ schema: req.schema });
-        const rolesService = new roles_1.RolesService({ schema: req.schema });
-        const filterContext = {};
-        if (req.accountability.user && requiredPermissionData.$CURRENT_USER.length > 0) {
-            filterContext.$CURRENT_USER = await usersService.readOne(req.accountability.user, {
-                fields: requiredPermissionData.$CURRENT_USER,
-            });
-        }
-        if (req.accountability.role && requiredPermissionData.$CURRENT_ROLE.length > 0) {
-            filterContext.$CURRENT_ROLE = await rolesService.readOne(req.accountability.role, {
-                fields: requiredPermissionData.$CURRENT_ROLE,
-            });
-        }
-        permissions = permissions.map((permission) => {
-            permission.permissions = (0, utils_1.parseFilter)(permission.permissions, req.accountability, filterContext);
-            permission.validation = (0, utils_1.parseFilter)(permission.validation, req.accountability, filterContext);
-            permission.presets = (0, utils_1.parseFilter)(permission.presets, req.accountability, filterContext);
-            return permission;
-        });
-        if (env_1.default.CACHE_PERMISSIONS !== false) {
-            await systemCache.set(cacheKey, permissions);
-        }
-    }
-    req.accountability.permissions = permissions;
+    req.accountability.permissions = await (0, get_permissions_1.getPermissions)(req.accountability, req.schema);
     return next();
 });
 exports.default = getPermissions;

package/dist/middleware/sanitize-query.js

@@ -6,7 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sanitize_query_1 = require("../utils/sanitize-query");
 const validate_query_1 = require("../utils/validate-query");
-const sanitizeQueryMiddleware = (req, res, next) => {
+const sanitizeQueryMiddleware = (req, _res, next) => {
     req.sanitizedQuery = {};
     if (!req.query)
         return;

package/dist/services/activity.d.ts

@@ -1,8 +1,10 @@
-import { AbstractServiceOptions } from '../types';
-import { ItemsService } from './index';
-/**
- * @TODO only return activity of the collections you have access to
- */
+import { AbstractServiceOptions, PrimaryKey, Item } from '../types';
+import { ItemsService, MutationOptions } from './index';
+import { NotificationsService } from './notifications';
+import { UsersService } from './users';
 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,13 +1,97 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActivityService = void 0;
+const types_1 = require("../types");
 const index_1 = require("./index");
-/**
- * @TODO only return activity of the collections you have access to
- */
+const notifications_1 = require("./notifications");
+const users_1 = require("./users");
+const authorization_1 = require("./authorization");
+const get_permissions_1 = require("../utils/get-permissions");
+const forbidden_1 = require("../exceptions/forbidden");
+const logger_1 = __importDefault(require("../logger"));
+const user_name_1 = require("../utils/user-name");
+const lodash_1 = require("lodash");
+const env_1 = __importDefault(require("../env"));
+const uuid_validate_1 = __importDefault(require("uuid-validate"));
 class ActivityService extends index_1.ItemsService {
     constructor(options) {
         super('directus_activity', options);
+        this.notificationsService = new notifications_1.NotificationsService({ schema: this.schema });
+        this.usersService = new users_1.UsersService({ schema: this.schema });
+    }
+    async createOne(data, opts) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (data.action === types_1.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 = (0, lodash_1.uniq)((_a = data.comment.match(usersRegExp)) !== null && _a !== void 0 ? _a : []);
+            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.id', 'role.admin_access', 'role.app_access'],
+                });
+                const accountability = {
+                    user: userID,
+                    role: (_c = (_b = user.role) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : null,
+                    admin: (_e = (_d = user.role) === null || _d === void 0 ? void 0 : _d.admin_access) !== null && _e !== void 0 ? _e : null,
+                    app: (_g = (_f = user.role) === null || _f === void 0 ? void 0 : _f.app_access) !== null && _g !== void 0 ? _g : null,
+                };
+                accountability.permissions = await (0, get_permissions_1.getPermissions)(accountability, this.schema);
+                const authorizationService = new authorization_1.AuthorizationService({ schema: this.schema, accountability });
+                const usersService = new users_1.UsersService({ schema: this.schema, accountability });
+                try {
+                    await authorizationService.checkAccess('read', data.collection, data.item);
+                    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>${(0, user_name_1.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 ((0, uuid_validate_1.default)(uuid) === false)
+                            continue;
+                        comment = comment.replace(new RegExp(mention, 'gm'), (_h = userPreviews[uuid]) !== null && _h !== void 0 ? _h : '@Unknown User');
+                    }
+                    comment = `> ${comment.replace(/\n+/gm, '\n> ')}`;
+                    const message = `
+Hello ${(0, user_name_1.userName)(user)},
+
+${(0, user_name_1.userName)(sender)} has mentioned you in a comment:
+
+${comment}
+
+<a href="${env_1.default.PUBLIC_URL}/admin/content/${data.collection}/${data.item}">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 (err instanceof forbidden_1.ForbiddenException) {
+                        logger_1.default.warn(`User ${userID} doesn't have proper permissions to receive notification for this item.`);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+        }
+        return super.createOne(data, opts);
     }
 }
 exports.ActivityService = ActivityService;

package/dist/services/assets.js

@@ -34,6 +34,7 @@ const exceptions_1 = require("../exceptions");
 const storage_1 = __importDefault(require("../storage"));
 const authorization_1 = require("./authorization");
 const TransformationUtils = __importStar(require("../utils/transformations"));
+const uuid_validate_1 = __importDefault(require("uuid-validate"));
 sharp_1.default.concurrency(1);
 // Note: don't put this in the service. The service can be initialized in multiple places, but they
 // should all share the same semaphore instance.
@@ -54,7 +55,20 @@ class AssetsService {
         if (systemPublicKeys.includes(id) === false && ((_a = this.accountability) === null || _a === void 0 ? void 0 : _a.admin) !== true) {
             await this.authorizationService.checkAccess('read', 'directus_files', id);
         }
+        /**
+         * This is a little annoying. Postgres will error out if you're trying to search in `where`
+         * with a wrong type. In case of directus_files where id is a uuid, we'll have to verify the
+         * validity of the uuid ahead of time.
+         */
+        const isValidUUID = (0, uuid_validate_1.default)(id, 4);
+        if (isValidUUID === false)
+            throw new exceptions_1.ForbiddenException();
         const file = (await this.knex.select('*').from('directus_files').where({ id }).first());
+        if (!file)
+            throw new exceptions_1.ForbiddenException();
+        const { exists } = await storage_1.default.disk(file.storage).exists(file.filename_disk);
+        if (!exists)
+            throw new exceptions_1.ForbiddenException();
         if (range) {
             if (range.start >= file.filesize || (range.end && range.end >= file.filesize)) {
                 throw new exceptions_1.RangeNotSatisfiableException(range);

package/dist/services/collections.js

@@ -171,11 +171,22 @@ class CollectionsService {
         }));
         meta.push(...collections_1.systemCollectionRows);
         if (this.accountability && this.accountability.admin !== true) {
-            const collectionsYouHavePermissionToRead = this.accountability
+            const collectionsGroups = meta.reduce((meta, item) => ({
+                ...meta,
+                [item.collection]: item.group,
+            }), {});
+            let collectionsYouHavePermissionToRead = this.accountability
                 .permissions.filter((permission) => {
                 return permission.action === 'read';
             })
                 .map(({ collection }) => collection);
+            for (const collection of collectionsYouHavePermissionToRead) {
+                const group = collectionsGroups[collection];
+                if (group)
+                    collectionsYouHavePermissionToRead.push(group);
+                delete collectionsGroups[collection];
+            }
+            collectionsYouHavePermissionToRead = [...new Set([...collectionsYouHavePermissionToRead])];
             tablesInDatabase = tablesInDatabase.filter((table) => {
                 return collectionsYouHavePermissionToRead.includes(table.name);
             });

package/dist/services/fields.d.ts

@@ -6,9 +6,11 @@ import { PayloadService } from '../services/payload';
 import { AbstractServiceOptions, SchemaOverview } from '../types';
 import { Accountability } from '@directus/shared/types';
 import { Field, RawField, Type } from '@directus/shared/types';
+import { Helpers } from '../database/helpers';
 import Keyv from 'keyv';
 export declare class FieldsService {
     knex: Knex;
+    helpers: Helpers;
     accountability: Accountability | null;
     itemsService: ItemsService;
     payloadService: PayloadService;

package/dist/services/fields.js

@@ -39,10 +39,11 @@ const get_local_type_1 = __importDefault(require("../utils/get-local-type"));
 const utils_1 = require("@directus/shared/utils");
 const lodash_1 = require("lodash");
 const relations_1 = require("./relations");
-const geometry_1 = require("../database/helpers/geometry");
+const helpers_1 = require("../database/helpers");
 class FieldsService {
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
+        this.helpers = (0, helpers_1.getHelpers)(this.knex);
         this.schemaInspector = options.knex ? (0, schema_1.default)(options.knex) : (0, database_1.getSchemaInspector)();
         this.accountability = options.accountability || null;
         this.itemsService = new items_1.ItemsService('directus_fields', options);
@@ -211,23 +212,39 @@ class FieldsService {
                 accountability: this.accountability,
                 schema: this.schema,
             });
-            if (field.type && constants_1.ALIAS_TYPES.includes(field.type) === false) {
+            const hookAdjustedField = await emitter_1.default.emitFilter(`fields.create`, field, {
+                collection: collection,
+            }, {
+                database: trx,
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+            if (hookAdjustedField.type && constants_1.ALIAS_TYPES.includes(hookAdjustedField.type) === false) {
                 if (table) {
-                    this.addColumnToTable(table, field);
+                    this.addColumnToTable(table, hookAdjustedField);
                 }
                 else {
                     await trx.schema.alterTable(collection, (table) => {
-                        this.addColumnToTable(table, field);
+                        this.addColumnToTable(table, hookAdjustedField);
                     });
                 }
             }
-            if (field.meta) {
+            if (hookAdjustedField.meta) {
                 await itemsService.createOne({
-                    ...field.meta,
+                    ...hookAdjustedField.meta,
                     collection: collection,
-                    field: field.field,
-                });
+                    field: hookAdjustedField.field,
+                }, { emitEvents: false });
             }
+            emitter_1.default.emitAction(`fields.create`, {
+                payload: hookAdjustedField,
+                key: hookAdjustedField.field,
+                collection: collection,
+            }, {
+                database: (0, database_1.default)(),
+                schema: this.schema,
+                accountability: this.accountability,
+            });
         });
         if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
             await this.cache.clear();
@@ -238,12 +255,23 @@ class FieldsService {
         if (this.accountability && this.accountability.admin !== true) {
             throw new exceptions_1.ForbiddenException();
         }
-        if (field.schema) {
-            const existingColumn = await this.schemaInspector.columnInfo(collection, field.field);
-            if (!(0, lodash_1.isEqual)(existingColumn, field.schema)) {
+        const hookAdjustedField = await emitter_1.default.emitFilter(`fields.update`, field, {
+            keys: [field.field],
+            collection: collection,
+        }, {
+            database: this.knex,
+            schema: this.schema,
+            accountability: this.accountability,
+        });
+        const record = field.meta
+            ? await this.knex.select('id').from('directus_fields').where({ collection, field: field.field }).first()
+            : null;
+        if (hookAdjustedField.schema) {
+            const existingColumn = await this.schemaInspector.columnInfo(collection, hookAdjustedField.field);
+            if (!(0, lodash_1.isEqual)(existingColumn, hookAdjustedField.schema)) {
                 try {
                     await this.knex.schema.alterTable(collection, (table) => {
-                        if (!field.schema)
+                        if (!hookAdjustedField.schema)
                             return;
                         this.addColumnToTable(table, field, existingColumn);
                     });
@@ -253,31 +281,35 @@ class FieldsService {
                 }
             }
         }
-        if (field.meta) {
-            const record = await this.knex
-                .select('id')
-                .from('directus_fields')
-                .where({ collection, field: field.field })
-                .first();
+        if (hookAdjustedField.meta) {
             if (record) {
                 await this.itemsService.updateOne(record.id, {
-                    ...field.meta,
+                    ...hookAdjustedField.meta,
                     collection: collection,
-                    field: field.field,
-                });
+                    field: hookAdjustedField.field,
+                }, { emitEvents: false });
             }
             else {
                 await this.itemsService.createOne({
-                    ...field.meta,
+                    ...hookAdjustedField.meta,
                     collection: collection,
-                    field: field.field,
-                });
+                    field: hookAdjustedField.field,
+                }, { emitEvents: false });
             }
         }
         if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
             await this.cache.clear();
         }
         await this.systemCache.clear();
+        emitter_1.default.emitAction(`fields.update`, {
+            payload: hookAdjustedField,
+            keys: [hookAdjustedField.field],
+            collection: collection,
+        }, {
+            database: (0, database_1.default)(),
+            schema: this.schema,
+            accountability: this.accountability,
+        });
         return field.field;
     }
     async deleteField(collection, field) {
@@ -402,8 +434,7 @@ class FieldsService {
             column = table.timestamp(field.field, { useTz: true });
         }
         else if (field.type.startsWith('geometry')) {
-            const helper = (0, geometry_1.getGeometryHelper)();
-            column = helper.createColumn(table, field);
+            column = this.helpers.st.createColumn(table, field);
         }
         else {
             // @ts-ignore

package/dist/services/files.d.ts

@@ -9,7 +9,7 @@ export declare class FilesService extends ItemsService {
     uploadOne(stream: NodeJS.ReadableStream, data: Partial<File> & {
         filename_download: string;
         storage: string;
-    }, primaryKey?: PrimaryKey): Promise<PrimaryKey>;
+    }, primaryKey?: PrimaryKey, opts?: MutationOptions): Promise<PrimaryKey>;
     /**
      * Import a single file from an external URL
      */

package/dist/services/files.js

@@ -26,7 +26,7 @@ class FilesService extends items_1.ItemsService {
     /**
      * Upload a single new file to the configured storage adapter
      */
-    async uploadOne(stream, data, primaryKey) {
+    async uploadOne(stream, data, primaryKey, opts) {
         var _a, _b, _c, _d, _e, _f;
         const payload = (0, lodash_1.clone)(data);
         if ('folder' in payload === false) {
@@ -109,15 +109,17 @@ class FilesService extends items_1.ItemsService {
         if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
             await this.cache.clear();
         }
-        emitter_1.default.emitAction('files.upload', {
-            payload,
-            key: primaryKey,
-            collection: this.collection,
-        }, {
-            database: this.knex,
-            schema: this.schema,
-            accountability: this.accountability,
-        });
+        if ((opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false) {
+            emitter_1.default.emitAction('files.upload', {
+                payload,
+                key: primaryKey,
+                collection: this.collection,
+            }, {
+                database: this.knex,
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+        }
         return primaryKey;
     }
     /**
@@ -126,7 +128,7 @@ class FilesService extends items_1.ItemsService {
     async importOne(importURL, body) {
         var _a, _b, _c;
         const fileCreatePermissions = (_b = (_a = this.accountability) === null || _a === void 0 ? void 0 : _a.permissions) === null || _b === void 0 ? void 0 : _b.find((permission) => permission.collection === 'directus_files' && permission.action === 'create');
-        if (((_c = this.accountability) === null || _c === void 0 ? void 0 : _c.admin) !== true && !fileCreatePermissions) {
+        if (this.accountability && ((_c = this.accountability) === null || _c === void 0 ? void 0 : _c.admin) !== true && !fileCreatePermissions) {
             throw new exceptions_1.ForbiddenException();
         }
         let fileResponse;

package/dist/services/graphql.js

@@ -28,6 +28,7 @@ const folders_1 = require("./folders");
 const items_1 = require("./items");
 const permissions_1 = require("./permissions");
 const presets_1 = require("./presets");
+const notifications_1 = require("./notifications");
 const relations_1 = require("./relations");
 const revisions_1 = require("./revisions");
 const roles_1 = require("./roles");
@@ -725,6 +726,9 @@ class GraphQLService {
                     args: {
                         groupBy: new graphql_1.GraphQLList(graphql_1.GraphQLString),
                         filter: ReadableCollectionFilterTypes[collection.collection],
+                        limit: {
+                            type: graphql_1.GraphQLInt,
+                        },
                         search: {
                             type: graphql_1.GraphQLString,
                         },
@@ -1252,6 +1256,8 @@ class GraphQLService {
                 return new permissions_1.PermissionsService(opts);
             case 'directus_presets':
                 return new presets_1.PresetsService(opts);
+            case 'directus_notifications':
+                return new notifications_1.NotificationsService(opts);
             case 'directus_revisions':
                 return new revisions_1.RevisionsService(opts);
             case 'directus_roles':

package/dist/services/index.d.ts

@@ -11,6 +11,7 @@ export * from './graphql';
 export * from './import';
 export * from './mail';
 export * from './meta';
+export * from './notifications';
 export * from './panels';
 export * from './payload';
 export * from './permissions';

package/dist/services/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./graphql"), exports);
 __exportStar(require("./import"), exports);
 __exportStar(require("./mail"), exports);
 __exportStar(require("./meta"), exports);
+__exportStar(require("./notifications"), exports);
 __exportStar(require("./panels"), exports);
 __exportStar(require("./payload"), exports);
 __exportStar(require("./permissions"), exports);