@directus/api 12.1.3 → 13.0.0

package/dist/cli/utils/create-env/env-stub.liquid

@@ -148,8 +148,8 @@ CACHE_ENABLED=false
 # How long the cache is persisted ["5m"]
 # CACHE_TTL="30m"
 
-# How to scope the cache data ["directus-cache"]
-# CACHE_NAMESPACE="directus-cache"
+# How to scope the cache data ["system-cache"]
+# CACHE_NAMESPACE="system-cache"
 
 # Automatically purge the cache on create, update, and delete actions. [false]
 # CACHE_AUTO_PURGE=true

package/dist/database/migrations/20230721A-require-shares-fields.js

@@ -1,12 +1,28 @@
 export async function up(knex) {
     await knex.schema.alterTable('directus_shares', (table) => {
+        if (knex.client.constructor.name === 'Client_MySQL') {
+            // Temporary drop foreign key constraint, see https://github.com/directus/directus/issues/19399
+            table.dropForeign('collection', 'directus_shares_collection_foreign');
+        }
         table.dropNullable('collection');
+        if (knex.client.constructor.name === 'Client_MySQL') {
+            // Recreate foreign key constraint, from 20211211A-add-shares.ts
+            table.foreign('collection').references('directus_collections.collection').onDelete('CASCADE');
+        }
         table.dropNullable('item');
     });
 }
 export async function down(knex) {
     await knex.schema.alterTable('directus_shares', (table) => {
+        if (knex.client.constructor.name === 'Client_MySQL') {
+            // Temporary drop foreign key constraint, see https://github.com/directus/directus/issues/19399
+            table.dropForeign('collection', 'directus_shares_collection_foreign');
+        }
         table.setNullable('collection');
+        if (knex.client.constructor.name === 'Client_MySQL') {
+            // Recreate foreign key constraint, from 20211211A-add-shares.ts
+            table.foreign('collection').references('directus_collections.collection').onDelete('CASCADE');
+        }
         table.setNullable('item');
     });
 }

package/dist/env.js

@@ -192,8 +192,9 @@ const allowedEnvironmentVars = [
     'RELATIONAL_BATCH_SIZE',
     'EXPORT_BATCH_SIZE',
     // flows
-    'FLOWS_EXEC_ALLOWED_MODULES',
     'FLOWS_ENV_ALLOW_LIST',
+    'FLOWS_RUN_SCRIPT_MAX_MEMORY',
+    'FLOWS_RUN_SCRIPT_TIMEOUT',
     // websockets
     'WEBSOCKETS_.+',
 ].map((name) => new RegExp(`^${name}$`));
