@directus/api 12.1.3 → 13.1.0-beta.0

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/branches.d.ts

@@ -0,0 +1,25 @@
+import type { Item, PrimaryKey, Query } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
+import { AuthorizationService } from './authorization.js';
+import { CollectionsService } from './collections.js';
+import { ItemsService } from './items.js';
+export declare class BranchesService extends ItemsService {
+    authorizationService: AuthorizationService;
+    collectionsService: CollectionsService;
+    constructor(options: AbstractServiceOptions);
+    private validateCreateData;
+    private validateUpdateData;
+    getMainBranchItem(collection: string, item: PrimaryKey, query?: Query): Promise<Item>;
+    verifyHash(collection: string, item: PrimaryKey, hash: string): Promise<{
+        outdated: boolean;
+        mainHash: string;
+    }>;
+    getBranchCommits(key: PrimaryKey): Promise<Partial<Item>[]>;
+    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateBatch(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateByQuery(query: Query, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    commit(key: PrimaryKey, data: Partial<Item>): Promise<Partial<Item>>;
+    merge(branch: PrimaryKey, mainHash: string, fields?: string[]): Promise<import("../types/items.js").PrimaryKey>;
+}

package/dist/services/branches.js

@@ -0,0 +1,205 @@
+import Joi from 'joi';
+import { assign, pick } from 'lodash-es';
+import objectHash from 'object-hash';
+import getDatabase from '../database/index.js';
+import emitter from '../emitter.js';
+import { InvalidPayloadError, UnprocessableContentError } from '../errors/index.js';
+import { ActivityService } from './activity.js';
+import { AuthorizationService } from './authorization.js';
+import { CollectionsService } from './collections.js';
+import { ItemsService } from './items.js';
+import { PayloadService } from './payload.js';
+import { RevisionsService } from './revisions.js';
+const branchUpdateSchema = Joi.object({
+    name: Joi.string(),
+});
+export class BranchesService extends ItemsService {
+    authorizationService;
+    collectionsService;
+    constructor(options) {
+        super('directus_branches', options);
+        this.authorizationService = new AuthorizationService({
+            accountability: this.accountability,
+            knex: this.knex,
+            schema: this.schema,
+        });
+        this.collectionsService = new CollectionsService({
+            accountability: this.accountability,
+            knex: this.knex,
+            schema: this.schema,
+        });
+    }
+    async validateCreateData(data) {
+        if (!data['name'])
+            throw new InvalidPayloadError({ reason: `"name" is required` });
+        // Reserves the "main" branch name for the branch query parameter
+        if (data['name'] === 'main')
+            throw new InvalidPayloadError({ reason: `"main" is a reserved branch name` });
+        if (!data['collection']) {
+            throw new InvalidPayloadError({ reason: `"collection" is required` });
+        }
+        if (!data['item'])
+            throw new InvalidPayloadError({ reason: `"item" is required` });
+        // will throw an error if the collection does not exist or the accountability does not have permission to read it
+        const existingCollection = await this.collectionsService.readOne(data['collection']);
+        if (!existingCollection.meta?.branches_enabled) {
+            throw new UnprocessableContentError({
+                reason: `Branch feature is not enabled for collection "${data['collection']}"`,
+            });
+        }
+        const existingBranches = await super.readByQuery({
+            fields: ['name', 'collection', 'item'],
+            filter: { name: { _eq: data['name'] }, collection: { _eq: data['collection'] }, item: { _eq: data['item'] } },
+        });
+        if (existingBranches.length > 0) {
+            throw new UnprocessableContentError({
+                reason: `Branch "${data['name']}" already exists for item "${data['item']}" in collection "${data['collection']}"`,
+            });
+        }
+        // will throw an error if the accountability does not have permission to read the item
+        await this.authorizationService.checkAccess('read', data['collection'], data['item']);
+    }
+    async validateUpdateData(data) {
+        // Only allow updates on "name" field
+        const { error } = branchUpdateSchema.validate(data);
+        if (error)
+            throw new InvalidPayloadError({ reason: error.message });
+        // Reserves the "main" branch name for the branch query parameter
+        if ('name' in data && data['name'] === 'main') {
+            throw new InvalidPayloadError({ reason: `"main" is a reserved branch name` });
+        }
+    }
+    async getMainBranchItem(collection, item, query) {
+        // will throw an error if the accountability does not have permission to read the item
+        await this.authorizationService.checkAccess('read', collection, item);
+        const itemsService = new ItemsService(collection, {
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+        });
+        return await itemsService.readOne(item, query);
+    }
+    async verifyHash(collection, item, hash) {
+        const mainBranchItem = await this.getMainBranchItem(collection, item);
+        const mainHash = objectHash(mainBranchItem);
+        return { outdated: hash !== mainHash, mainHash };
+    }
+    async getBranchCommits(key) {
+        const revisionsService = new RevisionsService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const result = await revisionsService.readByQuery({
+            filter: { branch: { _eq: key } },
+        });
+        return result.map((revision) => revision['delta']);
+    }
+    async createOne(data, opts) {
+        await this.validateCreateData(data);
+        const mainBranchItem = await this.getMainBranchItem(data['collection'], data['item']);
+        data['hash'] = objectHash(mainBranchItem);
+        return super.createOne(data, opts);
+    }
+    async createMany(data, opts) {
+        if (!Array.isArray(data)) {
+            throw new InvalidPayloadError({ reason: 'Input should be an array of items' });
+        }
+        for (const item of data) {
+            await this.validateCreateData(item);
+            const mainBranchItem = await this.getMainBranchItem(item['collection'], item['item']);
+            item['hash'] = objectHash(mainBranchItem);
+        }
+        return super.createMany(data, opts);
+    }
+    async updateBatch(data, opts) {
+        if (!Array.isArray(data)) {
+            throw new InvalidPayloadError({ reason: 'Input should be an array of items' });
+        }
+        for (const item of data) {
+            await this.validateUpdateData(item);
+        }
+        return super.updateBatch(data, opts);
+    }
+    async updateMany(keys, data, opts) {
+        await this.validateUpdateData(data);
+        return super.updateMany(keys, data, opts);
+    }
+    async updateByQuery(query, data, opts) {
+        await this.validateUpdateData(data);
+        return super.updateByQuery(query, data, opts);
+    }
+    async commit(key, data) {
+        const branch = await super.readOne(key);
+        const payloadService = new PayloadService(this.collection, {
+            accountability: this.accountability,
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const activityService = new ActivityService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const revisionsService = new RevisionsService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const activity = await activityService.createOne({
+            action: 'commit',
+            user: this.accountability?.user ?? null,
+            collection: branch['collection'],
+            ip: this.accountability?.ip ?? null,
+            user_agent: this.accountability?.userAgent ?? null,
+            origin: this.accountability?.origin ?? null,
+            item: branch['item'],
+        });
+        const revisionDelta = await payloadService.prepareDelta(data);
+        await revisionsService.createOne({
+            activity,
+            branch: key,
+            collection: branch['collection'],
+            item: branch['item'],
+            data: revisionDelta,
+            delta: revisionDelta,
+        });
+        return data;
+    }
+    async merge(branch, mainHash, fields) {
+        const { id, collection, item } = (await this.readOne(branch));
+        // will throw an error if the accountability does not have permission to update the item
+        await this.authorizationService.checkAccess('update', collection, item);
+        const { outdated } = await this.verifyHash(collection, item, mainHash);
+        if (outdated) {
+            throw new UnprocessableContentError({
+                reason: `Main branch has changed since this branch was last updated`,
+            });
+        }
+        const commits = await this.getBranchCommits(id);
+        const branchResult = assign({}, ...commits);
+        const payloadToUpdate = fields ? pick(branchResult, fields) : branchResult;
+        const itemsService = new ItemsService(collection, {
+            accountability: this.accountability,
+            schema: this.schema,
+        });
+        const payloadAfterHooks = await emitter.emitFilter(['items.merge', `${collection}.items.merge`], payloadToUpdate, {
+            collection,
+            item,
+            branch,
+        }, {
+            database: getDatabase(),
+            schema: this.schema,
+            accountability: this.accountability,
+        });
+        const updatedItemKey = await itemsService.updateOne(item, payloadAfterHooks);
+        emitter.emitAction(['items.merge', `${collection}.items.merge`], {
+            payload: payloadAfterHooks,
+            collection,
+            item: updatedItemKey,
+            branch,
+        }, {
+            database: getDatabase(),
+            schema: this.schema,
+            accountability: this.accountability,
+        });
+        return updatedItemKey;
+    }
+}

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/types/collection.d.ts

@@ -7,6 +7,7 @@ export type CollectionMeta = {
     singleton: boolean;
     icon: string | null;
     translations: Record<string, string>;
+    branches_enabled: boolean;
     item_duplication_fields: string[] | null;
     accountability: 'all' | 'accountability' | null;
     group: string | null;

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

@@ -46,6 +46,9 @@ export function sanitizeQuery(rawQuery, accountability) {
     if (rawQuery['search'] && typeof rawQuery['search'] === 'string') {
         query.search = rawQuery['search'];
     }
+    if (rawQuery['branch']) {
+        query.branch = rawQuery['branch'];
+    }
     if (rawQuery['export']) {
         query.export = rawQuery['export'];
     }
@@ -146,22 +149,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/dist/utils/validate-query.js

@@ -17,6 +17,7 @@ const querySchema = Joi.object({
     meta: Joi.array().items(Joi.string().valid('total_count', 'filter_count')),
     search: Joi.string(),
     export: Joi.string().valid('csv', 'json', 'xml', 'yaml'),
+    branch: Joi.string(),
     aggregate: Joi.object(),
     deep: Joi.object(),
     alias: Joi.object(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "12.1.3",
+  "version": "13.1.0-beta.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.8.0-beta.0",
+    "@directus/constants": "10.2.4-beta.0",
     "@directus/errors": "0.0.2",
-    "@directus/extensions-sdk": "10.1.8",
-    "@directus/pressure": "1.0.7",
+    "@directus/extensions-sdk": "10.1.10-beta.0",
+    "@directus/pressure": "1.0.9-beta.0",
     "@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.10-beta.0",
+    "@directus/storage-driver-cloudinary": "10.0.10-beta.0",
+    "@directus/storage-driver-gcs": "10.0.10-beta.0",
+    "@directus/storage-driver-local": "10.0.10-beta.0",
+    "@directus/storage-driver-s3": "10.0.10-beta.0",
+    "@directus/storage-driver-supabase": "1.0.2-beta.0",
+    "@directus/utils": "10.0.10-beta.0",
+    "@directus/validation": "0.0.5-beta.0"
   },
   "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.6-beta.0"
   },
   "optionalDependencies": {
     "@keyv/redis": "2.5.8",