directus 9.10.0 → 9.12.0

package/dist/extensions.js

@@ -45,6 +45,8 @@ const get_module_default_1 = __importDefault(require("./utils/get-module-default
 const lodash_1 = require("lodash");
 const chokidar_1 = __importDefault(require("chokidar"));
 const utils_1 = require("@directus/shared/utils");
+const flows_1 = require("./flows");
+const globby_1 = __importDefault(require("globby"));
 let extensionManager;
 function getExtensionManager() {
     if (extensionManager) {
@@ -63,7 +65,7 @@ class ExtensionManager {
         this.isLoaded = false;
         this.extensions = [];
         this.appExtensions = {};
-        this.apiExtensions = { hooks: [], endpoints: [] };
+        this.apiExtensions = { hooks: [], endpoints: [], operations: [] };
         this.watcher = null;
         this.options = defaultOptions;
         this.apiEmitter = new emitter_1.Emitter();
@@ -131,6 +133,7 @@ class ExtensionManager {
         }
         this.registerHooks();
         this.registerEndpoints();
+        await this.registerOperations();
         if (env_1.default.SERVE_APP) {
             this.appExtensions = await this.generateExtensionBundles();
         }
@@ -139,6 +142,7 @@ class ExtensionManager {
     async unload() {
         this.unregisterHooks();
         this.unregisterEndpoints();
+        this.unregisterOperations();
         this.apiEmitter.offAll();
         if (env_1.default.SERVE_APP) {
             this.appExtensions = {};
@@ -148,8 +152,13 @@ class ExtensionManager {
     initializeWatcher() {
         if (this.options.watch && !this.watcher) {
             logger_1.default.info('Watching extensions for changes...');
-            const localExtensionPaths = (env_1.default.SERVE_APP ? constants_1.EXTENSION_TYPES : constants_1.API_EXTENSION_TYPES).map((type) => path_1.default.posix.join(path_1.default.relative('.', env_1.default.EXTENSIONS_PATH).split(path_1.default.sep).join(path_1.default.posix.sep), (0, utils_1.pluralize)(type), '*', 'index.js'));
-            this.watcher = chokidar_1.default.watch([path_1.default.resolve('.', 'package.json'), ...localExtensionPaths], {
+            const localExtensionPaths = (env_1.default.SERVE_APP ? constants_1.EXTENSION_TYPES : constants_1.API_EXTENSION_TYPES).flatMap((type) => {
+                const typeDir = path_1.default.posix.join(path_1.default.relative('.', env_1.default.EXTENSIONS_PATH).split(path_1.default.sep).join(path_1.default.posix.sep), (0, utils_1.pluralize)(type));
+                return (0, utils_1.isHybridExtension)(type)
+                    ? [path_1.default.posix.join(typeDir, '*', 'app.js'), path_1.default.posix.join(typeDir, '*', 'api.js')]
+                    : path_1.default.posix.join(typeDir, '*', 'index.js');
+            });
+            this.watcher = chokidar_1.default.watch([path_1.default.resolve('package.json'), ...localExtensionPaths], {
                 ignoreInitial: true,
             });
             this.watcher
@@ -162,9 +171,14 @@ class ExtensionManager {
         if (this.watcher) {
             const toPackageExtensionPaths = (extensions) => extensions
                 .filter((extension) => !extension.local)
-                .map((extension) => extension.type !== 'pack'
-                ? path_1.default.resolve(extension.path, extension.entrypoint || '')
-                : path_1.default.resolve(extension.path, 'package.json'));
+                .flatMap((extension) => extension.type === constants_1.PACK_EXTENSION_TYPE
+                ? path_1.default.resolve(extension.path, 'package.json')
+                : (0, utils_1.isExtensionObject)(extension, constants_1.HYBRID_EXTENSION_TYPES)
+                    ? [
+                        path_1.default.resolve(extension.path, extension.entrypoint.app),
+                        path_1.default.resolve(extension.path, extension.entrypoint.api),
+                    ]
+                    : path_1.default.resolve(extension.path, extension.entrypoint));
             const addedPackageExtensionPaths = toPackageExtensionPaths(added);
             const removedPackageExtensionPaths = toPackageExtensionPaths(removed);
             this.watcher.add(addedPackageExtensionPaths);
@@ -223,7 +237,10 @@ class ExtensionManager {
         const hooks = this.extensions.filter((extension) => extension.type === 'hook');
         for (const hook of hooks) {
             try {
-                this.registerHook(hook);
+                const hookPath = path_1.default.resolve(hook.path, hook.entrypoint);
+                const hookInstance = require(hookPath);
+                const config = (0, get_module_default_1.default)(hookInstance);
+                this.registerHook(config, hookPath);
             }
             catch (error) {
                 logger_1.default.warn(`Couldn't register hook "${hook.name}"`);
@@ -235,7 +252,10 @@ class ExtensionManager {
         const endpoints = this.extensions.filter((extension) => extension.type === 'endpoint');
         for (const endpoint of endpoints) {
             try {
-                this.registerEndpoint(endpoint, this.endpointRouter);
+                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, this.endpointRouter);
             }
             catch (error) {
                 logger_1.default.warn(`Couldn't register endpoint "${endpoint.name}"`);
@@ -243,12 +263,33 @@ class ExtensionManager {
             }
         }
     }
-    registerHook(hook) {
-        const hookPath = path_1.default.resolve(hook.path, hook.entrypoint || '');
-        const hookInstance = require(hookPath);
-        const register = (0, get_module_default_1.default)(hookInstance);
+    async registerOperations() {
+        const internalPaths = await (0, globby_1.default)(path_1.default.posix.join(path_1.default.relative('.', __dirname).split(path_1.default.sep).join(path_1.default.posix.sep), 'operations/*/index.(js|ts)'));
+        const internalOperations = internalPaths.map((internalPath) => {
+            const dirs = internalPath.split(path_1.default.sep);
+            return {
+                name: dirs[dirs.length - 2],
+                path: dirs.slice(0, -1).join(path_1.default.sep),
+                entrypoint: { api: dirs[dirs.length - 1] },
+            };
+        });
+        const operations = this.extensions.filter((extension) => extension.type === 'operation');
+        for (const operation of [...internalOperations, ...operations]) {
+            try {
+                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);
+            }
+            catch (error) {
+                logger_1.default.warn(`Couldn't register operation "${operation.name}"`);
+                logger_1.default.warn(error);
+            }
+        }
+    }
+    registerHook(register, path) {
         const hookHandler = {
-            path: hookPath,
+            path,
             events: [],
         };
         const registerFunctions = {
@@ -309,12 +350,9 @@ class ExtensionManager {
         });
         this.apiExtensions.hooks.push(hookHandler);
     }
-    registerEndpoint(endpoint, router) {
-        const endpointPath = path_1.default.resolve(endpoint.path, endpoint.entrypoint || '');
-        const endpointInstance = require(endpointPath);
-        const mod = (0, get_module_default_1.default)(endpointInstance);
-        const register = typeof mod === 'function' ? mod : mod.handler;
-        const routeName = typeof mod === 'function' ? endpoint.name : mod.id;
+    registerEndpoint(config, path, router) {
+        const register = typeof config === 'function' ? config : config.handler;
+        const routeName = typeof config === 'function' ? config.name : config.id;
         const scopedRouter = express_1.default.Router();
         router.use(`/${routeName}`, scopedRouter);
         register(scopedRouter, {
@@ -327,7 +365,14 @@ class ExtensionManager {
             getSchema: get_schema_1.getSchema,
         });
         this.apiExtensions.endpoints.push({
-            path: endpointPath,
+            path,
+        });
+    }
+    registerOperation(config, path) {
+        const flowManager = (0, flows_1.getFlowManager)();
+        flowManager.addOperation(config.id, config.handler);
+        this.apiExtensions.operations.push({
+            path,
         });
     }
     unregisterHooks() {
@@ -359,4 +404,12 @@ class ExtensionManager {
         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 = [];
+    }
 }

package/dist/flows.d.ts

@@ -0,0 +1,17 @@
+import { OperationHandler } from '@directus/shared/types';
+export declare function getFlowManager(): FlowManager;
+declare class FlowManager {
+    private operations;
+    private triggerHandlers;
+    private operationFlowHandlers;
+    private webhookFlowHandlers;
+    initialize(): Promise<void>;
+    reload(): Promise<void>;
+    addOperation(id: string, operation: OperationHandler): void;
+    clearOperations(): void;
+    runOperationFlow(id: string, data: unknown, context: Record<string, unknown>): Promise<unknown>;
+    runWebhookFlow(id: string, data: unknown, context: Record<string, unknown>): Promise<unknown>;
+    private executeFlow;
+    private executeOperation;
+}
+export {};

package/dist/flows.js

@@ -0,0 +1,310 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFlowManager = void 0;
+const sharedExceptions = __importStar(require("@directus/shared/exceptions"));
+const types_1 = require("@directus/shared/types");
+const micromustache_1 = require("micromustache");
+const node_cron_1 = require("node-cron");
+const database_1 = __importDefault(require("./database"));
+const emitter_1 = __importDefault(require("./emitter"));
+const env_1 = __importDefault(require("./env"));
+const exceptions = __importStar(require("./exceptions"));
+const logger_1 = __importDefault(require("./logger"));
+const services = __importStar(require("./services"));
+const services_1 = require("./services");
+const construct_flow_tree_1 = require("./utils/construct-flow-tree");
+const get_schema_1 = require("./utils/get-schema");
+const activity_1 = require("./services/activity");
+const revisions_1 = require("./services/revisions");
+const lodash_1 = require("lodash");
+const messenger_1 = require("./messenger");
+const fast_redact_1 = __importDefault(require("fast-redact"));
+const operation_options_1 = require("./utils/operation-options");
+let flowManager;
+const redactLogs = (0, fast_redact_1.default)({
+    censor: '--redacted--',
+    paths: ['*.headers.authorization', '*.access_token', '*.headers.cookie'],
+    serialize: false,
+});
+function getFlowManager() {
+    if (flowManager) {
+        return flowManager;
+    }
+    flowManager = new FlowManager();
+    return flowManager;
+}
+exports.getFlowManager = getFlowManager;
+const TRIGGER_KEY = '$trigger';
+const ACCOUNTABILITY_KEY = '$accountability';
+const LAST_KEY = '$last';
+class FlowManager {
+    constructor() {
+        this.operations = {};
+        this.triggerHandlers = [];
+        this.operationFlowHandlers = {};
+        this.webhookFlowHandlers = {};
+    }
+    async initialize() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const flowsService = new services_1.FlowsService({ knex: (0, database_1.default)(), schema: await (0, get_schema_1.getSchema)() });
+        const flows = await flowsService.readByQuery({
+            filter: { status: { _eq: 'active' } },
+            fields: ['*', 'operations.*'],
+        });
+        const flowTrees = flows.map((flow) => (0, construct_flow_tree_1.constructFlowTree)(flow));
+        for (const flow of flowTrees) {
+            if (flow.trigger === 'event') {
+                const events = (_d = (_c = (_b = (_a = flow.options) === null || _a === void 0 ? void 0 : _a.scope) === null || _b === void 0 ? void 0 : _b.map((scope) => {
+                    var _a, _b, _c;
+                    if (['items.create', 'items.update', 'items.delete'].includes(scope)) {
+                        return ((_c = (_b = (_a = flow.options) === null || _a === void 0 ? void 0 : _a.collections) === null || _b === void 0 ? void 0 : _b.map((collection) => {
+                            if (collection.startsWith('directus_')) {
+                                const action = scope.split('.')[1];
+                                return collection.substring(9) + '.' + action;
+                            }
+                            return `${collection}.${scope}`;
+                        })) !== null && _c !== void 0 ? _c : []);
+                    }
+                    return scope;
+                })) === null || _c === void 0 ? void 0 : _c.flat()) !== null && _d !== void 0 ? _d : [];
+                if (flow.options.type === 'filter') {
+                    const handler = (payload, meta, context) => this.executeFlow(flow, { payload, ...meta }, {
+                        accountability: context.accountability,
+                        database: context.database,
+                        getSchema: context.schema ? () => context.schema : get_schema_1.getSchema,
+                    });
+                    events.forEach((event) => emitter_1.default.onFilter(event, handler));
+                    this.triggerHandlers.push({
+                        id: flow.id,
+                        events: events.map((event) => ({ type: 'filter', name: event, handler })),
+                    });
+                }
+                else if (flow.options.type === 'action') {
+                    const handler = (meta, context) => this.executeFlow(flow, meta, {
+                        accountability: context.accountability,
+                        database: context.database,
+                        getSchema: context.schema ? () => context.schema : get_schema_1.getSchema,
+                    });
+                    events.forEach((event) => emitter_1.default.onAction(event, handler));
+                    this.triggerHandlers.push({
+                        id: flow.id,
+                        events: events.map((event) => ({ type: 'action', name: event, handler })),
+                    });
+                }
+            }
+            else if (flow.trigger === 'schedule') {
+                if ((0, node_cron_1.validate)(flow.options.cron)) {
+                    const task = (0, node_cron_1.schedule)(flow.options.cron, async () => {
+                        try {
+                            await this.executeFlow(flow);
+                        }
+                        catch (error) {
+                            logger_1.default.error(error);
+                        }
+                    });
+                    this.triggerHandlers.push({ id: flow.id, events: [{ type: flow.trigger, task }] });
+                }
+                else {
+                    logger_1.default.warn(`Couldn't register cron trigger. Provided cron is invalid: ${flow.options.cron}`);
+                }
+            }
+            else if (flow.trigger === 'operation') {
+                const handler = (data, context) => this.executeFlow(flow, data, context);
+                this.operationFlowHandlers[flow.id] = handler;
+            }
+            else if (flow.trigger === 'webhook') {
+                const handler = (data, context) => {
+                    if (flow.options.async) {
+                        this.executeFlow(flow, data, context);
+                    }
+                    else {
+                        return this.executeFlow(flow, data, context);
+                    }
+                };
+                const method = (_f = (_e = flow.options) === null || _e === void 0 ? void 0 : _e.method) !== null && _f !== void 0 ? _f : 'GET';
+                // Default return to $last for webhooks
+                flow.options.return = (_g = flow.options.return) !== null && _g !== void 0 ? _g : '$last';
+                this.webhookFlowHandlers[`${method}-${flow.id}`] = handler;
+            }
+            else if (flow.trigger === 'manual') {
+                const handler = (data, context) => {
+                    var _a, _b, _c;
+                    const enabledCollections = (_b = (_a = flow.options) === null || _a === void 0 ? void 0 : _a.collections) !== null && _b !== void 0 ? _b : [];
+                    const targetCollection = (_c = data) === null || _c === void 0 ? void 0 : _c.body.collection;
+                    if (!targetCollection) {
+                        logger_1.default.warn(`Manual trigger requires "collection" to be specified in the payload`);
+                        throw new exceptions.ForbiddenException();
+                    }
+                    if (enabledCollections.length === 0) {
+                        logger_1.default.warn(`There is no collections configured for this manual trigger`);
+                        throw new exceptions.ForbiddenException();
+                    }
+                    if (!enabledCollections.includes(targetCollection)) {
+                        logger_1.default.warn(`Specified collection must be one of: ${enabledCollections.join(', ')}.`);
+                        throw new exceptions.ForbiddenException();
+                    }
+                    if (flow.options.async) {
+                        this.executeFlow(flow, data, context);
+                    }
+                    else {
+                        return this.executeFlow(flow, data, context);
+                    }
+                };
+                // Default return to $last for manual
+                flow.options.return = '$last';
+                this.webhookFlowHandlers[`POST-${flow.id}`] = handler;
+            }
+        }
+        (0, messenger_1.getMessenger)().subscribe('flows', (event) => {
+            if (event.type === 'reload') {
+                this.reload();
+            }
+        });
+    }
+    async reload() {
+        for (const trigger of this.triggerHandlers) {
+            trigger.events.forEach((event) => {
+                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 'schedule':
+                        event.task.stop();
+                        break;
+                }
+            });
+        }
+        this.triggerHandlers = [];
+        this.operationFlowHandlers = {};
+        this.webhookFlowHandlers = {};
+        await this.initialize();
+    }
+    addOperation(id, operation) {
+        this.operations[id] = operation;
+    }
+    clearOperations() {
+        this.operations = {};
+    }
+    async runOperationFlow(id, data, context) {
+        if (!(id in this.operationFlowHandlers)) {
+            logger_1.default.warn(`Couldn't find operation triggered flow with id "${id}"`);
+            return null;
+        }
+        const handler = this.operationFlowHandlers[id];
+        return handler(data, context);
+    }
+    async runWebhookFlow(id, data, context) {
+        if (!(id in this.webhookFlowHandlers)) {
+            logger_1.default.warn(`Couldn't find webhook or manual triggered flow with id "${id}"`);
+            throw new exceptions.ForbiddenException();
+        }
+        const handler = this.webhookFlowHandlers[id];
+        return handler(data, context);
+    }
+    async executeFlow(flow, data = null, context = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        const database = (_a = context.database) !== null && _a !== void 0 ? _a : (0, database_1.default)();
+        const schema = (_b = context.schema) !== null && _b !== void 0 ? _b : (await (0, get_schema_1.getSchema)({ database }));
+        const keyedData = {
+            [TRIGGER_KEY]: data,
+            [LAST_KEY]: data,
+            [ACCOUNTABILITY_KEY]: (_c = context === null || context === void 0 ? void 0 : context.accountability) !== null && _c !== void 0 ? _c : null,
+        };
+        let nextOperation = flow.operation;
+        const steps = [];
+        while (nextOperation !== null) {
+            const { successor, data, status, options } = await this.executeOperation(nextOperation, keyedData, context);
+            keyedData[nextOperation.key] = data;
+            keyedData[LAST_KEY] = data;
+            steps.push({ operation: nextOperation.id, key: nextOperation.key, status, options });
+            nextOperation = successor;
+        }
+        if (flow.accountability !== null) {
+            const activityService = new activity_1.ActivityService({
+                knex: database,
+                schema: schema,
+            });
+            const accountability = context === null || context === void 0 ? void 0 : context.accountability;
+            const activity = await activityService.createOne({
+                action: types_1.Action.RUN,
+                user: (_d = accountability === null || accountability === void 0 ? void 0 : accountability.user) !== null && _d !== void 0 ? _d : null,
+                collection: 'directus_flows',
+                ip: (_e = accountability === null || accountability === void 0 ? void 0 : accountability.ip) !== null && _e !== void 0 ? _e : null,
+                user_agent: (_f = accountability === null || accountability === void 0 ? void 0 : accountability.userAgent) !== null && _f !== void 0 ? _f : null,
+                item: flow.id,
+            });
+            if (flow.accountability === 'all') {
+                const revisionsService = new revisions_1.RevisionsService({
+                    knex: database,
+                    schema: schema,
+                });
+                await revisionsService.createOne({
+                    activity: activity,
+                    collection: 'directus_flows',
+                    item: flow.id,
+                    data: {
+                        steps: steps,
+                        data: redactLogs((0, lodash_1.omit)(keyedData, '$accountability.permissions')), // Permissions is a ton of data, and is just a copy of what's in the directus_permissions table
+                    },
+                });
+            }
+        }
+        if (flow.options.return === '$all') {
+            return keyedData;
+        }
+        else if (flow.options.return) {
+            return (0, micromustache_1.get)(keyedData, flow.options.return);
+        }
+        return undefined;
+    }
+    async executeOperation(operation, keyedData, context = {}) {
+        if (!(operation.type in this.operations)) {
+            logger_1.default.warn(`Couldn't find operation ${operation.type}`);
+            return { successor: null, status: 'unknown', data: null, options: null };
+        }
+        const handler = this.operations[operation.type];
+        const options = (0, operation_options_1.applyOperationOptions)(operation.options, keyedData);
+        try {
+            const result = await handler(options, {
+                services,
+                exceptions: { ...exceptions, ...sharedExceptions },
+                env: env_1.default,
+                database: (0, database_1.default)(),
+                logger: logger_1.default,
+                getSchema: get_schema_1.getSchema,
+                data: keyedData,
+                accountability: null,
+                ...context,
+            });
+            return { successor: operation.resolve, status: 'resolve', data: result !== null && result !== void 0 ? result : null, options };
+        }
+        catch (error) {
+            return { successor: operation.reject, status: 'reject', data: error !== null && error !== void 0 ? error : null, options };
+        }
+    }
+}

package/dist/messenger.d.ts

@@ -0,0 +1,24 @@
+import IORedis from 'ioredis';
+export declare type MessengerSubscriptionCallback = (payload: Record<string, any>) => void;
+export interface Messenger {
+    publish: (channel: string, payload: Record<string, any>) => void;
+    subscribe: (channel: string, callback: MessengerSubscriptionCallback) => void;
+    unsubscribe: (channel: string) => void;
+}
+export declare class MessengerMemory implements Messenger {
+    handlers: Record<string, MessengerSubscriptionCallback>;
+    constructor();
+    publish(channel: string, payload: Record<string, any>): void;
+    subscribe(channel: string, callback: MessengerSubscriptionCallback): void;
+    unsubscribe(channel: string): void;
+}
+export declare class MessengerRedis implements Messenger {
+    namespace: string;
+    pub: IORedis.Redis;
+    sub: IORedis.Redis;
+    constructor();
+    publish(channel: string, payload: Record<string, any>): void;
+    subscribe(channel: string, callback: MessengerSubscriptionCallback): void;
+    unsubscribe(channel: string): void;
+}
+export declare function getMessenger(): Messenger;

package/dist/messenger.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMessenger = exports.MessengerRedis = exports.MessengerMemory = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+const env_1 = __importDefault(require("./env"));
+const get_config_from_env_1 = require("./utils/get-config-from-env");
+const parse_json_1 = require("./utils/parse-json");
+class MessengerMemory {
+    constructor() {
+        this.handlers = {};
+    }
+    publish(channel, payload) {
+        var _a, _b;
+        (_b = (_a = this.handlers)[channel]) === null || _b === void 0 ? void 0 : _b.call(_a, payload);
+    }
+    subscribe(channel, callback) {
+        this.handlers[channel] = callback;
+    }
+    unsubscribe(channel) {
+        delete this.handlers[channel];
+    }
+}
+exports.MessengerMemory = MessengerMemory;
+class MessengerRedis {
+    constructor() {
+        var _a, _b, _c;
+        const config = (0, get_config_from_env_1.getConfigFromEnv)('MESSENGER_REDIS');
+        this.pub = new ioredis_1.default((_a = env_1.default.MESSENGER_REDIS) !== null && _a !== void 0 ? _a : config);
+        this.sub = new ioredis_1.default((_b = env_1.default.MESSENGER_REDIS) !== null && _b !== void 0 ? _b : config);
+        this.namespace = (_c = env_1.default.MESSENGER_NAMESPACE) !== null && _c !== void 0 ? _c : 'directus';
+    }
+    publish(channel, payload) {
+        this.pub.publish(`${this.namespace}:${channel}`, JSON.stringify(payload));
+    }
+    subscribe(channel, callback) {
+        this.sub.subscribe(`${this.namespace}:${channel}`);
+        this.sub.on('message', (messageChannel, payloadString) => {
+            const payload = (0, parse_json_1.parseJSON)(payloadString);
+            if (messageChannel === `${this.namespace}:${channel}`) {
+                callback(payload);
+            }
+        });
+    }
+    unsubscribe(channel) {
+        this.sub.unsubscribe(`${this.namespace}:${channel}`);
+    }
+}
+exports.MessengerRedis = MessengerRedis;
+let messenger;
+function getMessenger() {
+    if (messenger)
+        return messenger;
+    if (env_1.default.MESSENGER_STORE === 'redis') {
+        messenger = new MessengerRedis();
+    }
+    else {
+        messenger = new MessengerMemory();
+    }
+    return messenger;
+}
+exports.getMessenger = getMessenger;

package/dist/middleware/graphql.js

@@ -7,6 +7,7 @@ exports.parseGraphQL = void 0;
 const graphql_1 = require("graphql");
 const exceptions_1 = require("../exceptions");
 const async_handler_1 = __importDefault(require("../utils/async-handler"));
+const parse_json_1 = require("../utils/parse-json");
 exports.parseGraphQL = (0, async_handler_1.default)(async (req, res, next) => {
     if (req.method !== 'GET' && req.method !== 'POST') {
         throw new exceptions_1.MethodNotAllowedException('GraphQL only supports GET and POST requests.', { allow: ['GET', 'POST'] });
@@ -19,7 +20,7 @@ exports.parseGraphQL = (0, async_handler_1.default)(async (req, res, next) => {
         query = req.query.query || null;
         if (req.query.variables) {
             try {
-                variables = JSON.parse(req.query.variables);
+                variables = (0, parse_json_1.parseJSON)(req.query.variables);
             }
             catch {
                 throw new exceptions_1.InvalidQueryException(`Variables are invalid JSON.`);

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

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

package/dist/operations/condition/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+        if (errors.length > 0) {
+            throw errors;
+        }
+        else {
+            return null;
+        }
+    },
+});

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

@@ -0,0 +1,8 @@
+declare type Options = {
+    collection: string;
+    payload?: Record<string, any> | string | null;
+    emitEvents: boolean;
+    permissions: string;
+};
+declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
+export default _default;