@directus/api 9.25.0

package/dist/flows.js

@@ -0,0 +1,350 @@
+import * as sharedExceptions from '@directus/exceptions';
+import { Action } from '@directus/constants';
+import { applyOptionsData, isValidJSON, parseJSON, toArray } from '@directus/utils';
+import fastRedact from 'fast-redact';
+import { omit, pick } from 'lodash-es';
+import { get } from 'micromustache';
+import { schedule, validate } from 'node-cron';
+import getDatabase from './database/index.js';
+import emitter from './emitter.js';
+import env from './env.js';
+import * as exceptions from './exceptions/index.js';
+import { BaseException } from '@directus/exceptions';
+import logger from './logger.js';
+import { getMessenger } from './messenger.js';
+import { ActivityService } from './services/activity.js';
+import * as services from './services/index.js';
+import { FlowsService } from './services/flows.js';
+import { RevisionsService } from './services/revisions.js';
+import { constructFlowTree } from './utils/construct-flow-tree.js';
+import { getSchema } from './utils/get-schema.js';
+import { JobQueue } from './utils/job-queue.js';
+import { mapValuesDeep } from './utils/map-values-deep.js';
+let flowManager;
+const redactLogs = fastRedact({
+    censor: '--redacted--',
+    paths: ['*.headers.authorization', '*.access_token', '*.headers.cookie'],
+    serialize: false,
+});
+export function getFlowManager() {
+    if (flowManager) {
+        return flowManager;
+    }
+    flowManager = new FlowManager();
+    return flowManager;
+}
+const TRIGGER_KEY = '$trigger';
+const ACCOUNTABILITY_KEY = '$accountability';
+const LAST_KEY = '$last';
+const ENV_KEY = '$env';
+class FlowManager {
+    isLoaded = false;
+    operations = {};
+    triggerHandlers = [];
+    operationFlowHandlers = {};
+    webhookFlowHandlers = {};
+    reloadQueue;
+    constructor() {
+        this.reloadQueue = new JobQueue();
+        const messenger = getMessenger();
+        messenger.subscribe('flows', (event) => {
+            if (event['type'] === 'reload') {
+                this.reloadQueue.enqueue(async () => {
+                    if (this.isLoaded) {
+                        await this.unload();
+                        await this.load();
+                    }
+                    else {
+                        logger.warn('Flows have to be loaded before they can be reloaded');
+                    }
+                });
+            }
+        });
+    }
+    async initialize() {
+        if (!this.isLoaded) {
+            await this.load();
+        }
+    }
+    async reload() {
+        const messenger = getMessenger();
+        messenger.publish('flows', { type: 'reload' });
+    }
+    addOperation(id, operation) {
+        this.operations[id] = operation;
+    }
+    clearOperations() {
+        this.operations = {};
+    }
+    async runOperationFlow(id, data, context) {
+        if (!(id in this.operationFlowHandlers)) {
+            logger.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.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 load() {
+        const flowsService = new FlowsService({ knex: getDatabase(), schema: await getSchema() });
+        const flows = await flowsService.readByQuery({
+            filter: { status: { _eq: 'active' } },
+            fields: ['*', 'operations.*'],
+            limit: -1,
+        });
+        const flowTrees = flows.map((flow) => constructFlowTree(flow));
+        for (const flow of flowTrees) {
+            if (flow.trigger === 'event') {
+                let events = [];
+                if (flow.options?.['scope']) {
+                    events = toArray(flow.options['scope'])
+                        .map((scope) => {
+                        if (['items.create', 'items.update', 'items.delete'].includes(scope)) {
+                            if (!flow.options?.['collections'])
+                                return [];
+                            return toArray(flow.options['collections']).map((collection) => {
+                                if (collection.startsWith('directus_')) {
+                                    const action = scope.split('.')[1];
+                                    return collection.substring(9) + '.' + action;
+                                }
+                                return `${collection}.${scope}`;
+                            });
+                        }
+                        return scope;
+                    })
+                        .flat();
+                }
+                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'] : getSchema,
+                    });
+                    events.forEach((event) => emitter.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: getDatabase(),
+                        getSchema: context['schema'] ? () => context['schema'] : getSchema,
+                    });
+                    events.forEach((event) => emitter.onAction(event, handler));
+                    this.triggerHandlers.push({
+                        id: flow.id,
+                        events: events.map((event) => ({ type: 'action', name: event, handler })),
+                    });
+                }
+            }
+            else if (flow.trigger === 'schedule') {
+                if (validate(flow.options['cron'])) {
+                    const task = schedule(flow.options['cron'], async () => {
+                        try {
+                            await this.executeFlow(flow);
+                        }
+                        catch (error) {
+                            logger.error(error);
+                        }
+                    });
+                    this.triggerHandlers.push({ id: flow.id, events: [{ type: flow.trigger, task }] });
+                }
+                else {
+                    logger.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);
+                        return undefined;
+                    }
+                    else {
+                        return this.executeFlow(flow, data, context);
+                    }
+                };
+                const method = flow.options?.['method'] ?? 'GET';
+                // Default return to $last for webhooks
+                flow.options['return'] = flow.options['return'] ?? '$last';
+                this.webhookFlowHandlers[`${method}-${flow.id}`] = handler;
+            }
+            else if (flow.trigger === 'manual') {
+                const handler = (data, context) => {
+                    const enabledCollections = flow.options?.['collections'] ?? [];
+                    const targetCollection = data?.['body'].collection;
+                    if (!targetCollection) {
+                        logger.warn(`Manual trigger requires "collection" to be specified in the payload`);
+                        throw new exceptions.ForbiddenException();
+                    }
+                    if (enabledCollections.length === 0) {
+                        logger.warn(`There is no collections configured for this manual trigger`);
+                        throw new exceptions.ForbiddenException();
+                    }
+                    if (!enabledCollections.includes(targetCollection)) {
+                        logger.warn(`Specified collection must be one of: ${enabledCollections.join(', ')}.`);
+                        throw new exceptions.ForbiddenException();
+                    }
+                    if (flow.options['async']) {
+                        this.executeFlow(flow, data, context);
+                        return undefined;
+                    }
+                    else {
+                        return this.executeFlow(flow, data, context);
+                    }
+                };
+                // Default return to $last for manual
+                flow.options['return'] = '$last';
+                this.webhookFlowHandlers[`POST-${flow.id}`] = handler;
+            }
+        }
+        this.isLoaded = true;
+    }
+    async unload() {
+        for (const trigger of this.triggerHandlers) {
+            trigger.events.forEach((event) => {
+                switch (event.type) {
+                    case 'filter':
+                        emitter.offFilter(event.name, event.handler);
+                        break;
+                    case 'action':
+                        emitter.offAction(event.name, event.handler);
+                        break;
+                    case 'schedule':
+                        event.task.stop();
+                        break;
+                }
+            });
+        }
+        this.triggerHandlers = [];
+        this.operationFlowHandlers = {};
+        this.webhookFlowHandlers = {};
+        this.isLoaded = false;
+    }
+    async executeFlow(flow, data = null, context = {}) {
+        const database = context['database'] ?? getDatabase();
+        const schema = context['schema'] ?? (await getSchema({ database }));
+        const keyedData = {
+            [TRIGGER_KEY]: data,
+            [LAST_KEY]: data,
+            [ACCOUNTABILITY_KEY]: context?.['accountability'] ?? null,
+            [ENV_KEY]: pick(env, env['FLOWS_ENV_ALLOW_LIST'] ? toArray(env['FLOWS_ENV_ALLOW_LIST']) : []),
+        };
+        let nextOperation = flow.operation;
+        let lastOperationStatus = 'unknown';
+        const steps = [];
+        while (nextOperation !== null) {
+            const { successor, data, status, options } = await this.executeOperation(nextOperation, keyedData, context);
+            keyedData[nextOperation.key] = data;
+            keyedData[LAST_KEY] = data;
+            lastOperationStatus = status;
+            steps.push({ operation: nextOperation.id, key: nextOperation.key, status, options });
+            nextOperation = successor;
+        }
+        if (flow.accountability !== null) {
+            const activityService = new ActivityService({
+                knex: database,
+                schema: schema,
+            });
+            const accountability = context?.['accountability'];
+            const activity = await activityService.createOne({
+                action: Action.RUN,
+                user: accountability?.user ?? null,
+                collection: 'directus_flows',
+                ip: accountability?.ip ?? null,
+                user_agent: accountability?.userAgent ?? null,
+                origin: accountability?.origin ?? null,
+                item: flow.id,
+            });
+            if (flow.accountability === 'all') {
+                const revisionsService = new RevisionsService({
+                    knex: database,
+                    schema: schema,
+                });
+                await revisionsService.createOne({
+                    activity: activity,
+                    collection: 'directus_flows',
+                    item: flow.id,
+                    data: {
+                        steps: steps,
+                        data: redactLogs(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.trigger === 'event' && flow.options['type'] === 'filter' && lastOperationStatus === 'reject') {
+            throw keyedData[LAST_KEY];
+        }
+        if (flow.options['return'] === '$all') {
+            return keyedData;
+        }
+        else if (flow.options['return']) {
+            return get(keyedData, flow.options['return']);
+        }
+        return undefined;
+    }
+    async executeOperation(operation, keyedData, context = {}) {
+        if (!(operation.type in this.operations)) {
+            logger.warn(`Couldn't find operation ${operation.type}`);
+            return { successor: null, status: 'unknown', data: null, options: null };
+        }
+        const handler = this.operations[operation.type];
+        const options = applyOptionsData(operation.options, keyedData);
+        try {
+            let result = await handler(options, {
+                services,
+                exceptions: { ...exceptions, ...sharedExceptions },
+                env,
+                database: getDatabase(),
+                logger,
+                getSchema,
+                data: keyedData,
+                accountability: null,
+                ...context,
+            });
+            // Validate that the operations result is serializable and thus catching the error inside the flow execution
+            JSON.stringify(result ?? null);
+            // JSON structures don't allow for undefined values, so we need to replace them with null
+            // Otherwise the applyOptionsData function will not work correctly on the next operation
+            if (typeof result === 'object' && result !== null) {
+                result = mapValuesDeep(result, (_, value) => (value === undefined ? null : value));
+            }
+            return { successor: operation.resolve, status: 'resolve', data: result ?? null, options };
+        }
+        catch (error) {
+            let data;
+            if (error instanceof BaseException) {
+                data = { message: error.message, code: error.code, extensions: error.extensions, status: error.status };
+            }
+            else if (error instanceof Error) {
+                data = { message: error.message };
+            }
+            else if (typeof error === 'string') {
+                // If the error is a JSON string, parse it and use that as the error data
+                data = isValidJSON(error) ? parseJSON(error) : error;
+            }
+            else {
+                // If error is plain object, use this as the error data and otherwise fallback to null
+                data = error ?? null;
+            }
+            return {
+                successor: operation.reject,
+                status: 'reject',
+                data,
+                options,
+            };
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { default as createApp } from './app.js';
+export * from './services/index.js';
+export * from './exceptions/index.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { default as createApp } from './app.js';
+export * from './services/index.js';
+export * from './exceptions/index.js';

package/dist/logger.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="qs" />
+import type { LoggerOptions } from 'pino';
+import type { RequestHandler } from 'express';
+export declare const httpLoggerOptions: LoggerOptions;
+declare const logger: import("pino").Logger<LoggerOptions & Record<string, any>>;
+export declare const expressLogger: RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+export default logger;

package/dist/logger.js

@@ -0,0 +1,105 @@
+import { toArray } from '@directus/utils';
+import { merge } from 'lodash-es';
+import { pino } from 'pino';
+import { pinoHttp, stdSerializers } from 'pino-http';
+import { URL } from 'url';
+import env from './env.js';
+import { REDACT_TEXT } from './constants.js';
+import { getConfigFromEnv } from './utils/get-config-from-env.js';
+const pinoOptions = {
+    level: env['LOG_LEVEL'] || 'info',
+    redact: {
+        paths: ['req.headers.authorization', 'req.headers.cookie'],
+        censor: REDACT_TEXT,
+    },
+};
+export const httpLoggerOptions = {
+    level: env['LOG_LEVEL'] || 'info',
+    redact: {
+        paths: ['req.headers.authorization', 'req.headers.cookie'],
+        censor: REDACT_TEXT,
+    },
+};
+if (env['LOG_STYLE'] !== 'raw') {
+    pinoOptions.transport = {
+        target: 'pino-pretty',
+        options: {
+            ignore: 'hostname,pid',
+            sync: true,
+        },
+    };
+    httpLoggerOptions.transport = {
+        target: 'pino-http-print',
+        options: {
+            all: true,
+            translateTime: 'SYS:HH:MM:ss',
+            relativeUrl: true,
+            prettyOptions: {
+                ignore: 'hostname,pid',
+                sync: true,
+            },
+        },
+    };
+}
+if (env['LOG_STYLE'] === 'raw') {
+    httpLoggerOptions.redact = {
+        paths: ['req.headers.authorization', 'req.headers.cookie', 'res.headers'],
+        censor: (value, pathParts) => {
+            const path = pathParts.join('.');
+            if (path === 'res.headers') {
+                if ('set-cookie' in value) {
+                    value['set-cookie'] = REDACT_TEXT;
+                }
+                return value;
+            }
+            return REDACT_TEXT;
+        },
+    };
+}
+const loggerEnvConfig = getConfigFromEnv('LOGGER_', 'LOGGER_HTTP');
+// Expose custom log levels into formatter function
+if (loggerEnvConfig['levels']) {
+    const customLogLevels = {};
+    for (const el of toArray(loggerEnvConfig['levels'])) {
+        const key_val = el.split(':');
+        customLogLevels[key_val[0].trim()] = key_val[1].trim();
+    }
+    pinoOptions.formatters = {
+        level(label, number) {
+            return {
+                severity: customLogLevels[label] || 'info',
+                level: number,
+            };
+        },
+    };
+    httpLoggerOptions.formatters = {
+        level(label, number) {
+            return {
+                severity: customLogLevels[label] || 'info',
+                level: number,
+            };
+        },
+    };
+    delete loggerEnvConfig['levels'];
+}
+const logger = pino(merge(pinoOptions, loggerEnvConfig));
+const httpLoggerEnvConfig = getConfigFromEnv('LOGGER_HTTP', ['LOGGER_HTTP_LOGGER']);
+export const expressLogger = pinoHttp({
+    logger: pino(merge(httpLoggerOptions, loggerEnvConfig)),
+    ...httpLoggerEnvConfig,
+    serializers: {
+        req(request) {
+            const output = stdSerializers.req(request);
+            output.url = redactQuery(output.url);
+            return output;
+        },
+    },
+});
+export default logger;
+function redactQuery(originalPath) {
+    const url = new URL(originalPath, 'http://example.com/');
+    if (url.searchParams.has('access_token')) {
+        url.searchParams.set('access_token', REDACT_TEXT);
+    }
+    return url.pathname + url.search;
+}

package/dist/logger.test.d.ts

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

package/dist/mailer.d.ts

@@ -0,0 +1,2 @@
+import { Transporter } from 'nodemailer';
+export default function getMailer(): Transporter;

package/dist/mailer.js

@@ -0,0 +1,67 @@
+import nodemailer from 'nodemailer';
+import env from './env.js';
+import logger from './logger.js';
+import { getConfigFromEnv } from './utils/get-config-from-env.js';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+let transporter;
+export default function getMailer() {
+    if (transporter)
+        return transporter;
+    const transportName = env['EMAIL_TRANSPORT'].toLowerCase();
+    if (transportName === 'sendmail') {
+        transporter = nodemailer.createTransport({
+            sendmail: true,
+            newline: env['EMAIL_SENDMAIL_NEW_LINE'] || 'unix',
+            path: env['EMAIL_SENDMAIL_PATH'] || '/usr/sbin/sendmail',
+        });
+    }
+    else if (transportName === 'ses') {
+        const aws = require('@aws-sdk/client-ses');
+        const sesOptions = getConfigFromEnv('EMAIL_SES_');
+        const ses = new aws.SES(sesOptions);
+        transporter = nodemailer.createTransport({
+            SES: { ses, aws },
+        });
+    }
+    else if (transportName === 'smtp') {
+        let auth = false;
+        if (env['EMAIL_SMTP_USER'] || env['EMAIL_SMTP_PASSWORD']) {
+            auth = {
+                user: env['EMAIL_SMTP_USER'],
+                pass: env['EMAIL_SMTP_PASSWORD'],
+            };
+        }
+        const tls = getConfigFromEnv('EMAIL_SMTP_TLS_');
+        transporter = nodemailer.createTransport({
+            name: env['EMAIL_SMTP_NAME'],
+            pool: env['EMAIL_SMTP_POOL'],
+            host: env['EMAIL_SMTP_HOST'],
+            port: env['EMAIL_SMTP_PORT'],
+            secure: env['EMAIL_SMTP_SECURE'],
+            ignoreTLS: env['EMAIL_SMTP_IGNORE_TLS'],
+            auth,
+            tls,
+        });
+    }
+    else if (transportName === 'mailgun') {
+        const mg = require('nodemailer-mailgun-transport');
+        transporter = nodemailer.createTransport(mg({
+            auth: {
+                api_key: env['EMAIL_MAILGUN_API_KEY'],
+                domain: env['EMAIL_MAILGUN_DOMAIN'],
+            },
+            host: env['EMAIL_MAILGUN_HOST'] || 'api.mailgun.net',
+        }));
+    }
+    else if (transportName === 'sendgrid') {
+        const sg = require('nodemailer-sendgrid');
+        transporter = nodemailer.createTransport(sg({
+            apiKey: env['EMAIL_SENDGRID_API_KEY'],
+        }));
+    }
+    else {
+        logger.warn('Illegal transport given for email. Check the EMAIL_TRANSPORT env var.');
+    }
+    return transporter;
+}

package/dist/messenger.d.ts

@@ -0,0 +1,24 @@
+import { Redis } from 'ioredis';
+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;
+    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: Redis;
+    sub: 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,57 @@
+import { parseJSON } from '@directus/utils';
+import { Redis } from 'ioredis';
+import env from './env.js';
+import { getConfigFromEnv } from './utils/get-config-from-env.js';
+export class MessengerMemory {
+    handlers;
+    constructor() {
+        this.handlers = {};
+    }
+    publish(channel, payload) {
+        this.handlers[channel]?.(payload);
+    }
+    subscribe(channel, callback) {
+        this.handlers[channel] = callback;
+    }
+    unsubscribe(channel) {
+        delete this.handlers[channel];
+    }
+}
+export class MessengerRedis {
+    namespace;
+    pub;
+    sub;
+    constructor() {
+        const config = getConfigFromEnv('MESSENGER_REDIS');
+        this.pub = new Redis(env['MESSENGER_REDIS'] ?? config);
+        this.sub = new Redis(env['MESSENGER_REDIS'] ?? config);
+        this.namespace = env['MESSENGER_NAMESPACE'] ?? '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 = parseJSON(payloadString);
+            if (messageChannel === `${this.namespace}:${channel}`) {
+                callback(payload);
+            }
+        });
+    }
+    unsubscribe(channel) {
+        this.sub.unsubscribe(`${this.namespace}:${channel}`);
+    }
+}
+let messenger;
+export function getMessenger() {
+    if (messenger)
+        return messenger;
+    if (env['MESSENGER_STORE'] === 'redis') {
+        messenger = new MessengerRedis();
+    }
+    else {
+        messenger = new MessengerMemory();
+    }
+    return messenger;
+}

package/dist/middleware/authenticate.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="qs" />
+import type { NextFunction, Request, Response } from 'express';
+/**
+ * Verify the passed JWT and assign the user ID and role to `req`
+ */
+export declare const handler: (req: Request, _res: Response, next: NextFunction) => Promise<void>;
+declare const _default: (req: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: NextFunction) => Promise<void>;
+export default _default;