@@ -282,8 +283,9 @@ const defaults = {
     WEBSOCKETS_GRAPHQL_PATH: '/graphql',
     WEBSOCKETS_HEARTBEAT_ENABLED: true,
     WEBSOCKETS_HEARTBEAT_PERIOD: 30,
-    FLOWS_EXEC_ALLOWED_MODULES: false,
     FLOWS_ENV_ALLOW_LIST: false,
+    FLOWS_RUN_SCRIPT_MAX_MEMORY: 32,
+    FLOWS_RUN_SCRIPT_TIMEOUT: 10000,
     PRESSURE_LIMITER_ENABLED: true,
     PRESSURE_LIMITER_SAMPLE_INTERVAL: 250,
     PRESSURE_LIMITER_MAX_EVENT_LOOP_UTILIZATION: 0.99,

package/dist/flows.d.ts

@@ -7,6 +7,7 @@ declare class FlowManager {
     private operationFlowHandlers;
     private webhookFlowHandlers;
     private reloadQueue;
+    private envs;
     constructor();
     initialize(): Promise<void>;
     reload(): Promise<void>;

package/dist/flows.js

@@ -1,5 +1,5 @@
-import { Action, REDACTED_TEXT } from '@directus/constants';
-import { applyOptionsData, isValidJSON, parseJSON, toArray } from '@directus/utils';
+import { Action } from '@directus/constants';
+import { applyOptionsData, getRedactedString, isValidJSON, parseJSON, toArray } from '@directus/utils';
 import { omit, pick } from 'lodash-es';
 import { get } from 'micromustache';
 import getDatabase from './database/index.js';
@@ -16,7 +16,7 @@ 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';
-import { redact } from './utils/redact.js';
+import { redactObject } from './utils/redact-object.js';
 import { sanitizeError } from './utils/sanitize-error.js';
 import { scheduleSynchronizedJob, validateCron } from './utils/schedule.js';
 let flowManager;
@@ -38,8 +38,10 @@ class FlowManager {
     operationFlowHandlers = {};
     webhookFlowHandlers = {};
     reloadQueue;
+    envs;
     constructor() {
         this.reloadQueue = new JobQueue();
+        this.envs = env['FLOWS_ENV_ALLOW_LIST'] ? pick(env, toArray(env['FLOWS_ENV_ALLOW_LIST'])) : {};
         const messenger = getMessenger();
         messenger.subscribe('flows', (event) => {
             if (event['type'] === 'reload') {
@@ -238,7 +240,7 @@ class FlowManager {
             [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']) : []),
+            [ENV_KEY]: this.envs,
         };
         let nextOperation = flow.operation;
         let lastOperationStatus = 'unknown';
@@ -276,14 +278,17 @@ class FlowManager {
                     collection: 'directus_flows',
                     item: flow.id,
                     data: {
-                        steps: steps,
-                        data: redact(omit(keyedData, '$accountability.permissions'), // Permissions is a ton of data, and is just a copy of what's in the directus_permissions table
-                        [
-                            ['**', 'headers', 'authorization'],
-                            ['**', 'headers', 'cookie'],
-                            ['**', 'query', 'access_token'],
-                            ['**', 'payload', 'password'],
-                        ], REDACTED_TEXT),
+                        steps: steps.map((step) => redactObject(step, { values: this.envs }, getRedactedString)),
+                        data: redactObject(omit(keyedData, '$accountability.permissions'), // Permissions is a ton of data, and is just a copy of what's in the directus_permissions table
+                        {
+                            keys: [
+                                ['**', 'headers', 'authorization'],
+                                ['**', 'headers', 'cookie'],
+                                ['**', 'query', 'access_token'],
+                                ['**', 'payload', 'password'],
+                            ],
+                            values: this.envs,
+                        }, getRedactedString),
                     },
                 });
             }

package/dist/logger.js

@@ -1,5 +1,4 @@
-import { REDACTED_TEXT } from '@directus/constants';
-import { toArray } from '@directus/utils';
+import { REDACTED_TEXT, toArray } from '@directus/utils';
 import { merge } from 'lodash-es';
 import { pino } from 'pino';
 import { pinoHttp, stdSerializers } from 'pino-http';

package/dist/operations/exec/index.js

@@ -1,38 +1,47 @@
-import { defineOperationApi, toArray } from '@directus/utils';
-import { isBuiltin } from 'node:module';
-import { NodeVM, VMScript } from 'vm2';
+import { defineOperationApi } from '@directus/utils';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const ivm = require('isolated-vm');
+/**
+ * A helper for making the logs prettier.
+ * The logger prints arrays with their indices but this looks "bad" when you have only one argument.
+ */
+function unpackArgs(args) {
+    return args.length === 1 ? args[0] : args;
+}
 export default defineOperationApi({
     id: 'exec',
-    handler: async ({ code }, { data, env }) => {
-        const allowedModules = env['FLOWS_EXEC_ALLOWED_MODULES'] ? toArray(env['FLOWS_EXEC_ALLOWED_MODULES']) : [];
-        const allowedModulesBuiltIn = [];
-        const allowedModulesExternal = [];
+    handler: async ({ code }, { data, env, logger }) => {
         const allowedEnv = data['$env'] ?? {};
-        const opts = {
-            eval: false,
-            wasm: false,
-            env: allowedEnv,
-        };
-        for (const module of allowedModules) {
-            if (isBuiltin(module)) {
-                allowedModulesBuiltIn.push(module);
-            }
-            else {
-                allowedModulesExternal.push(module);
-            }
-        }
-        if (allowedModules.length > 0) {
-            opts.require = {
-                builtin: allowedModulesBuiltIn,
-                external: {
-                    modules: allowedModulesExternal,
-                    transitive: false,
-                },
-            };
-        }
-        const vm = new NodeVM(opts);
-        const script = new VMScript(code).compile();
-        const fn = await vm.run(script);
-        return await fn(data);
+        const isolateSizeMb = env['FLOWS_RUN_SCRIPT_MAX_MEMORY'];
+        const scriptTimeoutMs = env['FLOWS_RUN_SCRIPT_TIMEOUT'];
+        const isolate = new ivm.Isolate({ memoryLimit: isolateSizeMb });
+        const context = isolate.createContextSync();
+        const jail = context.global;
+        jail.setSync('global', jail.derefInto());
+        jail.setSync('process', { env: allowedEnv }, { copy: true });
+        jail.setSync('module', { exports: null }, { copy: true });
+        jail.setSync('console', {
+            log: new ivm.Callback((...args) => logger.info(unpackArgs(args)), { sync: true }),
+            info: new ivm.Callback((...args) => logger.info(unpackArgs(args)), { sync: true }),
+            warn: new ivm.Callback((...args) => logger.warn(unpackArgs(args)), { sync: true }),
+            error: new ivm.Callback((...args) => logger.error(unpackArgs(args)), { sync: true }),
+            trace: new ivm.Callback((...args) => logger.trace(unpackArgs(args)), { sync: true }),
+            debug: new ivm.Callback((...args) => logger.debug(unpackArgs(args)), { sync: true }),
+        }, { copy: true });
+        // Run the operation once to define the module.exports function
+        await context.eval(code, { timeout: scriptTimeoutMs });
+        const inputData = new ivm.ExternalCopy({ data });
+        const resultRef = await context.evalClosure(`return module.exports($0.data)`, [inputData.copyInto()], {
+            result: { reference: true, promise: true },
+            timeout: scriptTimeoutMs,
+        });
+        const result = await resultRef.copy();
+        // Memory cleanup
+        resultRef.release();
+        inputData.release();
+        context.release();
+        isolate.dispose();
+        return result;
     },
 });

package/dist/operations/json-web-token/index.d.ts

@@ -0,0 +1,10 @@
+import jwt from 'jsonwebtoken';
+type Options = {
+    operation: string;
+    payload?: Record<string, any> | string;
+    token?: string;
+    secret?: jwt.Secret;
+    options?: any;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/json-web-token/index.js

@@ -0,0 +1,35 @@
+import { defineOperationApi, optionToObject, optionToString } from '@directus/utils';
+import jwt from 'jsonwebtoken';
+export default defineOperationApi({
+    id: 'json-web-token',
+    handler: async ({ operation, payload, token, secret, options }) => {
+        if (operation === 'sign') {
+            if (!payload)
+                throw new Error('Undefined JSON Web Token payload');
+            if (!secret)
+                throw new Error('Undefined JSON Web Token secret');
+            const payloadObject = optionToObject(payload);
+            const secretString = optionToString(secret);
+            const optionsObject = optionToObject(options);
+            return jwt.sign(payloadObject, secretString, optionsObject);
+        }
+        else if (operation === 'verify') {
+            if (!token)
+                throw new Error('Undefined JSON Web Token token');
+            if (!secret)
+                throw new Error('Undefined JSON Web Token secret');
+            const tokenString = optionToString(token);
+            const secretString = optionToString(secret);
+            const optionsObject = optionToObject(options);
+            return jwt.verify(tokenString, secretString, optionsObject);
+        }
+        else if (operation === 'decode') {
+            if (!token)
+                throw new Error('Undefined JSON Web Token token');
+            const tokenString = optionToString(token);
+            const optionsObject = optionToObject(options);
+            return jwt.decode(tokenString, optionsObject);
+        }
+        throw new Error('Undefined "Operation" for JSON Web Token');
+    },
+});

package/dist/operations/notification/index.js

@@ -24,8 +24,8 @@ export default defineOperationApi({
             knex: database,
         });
         const messageString = message ? optionToString(message) : null;
-        const collectionString = message ? optionToString(collection) : null;
-        const itemString = message ? optionToString(item) : null;
+        const collectionString = collection ? optionToString(collection) : null;
+        const itemString = item ? optionToString(item) : null;
         const payload = toArray(recipient).map((userId) => {
             return {
                 recipient: userId,

package/dist/services/fields.js

@@ -67,7 +67,7 @@ export class FieldsService {
         }
         const columns = (await this.schemaInspector.columnInfo(collection)).map((column) => ({
             ...column,
-            default_value: getDefaultValue(column),
+            default_value: getDefaultValue(column, fields.find((field) => field.collection === column.table && field.field === column.name)),
         }));
         const columnsWithSystem = columns.map((column) => {
             const field = fields.find((field) => {
@@ -184,7 +184,7 @@ export class FieldsService {
         const columnWithCastDefaultValue = column
             ? {
                 ...column,
-                default_value: getDefaultValue(column),
+                default_value: getDefaultValue(column, fieldInfo),
             }
             : null;
         const data = {

package/dist/services/graphql/index.js

@@ -1532,16 +1532,6 @@ export class GraphQLService {
                         }),
                     }
                     : GraphQLBoolean,
-                flows: {
-                    type: new GraphQLObjectType({
-                        name: 'server_info_flows',
-                        fields: {
-                            execAllowedModules: {
-                                type: new GraphQLList(GraphQLString),
-                            },
-                        },
-                    }),
-                },
                 websocket: toBoolean(env['WEBSOCKETS_ENABLED'])
                     ? {
                         type: new GraphQLObjectType({

package/dist/services/server.js

@@ -60,9 +60,6 @@ export class ServerService {
             else {
                 info['rateLimitGlobal'] = false;
             }
-            info['flows'] = {
-                execAllowedModules: env['FLOWS_EXEC_ALLOWED_MODULES'] ? toArray(env['FLOWS_EXEC_ALLOWED_MODULES']) : [],
-            };
             info['queryLimit'] = {
                 default: env['QUERY_LIMIT_DEFAULT'],
                 max: Number.isFinite(env['QUERY_LIMIT_MAX']) ? env['QUERY_LIMIT_MAX'] : -1,

package/dist/services/specifications.js

@@ -186,6 +186,7 @@ class OASSpecsService {
                                     },
                                 responses: {
                                     '200': {
+                                        description: 'Successful request',
                                         content: method === 'delete'
                                             ? undefined
                                             : {
@@ -376,7 +377,7 @@ class OASSpecsService {
                         {
                             type: 'string',
                         },
-                        relatedTags.map((tag) => ({
+                        ...relatedTags.map((tag) => ({
                             $ref: `#/components/schemas/${tag.name}`,
                         })),
                     ],

package/dist/utils/get-default-value.d.ts

@@ -1,3 +1,6 @@
 import type { SchemaOverview } from '@directus/schema/types/overview';
 import type { Column } from '@directus/schema';
-export default function getDefaultValue(column: SchemaOverview[string]['columns'][string] | Column): string | boolean | number | Record<string, any> | any[] | null;
+import type { FieldMeta } from '@directus/types';
+export default function getDefaultValue(column: SchemaOverview[string]['columns'][string] | Column, field?: {
+    special?: FieldMeta['special'];
+}): string | boolean | number | Record<string, any> | any[] | null;

package/dist/utils/get-default-value.js

@@ -2,8 +2,8 @@ import { parseJSON } from '@directus/utils';
 import env from '../env.js';
 import logger from '../logger.js';
 import getLocalType from './get-local-type.js';
-export default function getDefaultValue(column) {
-    const type = getLocalType(column);
+export default function getDefaultValue(column, field) {
+    const type = getLocalType(column, field);
     const defaultValue = column.default_value ?? null;
     if (defaultValue === null)
         return null;

package/dist/utils/redact-object.d.ts

@@ -0,0 +1,23 @@
+import type { UnknownObject } from '@directus/types';
+type Keys = string[][];
+type Values = Record<string, any>;
+type Replacement = (key?: string) => string;
+/**
+ * Redact values in an object.
+ *
+ * @param input Input object in which values should be redacted.
+ * @param redact The key paths at which and values itself which should be redacted.
+ * @param redact.keys Nested array of key paths at which values should be redacted. (Supports `*` for shallow matching, `**` for deep matching.)
+ * @param redact.values Value names and the corresponding values that should be redacted.
+ * @param replacement Replacement function with which the values are redacted.
+ * @returns Redacted object.
+ */
+export declare function redactObject(input: UnknownObject, redact: {
+    keys?: Keys;
+    values?: Values;
+}, replacement: Replacement): UnknownObject;
+/**
+ * Replace values and extract Error objects for use with JSON.stringify()
+ */
+export declare function getReplacer(replacement: Replacement, values?: Values): (_key: string, value: unknown) => unknown;
+export {};

package/dist/utils/{redact.js → redact-object.js}

@@ -1,26 +1,32 @@
 import { isObject } from '@directus/utils';
 /**
- * Redact values at certain paths in an object.
+ * Redact values in an object.
+ *
  * @param input Input object in which values should be redacted.
- * @param paths Nested array of object paths to be redacted (supports `*` for shallow matching, `**` for deep matching).
- * @param replacement Replacement the values are redacted by.
+ * @param redact The key paths at which and values itself which should be redacted.
+ * @param redact.keys Nested array of key paths at which values should be redacted. (Supports `*` for shallow matching, `**` for deep matching.)
+ * @param redact.values Value names and the corresponding values that should be redacted.
+ * @param replacement Replacement function with which the values are redacted.
  * @returns Redacted object.
  */
-export function redact(input, paths, replacement) {
+export function redactObject(input, redact, replacement) {
     const wildcardChars = ['*', '**'];
-    const clone = JSON.parse(JSON.stringify(input, errorReplacer));
+    const clone = JSON.parse(JSON.stringify(input, getReplacer(replacement, redact.values)));
     const visited = new WeakSet();
-    traverse(clone, paths);
+    if (redact.keys) {
+        traverse(clone, redact.keys);
+    }
     return clone;
-    function traverse(object, checkPaths) {
-        if (checkPaths.length === 0) {
+    function traverse(object, checkKeyPaths) {
+        if (checkKeyPaths.length === 0) {
             return;
         }
         visited.add(object);
+        const REDACTED_TEXT = replacement();
         const globalCheckPaths = [];
         for (const key of Object.keys(object)) {
             const localCheckPaths = [];
-            for (const [index, path] of [...checkPaths].entries()) {
+            for (const [index, path] of [...checkKeyPaths].entries()) {
                 const [current, ...remaining] = path;
                 const escapedKey = wildcardChars.includes(key) ? `\\${key}` : key;
                 switch (current) {
@@ -29,17 +35,17 @@ export function redact(input, paths, replacement) {
                             localCheckPaths.push(remaining);
                         }
                         else {
-                            object[key] = replacement;
-                            checkPaths.splice(index, 1);
+                            object[key] = REDACTED_TEXT;
+                            checkKeyPaths.splice(index, 1);
                         }
                         break;
                     case '*':
                         if (remaining.length > 0) {
                             globalCheckPaths.push(remaining);
-                            checkPaths.splice(index, 1);
+                            checkKeyPaths.splice(index, 1);
                         }
                         else {
-                            object[key] = replacement;
+                            object[key] = REDACTED_TEXT;
                         }
                         break;
                     case '**':
@@ -47,7 +53,7 @@ export function redact(input, paths, replacement) {
                             const [next, ...nextRemaining] = remaining;
                             if (next === escapedKey) {
                                 if (nextRemaining.length === 0) {
-                                    object[key] = replacement;
+                                    object[key] = REDACTED_TEXT;
                                 }
                                 else {
                                     localCheckPaths.push(nextRemaining);
@@ -61,7 +67,7 @@ export function redact(input, paths, replacement) {
                             }
                         }
                         else {
-                            object[key] = replacement;
+                            object[key] = REDACTED_TEXT;
                         }
                         break;
                 }
@@ -74,16 +80,29 @@ export function redact(input, paths, replacement) {
     }
 }
 /**
- * Extract values from Error objects for use with JSON.stringify()
+ * Replace values and extract Error objects for use with JSON.stringify()
  */
-export function errorReplacer(_key, value) {
-    if (value instanceof Error) {
-        return {
-            name: value.name,
-            message: value.message,
-            stack: value.stack,
-            cause: value.cause,
-        };
-    }
-    return value;
+export function getReplacer(replacement, values) {
+    const filteredValues = values
+        ? Object.entries(values).filter(([_k, v]) => typeof v === 'string' && v.length > 0)
+        : [];
+    return (_key, value) => {
+        if (value instanceof Error) {
+            return {
+                name: value.name,
+                message: value.message,
+                stack: value.stack,
+                cause: value.cause,
+            };
+        }
+        if (!values || filteredValues.length === 0 || typeof value !== 'string')
+            return value;
+        let finalValue = value;
+        for (const [redactKey, valueToRedact] of filteredValues) {
+            if (finalValue.includes(valueToRedact)) {
+                finalValue = finalValue.replace(new RegExp(valueToRedact, 'g'), replacement(redactKey));
+            }
+        }
+        return finalValue;
+    };
 }

package/dist/utils/sanitize-query.js

@@ -146,22 +146,26 @@ function sanitizeDeep(deep, accountability) {
     parse(deep);
     return result;
     function parse(level, path = []) {
+        const subQuery = {};
         const parsedLevel = {};
         for (const [key, value] of Object.entries(level)) {
             if (!key)
                 break;
             if (key.startsWith('_')) {
-                // Sanitize query only accepts non-underscore-prefixed query options
-                const parsedSubQuery = sanitizeQuery({ [key.substring(1)]: value }, accountability);
-                // ...however we want to keep them for the nested structure of deep, otherwise there's no
-                // way of knowing when to keep nesting and when to stop
-                const [parsedKey, parsedValue] = Object.entries(parsedSubQuery)[0];
-                parsedLevel[`_${parsedKey}`] = parsedValue;
+                // Collect all sub query parameters without the leading underscore
+                subQuery[key.substring(1)] = value;
             }
             else if (isPlainObject(value)) {
                 parse(value, [...path, key]);
             }
         }
+        if (Object.keys(subQuery).length > 0) {
+            // Sanitize the entire sub query
+            const parsedSubQuery = sanitizeQuery(subQuery, accountability);
+            for (const [parsedKey, parsedValue] of Object.entries(parsedSubQuery)) {
+                parsedLevel[`_${parsedKey}`] = parsedValue;
+            }
+        }
         if (Object.keys(parsedLevel).length > 0) {
             set(result, path, merge({}, get(result, path, {}), parsedLevel));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "12.1.3",
+  "version": "13.0.0",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content",
   "keywords": [
     "directus",
@@ -97,11 +97,12 @@
     "icc": "3.0.0",
     "inquirer": "9.2.4",
     "ioredis": "5.3.2",
+    "isolated-vm": "4.6.0",
     "joi": "17.9.2",
     "js-yaml": "4.1.0",
     "js2xmlparser": "5.0.0",
     "json2csv": "5.0.7",
-    "jsonwebtoken": "9.0.0",
+    "jsonwebtoken": "9.0.1",
     "keyv": "4.5.2",
     "knex": "2.4.2",
     "ldapjs": "2.3.3",
@@ -138,27 +139,26 @@
     "tsx": "3.12.7",
     "uuid": "9.0.0",
     "uuid-validate": "0.0.3",
-    "vm2": "3.9.19",
     "wellknown": "0.5.0",
     "ws": "8.12.1",
     "zod": "3.21.4",
     "zod-validation-error": "1.0.1",
-    "@directus/app": "10.6.2",
-    "@directus/constants": "10.2.2",
+    "@directus/app": "10.7.0",
+    "@directus/constants": "10.2.3",
     "@directus/errors": "0.0.2",
-    "@directus/extensions-sdk": "10.1.8",
-    "@directus/pressure": "1.0.7",
+    "@directus/extensions-sdk": "10.1.9",
+    "@directus/pressure": "1.0.8",
     "@directus/schema": "10.0.2",
-    "@directus/specs": "10.1.1",
+    "@directus/specs": "10.2.0",
     "@directus/storage": "10.0.5",
-    "@directus/storage-driver-azure": "10.0.8",
-    "@directus/storage-driver-cloudinary": "10.0.8",
-    "@directus/storage-driver-gcs": "10.0.8",
-    "@directus/storage-driver-local": "10.0.8",
-    "@directus/storage-driver-s3": "10.0.8",
-    "@directus/storage-driver-supabase": "1.0.0",
-    "@directus/utils": "10.0.8",
-    "@directus/validation": "0.0.3"
+    "@directus/storage-driver-azure": "10.0.9",
+    "@directus/storage-driver-cloudinary": "10.0.9",
+    "@directus/storage-driver-gcs": "10.0.9",
+    "@directus/storage-driver-local": "10.0.9",
+    "@directus/storage-driver-s3": "10.0.9",
+    "@directus/storage-driver-supabase": "1.0.1",
+    "@directus/utils": "10.0.9",
+    "@directus/validation": "0.0.4"
   },
   "devDependencies": {
     "@ngneat/falso": "6.4.0",
@@ -207,7 +207,7 @@
     "vitest": "0.31.1",
     "@directus/random": "0.2.2",
     "@directus/tsconfig": "1.0.0",
-    "@directus/types": "10.1.4"
+    "@directus/types": "10.1.5"
   },
   "optionalDependencies": {
     "@keyv/redis": "2.5.8",

package/dist/utils/redact.d.ts

@@ -1,15 +0,0 @@
-import type { UnknownObject } from '@directus/types';
-type Paths = string[][];
-/**
- * Redact values at certain paths in an object.
- * @param input Input object in which values should be redacted.
- * @param paths Nested array of object paths to be redacted (supports `*` for shallow matching, `**` for deep matching).
- * @param replacement Replacement the values are redacted by.
- * @returns Redacted object.
- */
-export declare function redact(input: UnknownObject, paths: Paths, replacement: string): UnknownObject;
-/**
- * Extract values from Error objects for use with JSON.stringify()
- */
-export declare function errorReplacer(_key: string, value: unknown): unknown;
-export {};