@directus/api 22.1.0 → 22.2.0

package/dist/database/helpers/schema/utils/preprocess-bindings.js

@@ -1,30 +1,36 @@
 import { isString } from 'lodash-es';
+/**
+ * Preprocess a SQL query, such that repeated binding values are bound to the same binding index.
+ **/
 export function preprocessBindings(queryParams, options) {
     const query = { bindings: [], ...(isString(queryParams) ? { sql: queryParams } : queryParams) };
-    const bindingIndices = new Array(query.bindings.length);
-    for (let i = 0; i < query.bindings.length; i++) {
-        const binding = query.bindings[i];
-        const prevIndex = query.bindings.findIndex((b, j) => j < i && b === binding);
-        if (prevIndex !== -1) {
-            bindingIndices[i] = prevIndex;
-        }
-        else {
-            bindingIndices[i] = i;
-        }
-    }
+    // bindingIndices[i] is the index of the first occurrence of query.bindings[i]
+    const bindingIndices = new Map();
+    // The new, deduplicated bindings
+    const bindings = [];
     let matchIndex = 0;
-    let currentBindingIndex = 0;
-    const sql = query.sql.replace(/(\\*)(\?)/g, function (_, escapes) {
+    let nextBindingIndex = 0;
+    const sql = query.sql.replace(/(\\*)(\?)/g, (_, escapes) => {
         if (escapes.length % 2) {
             // Return an escaped question mark, so it stays escaped
             return `${'\\'.repeat(escapes.length)}?`;
         }
+        const binding = query.bindings[matchIndex];
+        let bindingIndex;
+        if (bindingIndices.has(binding)) {
+            // This index belongs to a binding that has been encountered before.
+            bindingIndex = bindingIndices.get(binding);
+        }
         else {
-            const bindingIndex = bindingIndices[matchIndex] === matchIndex ? currentBindingIndex++ : bindingIndices[matchIndex];
-            matchIndex++;
-            return options.format(bindingIndex);
+            // The first time the value is encountered, set the index lookup to the current index
+            // Use the nextBindingIndex to get the next unused binding index that is used in the new, deduplicated bindings
+            bindingIndex = nextBindingIndex++;
+            bindingIndices.set(binding, bindingIndex);
+            bindings.push(binding);
         }
+        // Increment the loop counter
+        matchIndex++;
+        return options.format(bindingIndex);
     });
-    const bindings = query.bindings.filter((_, i) => bindingIndices[i] === i);
     return { ...query, sql, bindings };
 }

package/dist/database/index.d.ts

@@ -3,7 +3,7 @@ import type { Knex } from 'knex';
 import type { DatabaseClient } from '../types/index.js';
 export default getDatabase;
 export declare function getDatabase(): Knex;
-export declare function getSchemaInspector(): SchemaInspector;
+export declare function getSchemaInspector(database?: Knex): SchemaInspector;
 /**
  * Get database version. Value currently exists for MySQL only.
  *

package/dist/database/index.js

@@ -143,11 +143,11 @@ export function getDatabase() {
     });
     return database;
 }
-export function getSchemaInspector() {
+export function getSchemaInspector(database) {
     if (inspector) {
         return inspector;
     }
-    const database = getDatabase();
+    database ??= getDatabase();
     inspector = createInspector(database);
     return inspector;
 }

package/dist/database/migrations/20240806A-permissions-policies.js

@@ -186,10 +186,10 @@ export async function up(knex) {
     /////////////////////////////////////////////////////////////////////////////////////////////////
     // Link permissions to policies instead of roles
     await knex.schema.alterTable('directus_permissions', (table) => {
-        table.uuid('policy').references('directus_policies.id').onDelete('CASCADE');
+        table.uuid('policy');
     });
     try {
-        const inspector = await getSchemaInspector();
+        const inspector = await getSchemaInspector(knex);
         const foreignKeys = await inspector.foreignKeys('directus_permissions');
         const foreignConstraint = foreignKeys.find((foreign) => foreign.foreign_key_table === 'directus_roles' && foreign.column === 'role')
             ?.constraint_name || undefined;
@@ -212,6 +212,7 @@ export async function up(knex) {
     await knex.schema.alterTable('directus_permissions', (table) => {
         table.dropColumns('role');
         table.dropNullable('policy');
+        table.foreign('policy').references('directus_policies.id').onDelete('CASCADE');
     });
     /////////////////////////////////////////////////////////////////////////////////////////////////
     // Setup junction table between roles/users and policies

package/dist/database/migrations/20240817A-update-icon-fields-length.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20240817A-update-icon-fields-length.js

@@ -0,0 +1,55 @@
+import { getHelpers } from '../helpers/index.js';
+export async function up(knex) {
+    const helper = getHelpers(knex).schema;
+    await helper.changeToType('directus_collections', 'icon', 'string', {
+        length: 64,
+    });
+    await helper.changeToType('directus_dashboards', 'icon', 'string', {
+        nullable: false,
+        default: 'dashboard',
+        length: 64,
+    });
+    await helper.changeToType('directus_flows', 'icon', 'string', {
+        length: 64,
+    });
+    await helper.changeToType('directus_panels', 'icon', 'string', {
+        default: null,
+        length: 64,
+    });
+    await helper.changeToType('directus_presets', 'icon', 'string', {
+        default: 'bookmark',
+        length: 64,
+    });
+    await helper.changeToType('directus_roles', 'icon', 'string', {
+        nullable: false,
+        default: 'supervised_user_circle',
+        length: 64,
+    });
+}
+export async function down(knex) {
+    const helper = getHelpers(knex).schema;
+    await helper.changeToType('directus_collections', 'icon', 'string', {
+        length: 30,
+    });
+    await helper.changeToType('directus_dashboards', 'icon', 'string', {
+        nullable: false,
+        default: 'dashboard',
+        length: 30,
+    });
+    await helper.changeToType('directus_flows', 'icon', 'string', {
+        length: 30,
+    });
+    await helper.changeToType('directus_panels', 'icon', 'string', {
+        default: null,
+        length: 30,
+    });
+    await helper.changeToType('directus_presets', 'icon', 'string', {
+        default: 'bookmark',
+        length: 30,
+    });
+    await helper.changeToType('directus_roles', 'icon', 'string', {
+        nullable: false,
+        default: 'supervised_user_circle',
+        length: 30,
+    });
+}

package/dist/database/run-ast/lib/get-db-query.d.ts

@@ -1,4 +1,4 @@
-import type { Filter, Query, SchemaOverview } from '@directus/types';
+import type { Filter, Permission, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { FieldNode, FunctionFieldNode, O2MNode } from '../../../types/ast.js';
-export declare function getDBQuery(schema: SchemaOverview, knex: Knex, table: string, fieldNodes: (FieldNode | FunctionFieldNode)[], o2mNodes: O2MNode[], query: Query, cases: Filter[]): Knex.QueryBuilder;
+export declare function getDBQuery(schema: SchemaOverview, knex: Knex, table: string, fieldNodes: (FieldNode | FunctionFieldNode)[], o2mNodes: O2MNode[], query: Query, cases: Filter[], permissions: Permission[]): Knex.QueryBuilder;

package/dist/database/run-ast/lib/get-db-query.js

@@ -9,10 +9,10 @@ import { getColumnPreprocessor } from '../utils/get-column-pre-processor.js';
 import { getNodeAlias } from '../utils/get-field-alias.js';
 import { getInnerQueryColumnPreProcessor } from '../utils/get-inner-query-column-pre-processor.js';
 import { withPreprocessBindings } from '../utils/with-preprocess-bindings.js';
-export function getDBQuery(schema, knex, table, fieldNodes, o2mNodes, query, cases) {
+export function getDBQuery(schema, knex, table, fieldNodes, o2mNodes, query, cases, permissions) {
     const aliasMap = Object.create(null);
     const env = useEnv();
-    const preProcess = getColumnPreprocessor(knex, schema, table, cases, aliasMap);
+    const preProcess = getColumnPreprocessor(knex, schema, table, cases, permissions, aliasMap);
     const queryCopy = cloneDeep(query);
     const helpers = getHelpers(knex);
     const hasCaseWhen = o2mNodes.some((node) => node.whenCase && node.whenCase.length > 0) ||
@@ -25,7 +25,10 @@ export function getDBQuery(schema, knex, table, fieldNodes, o2mNodes, query, cas
         const groupWhenCases = hasCaseWhen
             ? queryCopy.group?.map((field) => fieldNodes.find(({ fieldKey }) => fieldKey === field)?.whenCase ?? [])
             : undefined;
-        const dbQuery = applyQuery(knex, table, flatQuery, queryCopy, schema, cases, { aliasMap, groupWhenCases }).query;
+        const dbQuery = applyQuery(knex, table, flatQuery, queryCopy, schema, cases, permissions, {
+            aliasMap,
+            groupWhenCases,
+        }).query;
         flatQuery.select(fieldNodes.map((node) => preProcess(node)));
         withPreprocessBindings(knex, dbQuery);
         return dbQuery;
@@ -42,7 +45,7 @@ export function getDBQuery(schema, knex, table, fieldNodes, o2mNodes, query, cas
             hasMultiRelationalSort = sortResult.hasMultiRelationalSort;
         }
     }
-    const { hasMultiRelationalFilter } = applyQuery(knex, table, dbQuery, queryCopy, schema, cases, {
+    const { hasMultiRelationalFilter } = applyQuery(knex, table, dbQuery, queryCopy, schema, cases, permissions, {
         aliasMap,
         isInnerQuery: true,
         hasMultiRelationalSort,
@@ -68,6 +71,7 @@ export function getDBQuery(schema, knex, table, fieldNodes, o2mNodes, query, cas
                 cases,
                 table,
                 alias: node.fieldKey,
+                permissions,
             }, { knex, schema });
         }));
     }
@@ -82,19 +86,21 @@ export function getDBQuery(schema, knex, table, fieldNodes, o2mNodes, query, cas
                     orderByString += ', ';
                 }
                 const sortAlias = `sort_${generateAlias()}`;
+                let orderByColumn;
                 if (sortRecord.column.includes('.')) {
                     const [alias, field] = sortRecord.column.split('.');
                     const originalCollectionName = getCollectionFromAlias(alias, aliasMap);
                     dbQuery.select(getColumn(knex, alias, field, sortAlias, schema, { originalCollectionName }));
                     orderByString += `?? ${sortRecord.order}`;
-                    orderByFields.push(getColumn(knex, alias, field, false, schema, { originalCollectionName }));
+                    orderByColumn = getColumn(knex, alias, field, false, schema, { originalCollectionName });
                 }
                 else {
                     dbQuery.select(getColumn(knex, table, sortRecord.column, sortAlias, schema));
                     orderByString += `?? ${sortRecord.order}`;
-                    orderByFields.push(getColumn(knex, table, sortRecord.column, false, schema));
+                    orderByColumn = getColumn(knex, table, sortRecord.column, false, schema);
                 }
-                innerQuerySortRecords.push({ alias: sortAlias, order: sortRecord.order });
+                orderByFields.push(orderByColumn);
+                innerQuerySortRecords.push({ alias: sortAlias, order: sortRecord.order, column: orderByColumn });
             });
             if (hasMultiRelationalSort) {
                 dbQuery = helpers.schema.applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields);
@@ -159,7 +165,7 @@ export function getDBQuery(schema, knex, table, fieldNodes, o2mNodes, query, cas
             SELECT ...,
               CASE WHEN `inner`.<random-prefix>_<alias> > 0 THEN <actual-column> END AS <alias>
          */
-        const innerPreprocess = getInnerQueryColumnPreProcessor(knex, schema, table, cases, aliasMap, innerCaseWhenAliasPrefix);
+        const innerPreprocess = getInnerQueryColumnPreProcessor(knex, schema, table, cases, permissions, aliasMap, innerCaseWhenAliasPrefix);
         // To optimize the query we avoid having unnecessary columns in the inner query, that don't have a caseWhen, since
         // they are selected in the outer query directly
         dbQuery.select(fieldNodes.map(innerPreprocess).filter((x) => x !== null));
@@ -167,11 +173,15 @@ export function getDBQuery(schema, knex, table, fieldNodes, o2mNodes, query, cas
         // based on the case/when of that field.
         dbQuery.select(o2mNodes.map(innerPreprocess).filter((x) => x !== null));
         const groupByFields = [knex.raw('??.??', [table, primaryKey])];
-        if (hasMultiRelationalSort) {
-            // Sort fields that are not directly in the table the primary key is from need to be included in the group
-            // by clause, otherwise this causes problems on some DBs
-            groupByFields.push(...innerQuerySortRecords.map(({ alias }) => knex.raw('??', alias)));
-        }
+        // For some DB vendors sort fields need to be included in the group by clause, otherwise this causes problems those DBs
+        // since sort fields are selected in the inner query, and they expect all selected columns to be in
+        // the group by clause or aggregated over.
+        // For some DBs the field needs to be the actual raw column expression, since aliases are not available in the
+        // group by clause.
+        // Since the fields are expected to be the same for a single primary key it is safe to include them in the
+        // group by without influencing the result.
+        // This inclusion depends on the DB vendor, as such it is handled in a dialect specific helper.
+        helpers.schema.addInnerSortFieldsToGroupBy(groupByFields, innerQuerySortRecords, hasMultiRelationalSort ?? false);
         dbQuery.groupBy(groupByFields);
     }
     const wrapperQuery = knex

package/dist/database/run-ast/run-ast.d.ts

@@ -1,7 +1,7 @@
-import type { Item, SchemaOverview } from '@directus/types';
+import type { Accountability, Item, SchemaOverview } from '@directus/types';
 import type { AST, NestedCollectionNode } from '../../types/ast.js';
 import type { RunASTOptions } from './types.js';
 /**
  * Execute a given AST using Knex. Returns array of items based on requested AST.
  */
-export declare function runAst(originalAST: AST | NestedCollectionNode, schema: SchemaOverview, options?: RunASTOptions): Promise<null | Item | Item[]>;
+export declare function runAst(originalAST: AST | NestedCollectionNode, schema: SchemaOverview, accountability: Accountability | null, options?: RunASTOptions): Promise<null | Item | Item[]>;

package/dist/database/run-ast/run-ast.js

@@ -1,5 +1,7 @@
 import { useEnv } from '@directus/env';
 import { cloneDeep, merge } from 'lodash-es';
+import { fetchPermissions } from '../../permissions/lib/fetch-permissions.js';
+import { fetchPolicies } from '../../permissions/lib/fetch-policies.js';
 import { PayloadService } from '../../services/payload.js';
 import getDatabase from '../index.js';
 import { getDBQuery } from './lib/get-db-query.js';
@@ -10,26 +12,31 @@ import { removeTemporaryFields } from './utils/remove-temporary-fields.js';
 /**
  * Execute a given AST using Knex. Returns array of items based on requested AST.
  */
-export async function runAst(originalAST, schema, options) {
+export async function runAst(originalAST, schema, accountability, options) {
     const ast = cloneDeep(originalAST);
     const knex = options?.knex || getDatabase();
     if (ast.type === 'a2o') {
         const results = {};
         for (const collection of ast.names) {
-            results[collection] = await run(collection, ast.children[collection], ast.query[collection], ast.cases[collection] ?? []);
+            results[collection] = await run(collection, ast.children[collection], ast.query[collection], ast.cases[collection] ?? [], accountability);
         }
         return results;
     }
     else {
-        return await run(ast.name, ast.children, options?.query || ast.query, ast.cases);
+        return await run(ast.name, ast.children, options?.query || ast.query, ast.cases, accountability);
     }
-    async function run(collection, children, query, cases) {
+    async function run(collection, children, query, cases, accountability) {
         const env = useEnv();
         // Retrieve the database columns to select in the current AST
         const { fieldNodes, primaryKeyField, nestedCollectionNodes } = await parseCurrentLevel(schema, collection, children, query);
         const o2mNodes = nestedCollectionNodes.filter((node) => node.type === 'o2m');
+        let permissions = [];
+        if (accountability && !accountability.admin) {
+            const policies = await fetchPolicies(accountability, { schema, knex });
+            permissions = await fetchPermissions({ action: 'read', accountability, policies }, { schema, knex });
+        }
         // The actual knex query builder instance. This is a promise that resolves with the raw items from the db
-        const dbQuery = getDBQuery(schema, knex, collection, fieldNodes, o2mNodes, query, cases);
+        const dbQuery = getDBQuery(schema, knex, collection, fieldNodes, o2mNodes, query, cases, permissions);
         const rawItems = await dbQuery;
         if (!rawItems)
             return null;
@@ -72,7 +79,7 @@ export async function runAst(originalAST, schema, options) {
                             page: null,
                         },
                     });
-                    nestedItems = (await runAst(node, schema, { knex, nested: true }));
+                    nestedItems = (await runAst(node, schema, accountability, { knex, nested: true }));
                     if (nestedItems) {
                         items = mergeWithParentItems(schema, nestedItems, items, nestedNode, fieldAllowed);
                     }
@@ -86,7 +93,7 @@ export async function runAst(originalAST, schema, options) {
                 const node = merge({}, nestedNode, {
                     query: { limit: -1 },
                 });
-                nestedItems = (await runAst(node, schema, { knex, nested: true }));
+                nestedItems = (await runAst(node, schema, accountability, { knex, nested: true }));
                 if (nestedItems) {
                     // Merge all fetched nested records with the parent items
                     items = mergeWithParentItems(schema, nestedItems, items, nestedNode, true);

package/dist/database/run-ast/utils/apply-case-when.d.ts

@@ -1,4 +1,4 @@
-import type { Filter, SchemaOverview } from '@directus/types';
+import type { Filter, Permission, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { AliasMap } from '../../../utils/get-column-path.js';
 export interface ApplyCaseWhenOptions {
@@ -8,9 +8,10 @@ export interface ApplyCaseWhenOptions {
     cases: Filter[];
     aliasMap: AliasMap;
     alias?: string;
+    permissions: Permission[];
 }
 export interface ApplyCaseWhenContext {
     knex: Knex;
     schema: SchemaOverview;
 }
-export declare function applyCaseWhen({ columnCases, table, aliasMap, cases, column, alias }: ApplyCaseWhenOptions, { knex, schema }: ApplyCaseWhenContext): Knex.Raw;
+export declare function applyCaseWhen({ columnCases, table, aliasMap, cases, column, alias, permissions }: ApplyCaseWhenOptions, { knex, schema }: ApplyCaseWhenContext): Knex.Raw;

package/dist/database/run-ast/utils/apply-case-when.js

@@ -1,7 +1,7 @@
 import { applyFilter } from '../../../utils/apply-query.js';
-export function applyCaseWhen({ columnCases, table, aliasMap, cases, column, alias }, { knex, schema }) {
+export function applyCaseWhen({ columnCases, table, aliasMap, cases, column, alias, permissions }, { knex, schema }) {
     const caseQuery = knex.queryBuilder();
-    applyFilter(knex, schema, caseQuery, { _or: columnCases }, table, aliasMap, cases);
+    applyFilter(knex, schema, caseQuery, { _or: columnCases }, table, aliasMap, cases, permissions);
     const compiler = knex.client.queryCompiler(caseQuery);
     const sqlParts = [];
     // Only empty filters, so no where was generated, skip it

package/dist/database/run-ast/utils/get-column-pre-processor.d.ts

@@ -1,4 +1,4 @@
-import type { Filter, SchemaOverview } from '@directus/types';
+import type { Filter, Permission, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { FieldNode, FunctionFieldNode, M2ONode } from '../../../types/ast.js';
 import type { AliasMap } from '../../../utils/get-column-path.js';
@@ -6,5 +6,5 @@ interface NodePreProcessOptions {
     /** Don't assign an alias to the column but instead return the column as is */
     noAlias?: boolean;
 }
-export declare function getColumnPreprocessor(knex: Knex, schema: SchemaOverview, table: string, cases: Filter[], aliasMap: AliasMap): (fieldNode: FieldNode | FunctionFieldNode | M2ONode, options?: NodePreProcessOptions) => Knex.Raw<string>;
+export declare function getColumnPreprocessor(knex: Knex, schema: SchemaOverview, table: string, cases: Filter[], permissions: Permission[], aliasMap: AliasMap): (fieldNode: FieldNode | FunctionFieldNode | M2ONode, options?: NodePreProcessOptions) => Knex.Raw<string>;
 export {};

package/dist/database/run-ast/utils/get-column-pre-processor.js

@@ -4,7 +4,7 @@ import { parseFilterKey } from '../../../utils/parse-filter-key.js';
 import { getHelpers } from '../../helpers/index.js';
 import { applyCaseWhen } from './apply-case-when.js';
 import { getNodeAlias } from './get-field-alias.js';
-export function getColumnPreprocessor(knex, schema, table, cases, aliasMap) {
+export function getColumnPreprocessor(knex, schema, table, cases, permissions, aliasMap) {
     const helpers = getHelpers(knex);
     return function (fieldNode, options) {
         // Don't assign an alias to the column expression if the field has a whenCase
@@ -32,6 +32,7 @@ export function getColumnPreprocessor(knex, schema, table, cases, aliasMap) {
                     ...fieldNode.query,
                     filter: joinFilterWithCases(fieldNode.query.filter, fieldNode.cases),
                 },
+                permissions,
                 cases: fieldNode.cases,
             });
         }
@@ -50,6 +51,7 @@ export function getColumnPreprocessor(knex, schema, table, cases, aliasMap) {
                 cases,
                 table,
                 alias,
+                permissions,
             }, { knex, schema });
         }
         return column;

package/dist/database/run-ast/utils/get-inner-query-column-pre-processor.d.ts

@@ -1,5 +1,5 @@
-import type { Filter, SchemaOverview } from '@directus/types';
+import type { Filter, Permission, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { FieldNode, FunctionFieldNode, M2ONode, O2MNode } from '../../../types/index.js';
 import type { AliasMap } from '../../../utils/get-column-path.js';
-export declare function getInnerQueryColumnPreProcessor(knex: Knex, schema: SchemaOverview, table: string, cases: Filter[], aliasMap: AliasMap, aliasPrefix: string): (fieldNode: FieldNode | FunctionFieldNode | M2ONode | O2MNode) => Knex.Raw<string> | null;
+export declare function getInnerQueryColumnPreProcessor(knex: Knex, schema: SchemaOverview, table: string, cases: Filter[], permissions: Permission[], aliasMap: AliasMap, aliasPrefix: string): (fieldNode: FieldNode | FunctionFieldNode | M2ONode | O2MNode) => Knex.Raw<string> | null;

package/dist/database/run-ast/utils/get-inner-query-column-pre-processor.js

@@ -1,6 +1,6 @@
 import { applyCaseWhen } from './apply-case-when.js';
 import { getNodeAlias } from './get-field-alias.js';
-export function getInnerQueryColumnPreProcessor(knex, schema, table, cases, aliasMap, aliasPrefix) {
+export function getInnerQueryColumnPreProcessor(knex, schema, table, cases, permissions, aliasMap, aliasPrefix) {
     return function (fieldNode) {
         const alias = getNodeAlias(fieldNode);
         if (fieldNode.whenCase && fieldNode.whenCase.length > 0) {
@@ -15,6 +15,7 @@ export function getInnerQueryColumnPreProcessor(knex, schema, table, cases, alia
                 aliasMap,
                 cases,
                 table,
+                permissions,
             }, { knex, schema });
             return knex.raw('COUNT(??) AS ??', [caseWhen, `${aliasPrefix}_${alias}`]);
         }

package/dist/extensions/manager.js

@@ -156,7 +156,7 @@ export class ExtensionManager {
             }
         }
         if (this.options.watch && !wasWatcherInitialized) {
-            this.updateWatchedExtensions(Array.from(this.localExtensions.values()));
+            this.updateWatchedExtensions([...this.extensions]);
         }
         this.messenger.subscribe(this.reloadChannel, (payload) => {
             // Ignore requests for reloading that were published by the current process
@@ -327,7 +327,7 @@ export class ExtensionManager {
         const extensionDir = path.resolve(getExtensionsPath());
         const registryDir = path.join(extensionDir, '.registry');
         const toPackageExtensionPaths = (extensions) => extensions
-            .filter((extension) => extension.local && extension.path.startsWith(extensionDir) && !extension.path.startsWith(registryDir))
+            .filter((extension) => extension.local && !extension.path.startsWith(registryDir))
             .flatMap((extension) => isTypeIn(extension, HYBRID_EXTENSION_TYPES) || extension.type === 'bundle'
             ? [
                 path.resolve(extension.path, extension.entrypoint.app),

package/dist/logger/index.d.ts

@@ -1,9 +1,15 @@
 /// <reference types="qs" />
 import type { RequestHandler } from 'express';
 import { type Logger } from 'pino';
+import { LogsStream } from './logs-stream.js';
 export declare const _cache: {
     logger: Logger<never> | undefined;
+    logsStream: LogsStream | undefined;
+    httpLogsStream: LogsStream | undefined;
 };
 export declare const useLogger: () => Logger<never>;
+export declare const getLogsStream: (pretty: boolean) => LogsStream;
+export declare const getHttpLogsStream: (pretty: boolean) => LogsStream;
+export declare const getLoggerLevelValue: (level: string) => number;
 export declare const createLogger: () => Logger<never>;
 export declare const createExpressLogger: () => RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;

package/dist/logger/index.js

@@ -1,12 +1,15 @@
 import { useEnv } from '@directus/env';
-import { REDACTED_TEXT, toArray } from '@directus/utils';
+import { REDACTED_TEXT, toArray, toBoolean } from '@directus/utils';
 import { merge } from 'lodash-es';
 import { URL } from 'node:url';
 import { pino } from 'pino';
 import { pinoHttp, stdSerializers } from 'pino-http';
+import { httpPrintFactory } from 'pino-http-print';
+import { build as pinoPretty } from 'pino-pretty';
 import { getConfigFromEnv } from '../utils/get-config-from-env.js';
+import { LogsStream } from './logs-stream.js';
 import { redactQuery } from './redact-query.js';
-export const _cache = { logger: undefined };
+export const _cache = { logger: undefined, logsStream: undefined, httpLogsStream: undefined };
 export const useLogger = () => {
     if (_cache.logger) {
         return _cache.logger;
@@ -14,6 +17,23 @@ export const useLogger = () => {
     _cache.logger = createLogger();
     return _cache.logger;
 };
+export const getLogsStream = (pretty) => {
+    if (_cache.logsStream) {
+        return _cache.logsStream;
+    }
+    _cache.logsStream = new LogsStream(pretty ? 'basic' : false);
+    return _cache.logsStream;
+};
+export const getHttpLogsStream = (pretty) => {
+    if (_cache.httpLogsStream) {
+        return _cache.httpLogsStream;
+    }
+    _cache.httpLogsStream = new LogsStream(pretty ? 'http' : false);
+    return _cache.httpLogsStream;
+};
+export const getLoggerLevelValue = (level) => {
+    return pino.levels.values[level] || pino.levels.values['info'];
+};
 export const createLogger = () => {
     const env = useEnv();
     const pinoOptions = {
@@ -23,15 +43,6 @@ export const createLogger = () => {
             censor: REDACTED_TEXT,
         },
     };
-    if (env['LOG_STYLE'] !== 'raw') {
-        pinoOptions.transport = {
-            target: 'pino-pretty',
-            options: {
-                ignore: 'hostname,pid',
-                sync: true,
-            },
-        };
-    }
     const loggerEnvConfig = getConfigFromEnv('LOGGER_', 'LOGGER_HTTP');
     // Expose custom log levels into formatter function
     if (loggerEnvConfig['levels']) {
@@ -50,7 +61,33 @@ export const createLogger = () => {
         };
         delete loggerEnvConfig['levels'];
     }
-    return pino(merge(pinoOptions, loggerEnvConfig));
+    const mergedOptions = merge(pinoOptions, loggerEnvConfig);
+    const streams = [];
+    // Console Logs
+    if (env['LOG_STYLE'] !== 'raw') {
+        streams.push({
+            level: mergedOptions.level,
+            stream: pinoPretty({
+                ignore: 'hostname,pid',
+                sync: true,
+            }),
+        });
+    }
+    else {
+        streams.push({ level: mergedOptions.level, stream: process.stdout });
+    }
+    // WebSocket Logs
+    if (toBoolean(env['WEBSOCKETS_LOGS_ENABLED'])) {
+        const wsLevel = env['WEBSOCKETS_LOGS_LEVEL'] || 'info';
+        if (getLoggerLevelValue(wsLevel) < getLoggerLevelValue(mergedOptions.level)) {
+            mergedOptions.level = wsLevel;
+        }
+        streams.push({
+            level: wsLevel,
+            stream: getLogsStream(env['WEBSOCKETS_LOGS_STYLE'] !== 'raw'),
+        });
+    }
+    return pino(mergedOptions, pino.multistream(streams));
 };
 export const createExpressLogger = () => {
     const env = useEnv();
@@ -63,21 +100,7 @@ export const createExpressLogger = () => {
             censor: REDACTED_TEXT,
         },
     };
-    if (env['LOG_STYLE'] !== 'raw') {
-        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') {
+    if (env['LOG_STYLE'] === 'raw' || toBoolean(env['WEBSOCKETS_LOGS_ENABLED'])) {
         httpLoggerOptions.redact = {
             paths: ['req.headers.authorization', 'req.headers.cookie', 'res.headers', 'req.query.access_token'],
             censor: (value, pathParts) => {
@@ -120,8 +143,36 @@ export const createExpressLogger = () => {
             },
         };
     }
+    const mergedHttpOptions = merge(httpLoggerOptions, loggerEnvConfig);
+    const streams = [];
+    if (env['LOG_STYLE'] !== 'raw') {
+        const pinoHttpPretty = httpPrintFactory({
+            all: true,
+            translateTime: 'SYS:HH:MM:ss',
+            relativeUrl: true,
+            prettyOptions: {
+                ignore: 'hostname,pid',
+                sync: true,
+            },
+        });
+        streams.push({ level: mergedHttpOptions.level, stream: pinoHttpPretty(process.stdout) });
+    }
+    else {
+        streams.push({ level: mergedHttpOptions.level, stream: process.stdout });
+    }
+    // WebSocket Logs
+    if (toBoolean(env['WEBSOCKETS_LOGS_ENABLED'])) {
+        const wsLevel = env['WEBSOCKETS_LOGS_LEVEL'] || 'info';
+        if (getLoggerLevelValue(wsLevel) < getLoggerLevelValue(mergedHttpOptions.level)) {
+            mergedHttpOptions.level = wsLevel;
+        }
+        streams.push({
+            level: wsLevel,
+            stream: getHttpLogsStream(env['WEBSOCKETS_LOGS_STYLE'] !== 'raw'),
+        });
+    }
     return pinoHttp({
-        logger: pino(merge(httpLoggerOptions, loggerEnvConfig)),
+        logger: pino(mergedHttpOptions, pino.multistream(streams)),
         ...httpLoggerEnvConfig,
         serializers: {
             req(request) {

package/dist/logger/logs-stream.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Bus } from '@directus/memory';
+import { Writable } from 'stream';
+type PrettyType = 'basic' | 'http' | false;
+export declare class LogsStream extends Writable {
+    messenger: Bus;
+    pretty: PrettyType;
+    constructor(pretty: PrettyType);
+    _write(chunk: string, _encoding: string, callback: (error?: Error | null) => void): void;
+}
+export {};