directus 9.20.4 → 9.21.0

package/dist/exceptions/method-not-allowed.d.ts

@@ -1,5 +1,5 @@
 import { BaseException } from '@directus/shared/exceptions';
-declare type Extensions = {
+type Extensions = {
     allow: string[];
 };
 export declare class MethodNotAllowedException extends BaseException {

package/dist/exceptions/service-unavailable.d.ts

@@ -1,5 +1,5 @@
 import { BaseException } from '@directus/shared/exceptions';
-declare type Extensions = {
+type Extensions = {
     service: string;
     [key: string]: any;
 };

package/dist/extensions.d.ts

@@ -1,7 +1,7 @@
 import { Router } from 'express';
-import { AppExtensionType, ExtensionType, HybridExtensionType } from '@directus/shared/types';
+import { ExtensionType } from '@directus/shared/types';
 export declare function getExtensionManager(): ExtensionManager;
-declare type Options = {
+type Options = {
     schedule: boolean;
     watch: boolean;
 };
@@ -12,6 +12,7 @@ declare class ExtensionManager {
     private appExtensions;
     private apiExtensions;
     private apiEmitter;
+    private hookEvents;
     private endpointRouter;
     private reloadQueue;
     private watcher;
@@ -19,7 +20,7 @@ declare class ExtensionManager {
     initialize(options?: Partial<Options>): Promise<void>;
     reload(): void;
     getExtensionsList(type?: ExtensionType): string[];
-    getAppExtensions(type: AppExtensionType | HybridExtensionType): string | undefined;
+    getAppExtensions(): string | null;
     getEndpointRouter(): Router;
     private load;
     private unload;
@@ -27,16 +28,15 @@ declare class ExtensionManager {
     private closeWatcher;
     private updateWatchedExtensions;
     private getExtensions;
-    private generateExtensionBundles;
+    private generateExtensionBundle;
     private getSharedDepsMapping;
     private registerHooks;
     private registerEndpoints;
     private registerOperations;
+    private registerBundles;
     private registerHook;
     private registerEndpoint;
     private registerOperation;
-    private unregisterHooks;
-    private unregisterEndpoints;
-    private unregisterOperations;
+    private unregisterApiExtensions;
 }
 export {};

package/dist/extensions.js

@@ -69,8 +69,9 @@ class ExtensionManager {
     constructor() {
         this.isLoaded = false;
         this.extensions = [];
-        this.appExtensions = {};
-        this.apiExtensions = { hooks: [], endpoints: [], operations: [] };
+        this.appExtensions = null;
+        this.apiExtensions = [];
+        this.hookEvents = [];
         this.watcher = null;
         this.options = defaultOptions;
         this.apiEmitter = new emitter_1.Emitter();
@@ -132,8 +133,8 @@ class ExtensionManager {
             return this.extensions.filter((extension) => extension.type === type).map((extension) => extension.name);
         }
     }
-    getAppExtensions(type) {
-        return this.appExtensions[type];
+    getAppExtensions() {
+        return this.appExtensions;
     }
     getEndpointRouter() {
         return this.endpointRouter;
@@ -147,21 +148,20 @@ class ExtensionManager {
             logger_1.default.warn(`Couldn't load extensions`);
             logger_1.default.warn(err);
         }
-        this.registerHooks();
-        this.registerEndpoints();
+        await this.registerHooks();
+        await this.registerEndpoints();
         await this.registerOperations();
+        await this.registerBundles();
         if (env_1.default.SERVE_APP) {
-            this.appExtensions = await this.generateExtensionBundles();
+            this.appExtensions = await this.generateExtensionBundle();
         }
         this.isLoaded = true;
     }
     async unload() {
-        this.unregisterHooks();
-        this.unregisterEndpoints();
-        this.unregisterOperations();
+        this.unregisterApiExtensions();
         this.apiEmitter.offAll();
         if (env_1.default.SERVE_APP) {
-            this.appExtensions = {};
+            this.appExtensions = null;
         }
         this.isLoaded = false;
     }
@@ -192,9 +192,9 @@ class ExtensionManager {
         if (this.watcher) {
             const toPackageExtensionPaths = (extensions) => extensions
                 .filter((extension) => !extension.local)
-                .flatMap((extension) => (0, utils_1.isTypeIn)(extension, constants_1.PACKAGE_EXTENSION_TYPES)
+                .flatMap((extension) => extension.type === 'pack'
                 ? path_1.default.resolve(extension.path, 'package.json')
-                : (0, utils_1.isTypeIn)(extension, constants_1.HYBRID_EXTENSION_TYPES)
+                : (0, utils_1.isTypeIn)(extension, constants_1.HYBRID_EXTENSION_TYPES) || extension.type === 'bundle'
                     ? [
                         path_1.default.resolve(extension.path, extension.entrypoint.app),
                         path_1.default.resolve(extension.path, extension.entrypoint.api),
@@ -211,32 +211,29 @@ class ExtensionManager {
         const localExtensions = await (0, node_1.getLocalExtensions)(env_1.default.EXTENSIONS_PATH, env_1.default.SERVE_APP ? constants_1.EXTENSION_TYPES : constants_1.API_OR_HYBRID_EXTENSION_TYPES);
         return [...packageExtensions, ...localExtensions];
     }
-    async generateExtensionBundles() {
+    async generateExtensionBundle() {
         const sharedDepsMapping = await this.getSharedDepsMapping(constants_1.APP_SHARED_DEPS);
         const internalImports = Object.entries(sharedDepsMapping).map(([name, path]) => ({
             find: name,
             replacement: path,
         }));
-        const bundles = {};
-        for (const extensionType of constants_1.APP_OR_HYBRID_EXTENSION_TYPES) {
-            const entry = (0, node_1.generateExtensionsEntry)(extensionType, this.extensions);
-            try {
-                const bundle = await (0, rollup_1.rollup)({
-                    input: 'entry',
-                    external: Object.values(sharedDepsMapping),
-                    makeAbsoluteExternalsRelative: false,
-                    plugins: [(0, plugin_virtual_1.default)({ entry }), (0, plugin_alias_1.default)({ entries: internalImports })],
-                });
-                const { output } = await bundle.generate({ format: 'es', compact: true });
-                bundles[extensionType] = output[0].code;
-                await bundle.close();
-            }
-            catch (error) {
-                logger_1.default.warn(`Couldn't bundle App extensions`);
-                logger_1.default.warn(error);
-            }
+        const entrypoint = (0, node_1.generateExtensionsEntrypoint)(this.extensions);
+        try {
+            const bundle = await (0, rollup_1.rollup)({
+                input: 'entry',
+                external: Object.values(sharedDepsMapping),
+                makeAbsoluteExternalsRelative: false,
+                plugins: [(0, plugin_virtual_1.default)({ entry: entrypoint }), (0, plugin_alias_1.default)({ entries: internalImports })],
+            });
+            const { output } = await bundle.generate({ format: 'es', compact: true });
+            await bundle.close();
+            return output[0].code;
+        }
+        catch (error) {
+            logger_1.default.warn(`Couldn't bundle App extensions`);
+            logger_1.default.warn(error);
         }
-        return bundles;
+        return null;
     }
     async getSharedDepsMapping(deps) {
         const appDir = await fs_extra_1.default.readdir(path_1.default.join((0, node_1.resolvePackage)('@directus/app', __dirname), 'dist', 'assets'));
@@ -254,14 +251,16 @@ class ExtensionManager {
         }
         return depsMapping;
     }
-    registerHooks() {
+    async registerHooks() {
+        var _a;
         const hooks = this.extensions.filter((extension) => extension.type === 'hook');
         for (const hook of hooks) {
             try {
                 const hookPath = path_1.default.resolve(hook.path, hook.entrypoint);
-                const hookInstance = require(hookPath);
+                const hookInstance = await (_a = hookPath, Promise.resolve().then(() => __importStar(require(_a))));
                 const config = (0, get_module_default_1.default)(hookInstance);
-                this.registerHook(config, hookPath);
+                this.registerHook(config);
+                this.apiExtensions.push({ path: hookPath });
             }
             catch (error) {
                 logger_1.default.warn(`Couldn't register hook "${hook.name}"`);
@@ -269,14 +268,15 @@ class ExtensionManager {
             }
         }
     }
-    registerEndpoints() {
+    async registerEndpoints() {
         const endpoints = this.extensions.filter((extension) => extension.type === 'endpoint');
         for (const endpoint of endpoints) {
             try {
                 const endpointPath = path_1.default.resolve(endpoint.path, endpoint.entrypoint);
                 const endpointInstance = require(endpointPath);
                 const config = (0, get_module_default_1.default)(endpointInstance);
-                this.registerEndpoint(config, endpointPath, endpoint.name, this.endpointRouter);
+                this.registerEndpoint(config, endpoint.name);
+                this.apiExtensions.push({ path: endpointPath });
             }
             catch (error) {
                 logger_1.default.warn(`Couldn't register endpoint "${endpoint.name}"`);
@@ -300,7 +300,8 @@ class ExtensionManager {
                 const operationPath = path_1.default.resolve(operation.path, operation.entrypoint.api);
                 const operationInstance = require(operationPath);
                 const config = (0, get_module_default_1.default)(operationInstance);
-                this.registerOperation(config, operationPath);
+                this.registerOperation(config);
+                this.apiExtensions.push({ path: operationPath });
             }
             catch (error) {
                 logger_1.default.warn(`Couldn't register operation "${operation.name}"`);
@@ -308,15 +309,35 @@ class ExtensionManager {
             }
         }
     }
-    registerHook(register, path) {
-        const hookHandler = {
-            path,
-            events: [],
-        };
+    async registerBundles() {
+        const bundles = this.extensions.filter((extension) => extension.type === 'bundle');
+        for (const bundle of bundles) {
+            try {
+                const bundlePath = path_1.default.resolve(bundle.path, bundle.entrypoint.api);
+                const bundleInstances = require(bundlePath);
+                const configs = (0, get_module_default_1.default)(bundleInstances);
+                for (const { config } of configs.hooks) {
+                    this.registerHook(config);
+                }
+                for (const { config, name } of configs.endpoints) {
+                    this.registerEndpoint(config, name);
+                }
+                for (const { config } of configs.operations) {
+                    this.registerOperation(config);
+                }
+                this.apiExtensions.push({ path: bundlePath });
+            }
+            catch (error) {
+                logger_1.default.warn(`Couldn't register bundle "${bundle.name}"`);
+                logger_1.default.warn(error);
+            }
+        }
+    }
+    registerHook(register) {
         const registerFunctions = {
             filter: (event, handler) => {
                 emitter_1.default.onFilter(event, handler);
-                hookHandler.events.push({
+                this.hookEvents.push({
                     type: 'filter',
                     name: event,
                     handler,
@@ -324,7 +345,7 @@ class ExtensionManager {
             },
             action: (event, handler) => {
                 emitter_1.default.onAction(event, handler);
-                hookHandler.events.push({
+                this.hookEvents.push({
                     type: 'action',
                     name: event,
                     handler,
@@ -332,7 +353,7 @@ class ExtensionManager {
             },
             init: (event, handler) => {
                 emitter_1.default.onInit(event, handler);
-                hookHandler.events.push({
+                this.hookEvents.push({
                     type: 'init',
                     name: event,
                     handler,
@@ -350,7 +371,7 @@ class ExtensionManager {
                             }
                         }
                     });
-                    hookHandler.events.push({
+                    this.hookEvents.push({
                         type: 'schedule',
                         task,
                     });
@@ -369,13 +390,12 @@ class ExtensionManager {
             logger: logger_1.default,
             getSchema: get_schema_1.getSchema,
         });
-        this.apiExtensions.hooks.push(hookHandler);
     }
-    registerEndpoint(config, path, name, router) {
+    registerEndpoint(config, name) {
         const register = typeof config === 'function' ? config : config.handler;
         const routeName = typeof config === 'function' ? name : config.id;
         const scopedRouter = express_1.default.Router();
-        router.use(`/${routeName}`, scopedRouter);
+        this.endpointRouter.use(`/${routeName}`, scopedRouter);
         register(scopedRouter, {
             services,
             exceptions: { ...exceptions, ...sharedExceptions },
@@ -385,52 +405,35 @@ class ExtensionManager {
             logger: logger_1.default,
             getSchema: get_schema_1.getSchema,
         });
-        this.apiExtensions.endpoints.push({
-            path,
-        });
     }
-    registerOperation(config, path) {
+    registerOperation(config) {
         const flowManager = (0, flows_1.getFlowManager)();
         flowManager.addOperation(config.id, config.handler);
-        this.apiExtensions.operations.push({
-            path,
-        });
     }
-    unregisterHooks() {
-        for (const hook of this.apiExtensions.hooks) {
-            for (const event of hook.events) {
-                switch (event.type) {
-                    case 'filter':
-                        emitter_1.default.offFilter(event.name, event.handler);
-                        break;
-                    case 'action':
-                        emitter_1.default.offAction(event.name, event.handler);
-                        break;
-                    case 'init':
-                        emitter_1.default.offInit(event.name, event.handler);
-                        break;
-                    case 'schedule':
-                        event.task.stop();
-                        break;
-                }
+    unregisterApiExtensions() {
+        for (const event of this.hookEvents) {
+            switch (event.type) {
+                case 'filter':
+                    emitter_1.default.offFilter(event.name, event.handler);
+                    break;
+                case 'action':
+                    emitter_1.default.offAction(event.name, event.handler);
+                    break;
+                case 'init':
+                    emitter_1.default.offInit(event.name, event.handler);
+                    break;
+                case 'schedule':
+                    event.task.stop();
+                    break;
             }
-            delete require.cache[require.resolve(hook.path)];
-        }
-        this.apiExtensions.hooks = [];
-    }
-    unregisterEndpoints() {
-        for (const endpoint of this.apiExtensions.endpoints) {
-            delete require.cache[require.resolve(endpoint.path)];
         }
+        this.hookEvents = [];
         this.endpointRouter.stack = [];
-        this.apiExtensions.endpoints = [];
-    }
-    unregisterOperations() {
-        for (const operation of this.apiExtensions.operations) {
-            delete require.cache[require.resolve(operation.path)];
-        }
         const flowManager = (0, flows_1.getFlowManager)();
         flowManager.clearOperations();
-        this.apiExtensions.operations = [];
+        for (const apiExtension of this.apiExtensions) {
+            delete require.cache[require.resolve(apiExtension.path)];
+        }
+        this.apiExtensions = [];
     }
 }

package/dist/logger.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="qs" />
 import { RequestHandler } from 'express';
 import { LoggerOptions } from 'pino';
 declare const logger: import("pino").Logger<LoggerOptions & Record<string, any>>;

package/dist/messenger.d.ts

@@ -1,5 +1,5 @@
 import type { Redis } from 'ioredis';
-export declare type MessengerSubscriptionCallback = (payload: Record<string, any>) => void;
+export type MessengerSubscriptionCallback = (payload: Record<string, any>) => void;
 export interface Messenger {
     publish: (channel: string, payload: Record<string, any>) => void;
     subscribe: (channel: string, callback: MessengerSubscriptionCallback) => void;

package/dist/middleware/authenticate.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="qs" />
 import { NextFunction, Request, Response } from 'express';
 /**
  * Verify the passed JWT and assign the user ID and role to `req`

package/dist/middleware/validate-batch.d.ts

@@ -1 +1,3 @@
+/// <reference types="qs" />
+/// <reference types="express" />
 export declare const validateBatch: (scope: 'read' | 'update' | 'delete') => (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: import("express").Response<any, Record<string, any>>, next: import("express").NextFunction) => Promise<void>;

package/dist/operations/condition/index.d.ts

@@ -1,5 +1,5 @@
 import { Filter } from '@directus/shared/types';
-declare type Options = {
+type Options = {
     filter: Filter;
 };
 declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;

package/dist/operations/condition/index.js

@@ -4,7 +4,7 @@ const utils_1 = require("@directus/shared/utils");
 exports.default = (0, utils_1.defineOperationApi)({
     id: 'condition',
     handler: ({ filter }, { data }) => {
-        const errors = (0, utils_1.validatePayload)(filter, data);
+        const errors = (0, utils_1.validatePayload)(filter, data, { requireAll: true });
         if (errors.length > 0) {
             throw errors;
         }

package/dist/operations/condition/index.test.d.ts

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

package/dist/operations/exec/index.d.ts

@@ -1,4 +1,4 @@
-declare type Options = {
+type Options = {
     code: string;
 };
 declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;

package/dist/operations/item-create/index.d.ts

@@ -1,4 +1,4 @@
-declare type Options = {
+type Options = {
     collection: string;
     payload?: Record<string, any> | string | null;
     emitEvents: boolean;

package/dist/operations/item-delete/index.d.ts

@@ -1,5 +1,5 @@
 import { PrimaryKey } from '@directus/shared/types';
-declare type Options = {
+type Options = {
     collection: string;
     key?: PrimaryKey | PrimaryKey[] | null;
     query?: Record<string, any> | string | null;

package/dist/operations/item-read/index.d.ts

@@ -1,5 +1,5 @@
 import { PrimaryKey } from '@directus/shared/types';
-declare type Options = {
+type Options = {
     collection: string;
     key?: PrimaryKey | PrimaryKey[] | null;
     query?: Record<string, any> | string | null;

package/dist/operations/item-update/index.d.ts

@@ -1,5 +1,5 @@
 import { PrimaryKey } from '@directus/shared/types';
-declare type Options = {
+type Options = {
     collection: string;
     key?: PrimaryKey | PrimaryKey[] | null;
     payload?: Record<string, any> | string | null;

package/dist/operations/log/index.d.ts

@@ -1,4 +1,4 @@
-declare type Options = {
+type Options = {
     message: unknown;
 };
 declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;

package/dist/operations/mail/index.d.ts

@@ -1,4 +1,4 @@
-declare type Options = {
+type Options = {
     body: string;
     to: string;
     type: 'wysiwyg' | 'markdown';

package/dist/operations/notification/index.d.ts

@@ -1,4 +1,4 @@
-declare type Options = {
+type Options = {
     recipient: string;
     subject: string;
     message?: unknown | null;

package/dist/operations/request/index.d.ts

@@ -1,5 +1,5 @@
 import { Method } from 'axios';
-declare type Options = {
+type Options = {
     url: string;
     method: Method;
     body: Record<string, any> | string | null;

package/dist/operations/sleep/index.d.ts

@@ -1,4 +1,4 @@
-declare type Options = {
+type Options = {
     milliseconds: string | number;
 };
 declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;

package/dist/operations/transform/index.d.ts

@@ -1,4 +1,4 @@
-declare type Options = {
+type Options = {
     json: string | Record<string, any>;
 };
 declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;

package/dist/operations/trigger/index.d.ts

@@ -1,4 +1,4 @@
-declare type Options = {
+type Options = {
     flow: string;
     payload?: Record<string, any> | Record<string, any>[] | string | null;
 };

package/dist/operations/trigger/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@directus/shared/utils");
+const lodash_1 = require("lodash");
 const flows_1 = require("../../flows");
 exports.default = (0, utils_1.defineOperationApi)({
     id: 'trigger',
@@ -10,10 +11,12 @@ exports.default = (0, utils_1.defineOperationApi)({
         const payloadObject = (_a = (0, utils_1.optionToObject)(payload)) !== null && _a !== void 0 ? _a : null;
         let result;
         if (Array.isArray(payloadObject)) {
-            result = await Promise.all(payloadObject.map((payload) => flowManager.runOperationFlow(flow, payload, context)));
+            result = await Promise.all(payloadObject.map((payload) => {
+                return flowManager.runOperationFlow(flow, payload, (0, lodash_1.omit)(context, 'data'));
+            }));
         }
         else {
-            result = await flowManager.runOperationFlow(flow, payloadObject, context);
+            result = await flowManager.runOperationFlow(flow, payloadObject, (0, lodash_1.omit)(context, 'data'));
         }
         return result;
     },

package/dist/rate-limiter.d.ts

@@ -1,4 +1,4 @@
 import { IRateLimiterOptions, IRateLimiterStoreOptions, RateLimiterAbstract } from 'rate-limiter-flexible';
-declare type IRateLimiterOptionsOverrides = Partial<IRateLimiterOptions> | Partial<IRateLimiterStoreOptions>;
+type IRateLimiterOptionsOverrides = Partial<IRateLimiterOptions> | Partial<IRateLimiterStoreOptions>;
 export declare function createRateLimiter(configOverrides?: IRateLimiterOptionsOverrides): RateLimiterAbstract;
 export {};

package/dist/services/authorization.js

@@ -151,7 +151,7 @@ class AuthorizationService {
             }
             if (ast.type === 'root') {
                 // Validate all required permissions once at the root level
-                checkFieldPermissions(ast.name, schema, action, requiredFieldPermissions);
+                checkFieldPermissions(ast.name, schema, action, requiredFieldPermissions, ast.query.alias);
             }
             return requiredFieldPermissions;
             function extractRequiredFieldPermissions(collection, filter, parentCollection, parentField) {
@@ -259,7 +259,7 @@ class AuthorizationService {
                 }
                 return current;
             }
-            function checkFieldPermissions(rootCollection, schema, action, requiredPermissions) {
+            function checkFieldPermissions(rootCollection, schema, action, requiredPermissions, aliasMap) {
                 var _a, _b;
                 if ((accountability === null || accountability === void 0 ? void 0 : accountability.admin) === true)
                     return;
@@ -291,7 +291,11 @@ class AuthorizationService {
                         if (field.startsWith('$FOLLOW'))
                             continue;
                         const fieldName = (0, strip_function_1.stripFunction)(field);
-                        if (!allowedFields.includes(fieldName)) {
+                        let originalFieldName = fieldName;
+                        if (collection === rootCollection && (aliasMap === null || aliasMap === void 0 ? void 0 : aliasMap[fieldName])) {
+                            originalFieldName = aliasMap[fieldName];
+                        }
+                        if (!allowedFields.includes(originalFieldName)) {
                             throw new exceptions_2.ForbiddenException();
                         }
                     }

package/dist/services/collections.d.ts

@@ -5,7 +5,7 @@ import { AbstractServiceOptions, Collection, CollectionMeta, MutationOptions } f
 import { Accountability, RawField, SchemaOverview } from '@directus/shared/types';
 import { Table } from 'knex-schema-inspector/dist/types/table';
 import { Helpers } from '../database/helpers';
-export declare type RawCollection = {
+export type RawCollection = {
     collection: string;
     fields?: RawField[];
     schema?: Partial<Table> | null;