directus 9.22.4 → 9.23.3

package/dist/operations/notification/index.js

@@ -27,10 +27,9 @@ exports.default = (0, utils_1.defineOperationApi)({
         });
         const messageString = message ? (0, utils_1.optionToString)(message) : null;
         const payload = (0, utils_1.toArray)(recipient).map((userId) => {
-            var _a;
             return {
                 recipient: userId,
-                sender: (_a = customAccountability === null || customAccountability === void 0 ? void 0 : customAccountability.user) !== null && _a !== void 0 ? _a : null,
+                sender: customAccountability?.user ?? null,
                 subject,
                 message: messageString,
             };

package/dist/operations/request/index.js

@@ -5,33 +5,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@directus/shared/utils");
 const encodeurl_1 = __importDefault(require("encodeurl"));
+const index_1 = require("../../request/index");
 exports.default = (0, utils_1.defineOperationApi)({
     id: 'request',
     handler: async ({ url, method, body, headers }) => {
-        var _a;
-        const axios = (await import('axios')).default;
-        const customHeaders = (_a = headers === null || headers === void 0 ? void 0 : headers.reduce((acc, { header, value }) => {
+        const customHeaders = headers?.reduce((acc, { header, value }) => {
             acc[header] = value;
             return acc;
-        }, {})) !== null && _a !== void 0 ? _a : {};
-        if (!customHeaders['Content-Type'] && isValidJSON(body)) {
+        }, {}) ?? {};
+        if (!customHeaders['Content-Type'] && (typeof body === 'object' || (0, utils_1.isValidJSON)(body))) {
             customHeaders['Content-Type'] = 'application/json';
         }
-        const result = await axios({
-            url: (0, encodeurl_1.default)(url),
-            method,
-            data: body,
-            headers: customHeaders,
-        });
-        return { status: result.status, statusText: result.statusText, headers: result.headers, data: result.data };
-        function isValidJSON(value) {
-            try {
-                (0, utils_1.parseJSON)(value);
-                return true;
-            }
-            catch {
-                return false;
-            }
+        const axios = await (0, index_1.getAxios)();
+        try {
+            const result = await axios({
+                url: (0, encodeurl_1.default)(url),
+                method,
+                data: body,
+                headers: customHeaders,
+            });
+            return { status: result.status, statusText: result.statusText, headers: result.headers, data: result.data };
+        }
+        catch (error) {
+            throw JSON.stringify({
+                status: error.response.status,
+                statusText: error.response.statusText,
+                headers: error.response.headers,
+                data: error.response.data,
+            });
         }
     },
 });

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

@@ -1,6 +1,8 @@
 type Options = {
     flow: string;
     payload?: Record<string, any> | Record<string, any>[] | string | null;
+    iterationMode?: 'serial' | 'batch' | 'parallel';
+    batchSize?: number;
 };
 declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
 export default _default;

package/dist/operations/trigger/index.js

@@ -5,19 +5,35 @@ const lodash_1 = require("lodash");
 const flows_1 = require("../../flows");
 exports.default = (0, utils_1.defineOperationApi)({
     id: 'trigger',
-    handler: async ({ flow, payload }, context) => {
-        var _a;
+    handler: async ({ flow, payload, iterationMode, batchSize }, context) => {
         const flowManager = (0, flows_1.getFlowManager)();
-        const payloadObject = (_a = (0, utils_1.optionToObject)(payload)) !== null && _a !== void 0 ? _a : null;
-        let result;
+        const payloadObject = (0, utils_1.optionToObject)(payload) ?? null;
         if (Array.isArray(payloadObject)) {
-            result = await Promise.all(payloadObject.map((payload) => {
-                return flowManager.runOperationFlow(flow, payload, (0, lodash_1.omit)(context, 'data'));
-            }));
+            if (iterationMode === 'serial') {
+                const result = [];
+                for (const payload of payloadObject) {
+                    result.push(await flowManager.runOperationFlow(flow, payload, (0, lodash_1.omit)(context, 'data')));
+                }
+                return result;
+            }
+            if (iterationMode === 'batch') {
+                const size = batchSize ?? 10;
+                const result = [];
+                for (let i = 0; i < payloadObject.length; i += size) {
+                    const batch = payloadObject.slice(i, i + size);
+                    const batchResults = await Promise.all(batch.map((payload) => {
+                        return flowManager.runOperationFlow(flow, payload, (0, lodash_1.omit)(context, 'data'));
+                    }));
+                    result.push(...batchResults);
+                }
+                return result;
+            }
+            if (iterationMode === 'parallel' || !iterationMode) {
+                return await Promise.all(payloadObject.map((payload) => {
+                    return flowManager.runOperationFlow(flow, payload, (0, lodash_1.omit)(context, 'data'));
+                }));
+            }
         }
-        else {
-            result = await flowManager.runOperationFlow(flow, payloadObject, (0, lodash_1.omit)(context, 'data'));
-        }
-        return result;
+        return await flowManager.runOperationFlow(flow, payloadObject, (0, lodash_1.omit)(context, 'data'));
     },
 });

package/dist/rate-limiter.d.ts

@@ -1,4 +1,4 @@
 import { IRateLimiterOptions, IRateLimiterStoreOptions, RateLimiterAbstract } from 'rate-limiter-flexible';
 type IRateLimiterOptionsOverrides = Partial<IRateLimiterOptions> | Partial<IRateLimiterStoreOptions>;
-export declare function createRateLimiter(configOverrides?: IRateLimiterOptionsOverrides): RateLimiterAbstract;
+export declare function createRateLimiter(configPrefix?: string, configOverrides?: IRateLimiterOptionsOverrides): RateLimiterAbstract;
 export {};

package/dist/rate-limiter.js

@@ -8,28 +8,28 @@ const lodash_1 = require("lodash");
 const rate_limiter_flexible_1 = require("rate-limiter-flexible");
 const env_1 = __importDefault(require("./env"));
 const get_config_from_env_1 = require("./utils/get-config-from-env");
-function createRateLimiter(configOverrides) {
+function createRateLimiter(configPrefix = 'RATE_LIMITER', configOverrides) {
     switch (env_1.default.RATE_LIMITER_STORE) {
         case 'redis':
-            return new rate_limiter_flexible_1.RateLimiterRedis(getConfig('redis', configOverrides));
+            return new rate_limiter_flexible_1.RateLimiterRedis(getConfig('redis', configPrefix, configOverrides));
         case 'memcache':
-            return new rate_limiter_flexible_1.RateLimiterMemcache(getConfig('memcache', configOverrides));
+            return new rate_limiter_flexible_1.RateLimiterMemcache(getConfig('memcache', configPrefix, configOverrides));
         case 'memory':
         default:
-            return new rate_limiter_flexible_1.RateLimiterMemory(getConfig('memory', configOverrides));
+            return new rate_limiter_flexible_1.RateLimiterMemory(getConfig('memory', configPrefix, configOverrides));
     }
 }
 exports.createRateLimiter = createRateLimiter;
-function getConfig(store = 'memory', overrides) {
-    const config = (0, get_config_from_env_1.getConfigFromEnv)('RATE_LIMITER_', `RATE_LIMITER_${store}_`);
+function getConfig(store = 'memory', configPrefix = 'RATE_LIMITER', overrides) {
+    const config = (0, get_config_from_env_1.getConfigFromEnv)(`${configPrefix}_`, `${configPrefix}_${store}_`);
     if (store === 'redis') {
         const Redis = require('ioredis');
         delete config.redis;
-        config.storeClient = new Redis(env_1.default.RATE_LIMITER_REDIS || (0, get_config_from_env_1.getConfigFromEnv)('RATE_LIMITER_REDIS_'));
+        config.storeClient = new Redis(env_1.default[`${configPrefix}_REDIS`] || (0, get_config_from_env_1.getConfigFromEnv)(`${configPrefix}_REDIS_`));
     }
     if (store === 'memcache') {
         const Memcached = require('memcached');
-        config.storeClient = new Memcached(env_1.default.RATE_LIMITER_MEMCACHE, (0, get_config_from_env_1.getConfigFromEnv)('RATE_LIMITER_MEMCACHE_'));
+        config.storeClient = new Memcached(env_1.default[`${configPrefix}_MEMCACHE`], (0, get_config_from_env_1.getConfigFromEnv)(`${configPrefix}_MEMCACHE_`));
     }
     delete config.enabled;
     delete config.store;

package/dist/request/index.d.ts

@@ -0,0 +1,5 @@
+import type { AxiosInstance } from 'axios';
+export declare const _cache: {
+    axiosInstance: AxiosInstance | null;
+};
+export declare function getAxios(): Promise<AxiosInstance>;

package/dist/request/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAxios = exports._cache = void 0;
+const request_interceptor_1 = require("./request-interceptor");
+const response_interceptor_1 = require("./response-interceptor");
+exports._cache = {
+    axiosInstance: null,
+};
+async function getAxios() {
+    if (!exports._cache.axiosInstance) {
+        const axios = (await import('axios')).default;
+        exports._cache.axiosInstance = axios.create();
+        exports._cache.axiosInstance.interceptors.request.use(request_interceptor_1.requestInterceptor);
+        exports._cache.axiosInstance.interceptors.response.use(response_interceptor_1.responseInterceptor);
+    }
+    return exports._cache.axiosInstance;
+}
+exports.getAxios = getAxios;

package/dist/request/index.test.d.ts

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

package/dist/request/request-interceptor.d.ts

@@ -0,0 +1,2 @@
+import type { InternalAxiosRequestConfig } from 'axios';
+export declare const requestInterceptor: (config: InternalAxiosRequestConfig) => Promise<InternalAxiosRequestConfig<any>>;

package/dist/request/request-interceptor.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestInterceptor = void 0;
+const axios_1 = __importDefault(require("axios"));
+const promises_1 = require("node:dns/promises");
+const node_net_1 = require("node:net");
+const node_url_1 = require("node:url");
+const logger_1 = __importDefault(require("../logger"));
+const validate_ip_1 = require("./validate-ip");
+const requestInterceptor = async (config) => {
+    const uri = axios_1.default.getUri(config);
+    const { hostname } = new node_url_1.URL(uri);
+    let ip;
+    if ((0, node_net_1.isIP)(hostname) === 0) {
+        try {
+            const dns = await (0, promises_1.lookup)(hostname);
+            ip = dns.address;
+        }
+        catch (err) {
+            logger_1.default.warn(err, `Couldn't lookup the DNS for url "${uri}"`);
+            throw new Error(`Requested URL "${uri}" resolves to a denied IP address`);
+        }
+    }
+    else {
+        ip = hostname;
+    }
+    await (0, validate_ip_1.validateIP)(ip, uri);
+    return config;
+};
+exports.requestInterceptor = requestInterceptor;

package/dist/request/request-interceptor.test.d.ts

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

package/dist/request/response-interceptor.d.ts

@@ -0,0 +1,2 @@
+import type { AxiosResponse } from 'axios';
+export declare const responseInterceptor: (config: AxiosResponse<any, any>) => Promise<AxiosResponse<any, any>>;

package/dist/request/response-interceptor.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseInterceptor = void 0;
+const validate_ip_1 = require("./validate-ip");
+const responseInterceptor = async (config) => {
+    await (0, validate_ip_1.validateIP)(config.request.socket.remoteAddress, config.request.url);
+    return config;
+};
+exports.responseInterceptor = responseInterceptor;

package/dist/request/response-interceptor.test.d.ts

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

package/dist/request/validate-ip.d.ts

@@ -0,0 +1 @@
+export declare const validateIP: (ip: string, url: string) => Promise<void>;

package/dist/request/validate-ip.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateIP = void 0;
+const node_os_1 = __importDefault(require("node:os"));
+const env_1 = require("../env");
+const validateIP = async (ip, url) => {
+    const env = (0, env_1.getEnv)();
+    if (env.IMPORT_IP_DENY_LIST.includes(ip)) {
+        throw new Error(`Requested URL "${url}" resolves to a denied IP address`);
+    }
+    if (env.IMPORT_IP_DENY_LIST.includes('0.0.0.0')) {
+        const networkInterfaces = node_os_1.default.networkInterfaces();
+        for (const networkInfo of Object.values(networkInterfaces)) {
+            if (!networkInfo)
+                continue;
+            for (const info of networkInfo) {
+                if (info.address === ip) {
+                    throw new Error(`Requested URL "${url}" resolves to a denied IP address`);
+                }
+            }
+        }
+    }
+};
+exports.validateIP = validateIP;

package/dist/request/validate-ip.test.d.ts

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

package/dist/server.js

@@ -32,14 +32,14 @@ const http = __importStar(require("http"));
 const https = __importStar(require("https"));
 const lodash_1 = require("lodash");
 const qs_1 = __importDefault(require("qs"));
+const update_check_1 = __importDefault(require("update-check"));
 const url_1 = __importDefault(require("url"));
+const package_json_1 = __importDefault(require("../package.json"));
 const app_1 = __importDefault(require("./app"));
 const database_1 = __importDefault(require("./database"));
+const emitter_1 = __importDefault(require("./emitter"));
 const env_1 = __importDefault(require("./env"));
 const logger_1 = __importDefault(require("./logger"));
-const emitter_1 = __importDefault(require("./emitter"));
-const update_check_1 = __importDefault(require("update-check"));
-const package_json_1 = __importDefault(require("../package.json"));
 const get_config_from_env_1 = require("./utils/get-config-from-env");
 async function createServer() {
     const server = http.createServer(await (0, app_1.default)());
@@ -47,12 +47,11 @@ async function createServer() {
     server.on('request', function (req, res) {
         const startTime = process.hrtime();
         const complete = (0, lodash_1.once)(function (finished) {
-            var _a, _b, _c, _d;
             const elapsedTime = process.hrtime(startTime);
             const elapsedNanoseconds = elapsedTime[0] * 1e9 + elapsedTime[1];
             const elapsedMilliseconds = elapsedNanoseconds / 1e6;
-            const previousIn = ((_a = req.socket._metrics) === null || _a === void 0 ? void 0 : _a.in) || 0;
-            const previousOut = ((_b = req.socket._metrics) === null || _b === void 0 ? void 0 : _b.out) || 0;
+            const previousIn = req.socket._metrics?.in || 0;
+            const previousOut = req.socket._metrics?.out || 0;
             const metrics = {
                 in: req.socket.bytesRead - previousIn,
                 out: req.socket.bytesWritten - previousOut,
@@ -85,13 +84,13 @@ async function createServer() {
                     size: metrics.out,
                     headers: res.getHeaders(),
                 },
-                ip: req.headers['x-forwarded-for'] || ((_c = req.socket) === null || _c === void 0 ? void 0 : _c.remoteAddress),
+                ip: req.headers['x-forwarded-for'] || req.socket?.remoteAddress,
                 duration: elapsedMilliseconds.toFixed(),
             };
             emitter_1.default.emitAction('response', info, {
                 database: (0, database_1.default)(),
                 schema: req.schema,
-                accountability: (_d = req.accountability) !== null && _d !== void 0 ? _d : null,
+                accountability: req.accountability ?? null,
             });
         });
         res.once('finish', complete.bind(null, true));
@@ -151,7 +150,7 @@ async function startServer() {
         });
     })
         .once('error', (err) => {
-        if ((err === null || err === void 0 ? void 0 : err.code) === 'EADDRINUSE') {
+        if (err?.code === 'EADDRINUSE') {
             logger_1.default.error(`Port ${port} is already in use`);
             process.exit(1);
         }

package/dist/services/activity.d.ts

@@ -1,4 +1,4 @@
-import { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types';
+import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types';
 import { ItemsService } from './items';
 import { NotificationsService } from './notifications';
 import { UsersService } from './users';

package/dist/services/activity.js

@@ -18,16 +18,17 @@ const items_1 = require("./items");
 const notifications_1 = require("./notifications");
 const users_1 = require("./users");
 class ActivityService extends items_1.ItemsService {
+    notificationsService;
+    usersService;
     constructor(options) {
         super('directus_activity', options);
         this.notificationsService = new notifications_1.NotificationsService({ schema: this.schema });
         this.usersService = new users_1.UsersService({ schema: this.schema });
     }
     async createOne(data, opts) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
         if (data.action === types_1.Action.COMMENT && typeof data.comment === 'string') {
             const usersRegExp = new RegExp(/@[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/gi);
-            const mentions = (0, lodash_1.uniq)((_a = data.comment.match(usersRegExp)) !== null && _a !== void 0 ? _a : []);
+            const mentions = (0, lodash_1.uniq)(data.comment.match(usersRegExp) ?? []);
             const sender = await this.usersService.readOne(this.accountability.user, {
                 fields: ['id', 'first_name', 'last_name', 'email'],
             });
@@ -38,9 +39,9 @@ class ActivityService extends items_1.ItemsService {
                 });
                 const accountability = {
                     user: userID,
-                    role: (_c = (_b = user.role) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : null,
-                    admin: (_e = (_d = user.role) === null || _d === void 0 ? void 0 : _d.admin_access) !== null && _e !== void 0 ? _e : null,
-                    app: (_g = (_f = user.role) === null || _f === void 0 ? void 0 : _f.app_access) !== null && _g !== void 0 ? _g : null,
+                    role: user.role?.id ?? null,
+                    admin: user.role?.admin_access ?? null,
+                    app: user.role?.app_access ?? null,
                 };
                 accountability.permissions = await (0, get_permissions_1.getPermissions)(accountability, this.schema);
                 const authorizationService = new authorization_1.AuthorizationService({ schema: this.schema, accountability });
@@ -61,7 +62,7 @@ class ActivityService extends items_1.ItemsService {
                         // We only match on UUIDs in the first place. This is just an extra sanity check
                         if ((0, uuid_validate_1.default)(uuid) === false)
                             continue;
-                        comment = comment.replace(new RegExp(mention, 'gm'), (_h = userPreviews[uuid]) !== null && _h !== void 0 ? _h : '@Unknown User');
+                        comment = comment.replace(new RegExp(mention, 'gm'), userPreviews[uuid] ?? '@Unknown User');
                     }
                     comment = `> ${comment.replace(/\n+/gm, '\n> ')}`;
                     const message = `

package/dist/services/assets.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 import type { Range, Stat } from '@directus/storage';
-import { Accountability } from '@directus/shared/types';
+import type { Accountability } from '@directus/shared/types';
+import type { Knex } from 'knex';
 import type { Readable } from 'node:stream';
-import { Knex } from 'knex';
-import { AbstractServiceOptions, TransformationParams, TransformationPreset } from '../types';
+import type { AbstractServiceOptions, TransformationParams, TransformationPreset } from '../types';
 import { AuthorizationService } from './authorization';
 export declare class AssetsService {
     knex: Knex;

package/dist/services/assets.js

@@ -27,7 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetsService = void 0;
-const async_mutex_1 = require("async-mutex");
+const lodash_1 = require("lodash");
 const mime_types_1 = require("mime-types");
 const object_hash_1 = __importDefault(require("object-hash"));
 const path_1 = __importDefault(require("path"));
@@ -36,22 +36,22 @@ const uuid_validate_1 = __importDefault(require("uuid-validate"));
 const database_1 = __importDefault(require("../database"));
 const env_1 = __importDefault(require("../env"));
 const exceptions_1 = require("../exceptions");
+const service_unavailable_1 = require("../exceptions/service-unavailable");
 const logger_1 = __importDefault(require("../logger"));
 const storage_1 = require("../storage");
+const get_milliseconds_1 = require("../utils/get-milliseconds");
 const TransformationUtils = __importStar(require("../utils/transformations"));
 const authorization_1 = require("./authorization");
-sharp_1.default.concurrency(1);
-// Note: don't put this in the service. The service can be initialized in multiple places, but they
-// should all share the same semaphore instance.
-const semaphore = new async_mutex_1.Semaphore(env_1.default.ASSETS_TRANSFORM_MAX_CONCURRENT);
 class AssetsService {
+    knex;
+    accountability;
+    authorizationService;
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
         this.accountability = options.accountability || null;
         this.authorizationService = new authorization_1.AuthorizationService(options);
     }
     async getAsset(id, transformation, range) {
-        var _a;
         const storage = await (0, storage_1.getStorage)();
         const publicSettings = await this.knex
             .select('project_logo', 'public_background', 'public_foreground')
@@ -66,7 +66,7 @@ class AssetsService {
         const isValidUUID = (0, uuid_validate_1.default)(id, 4);
         if (isValidUUID === false)
             throw new exceptions_1.ForbiddenException();
-        if (systemPublicKeys.includes(id) === false && ((_a = this.accountability) === null || _a === void 0 ? void 0 : _a.admin) !== true) {
+        if (systemPublicKeys.includes(id) === false && this.accountability?.admin !== true) {
             await this.authorizationService.checkAccess('read', 'directus_files', id);
         }
         const file = (await this.knex.select('*').from('directus_files').where({ id }).first());
@@ -135,27 +135,34 @@ class AssetsService {
                 height > env_1.default.ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION) {
                 throw new exceptions_1.IllegalAssetTransformation(`Image is too large to be transformed, or image size couldn't be determined.`);
             }
-            return await semaphore.runExclusive(async () => {
-                const readStream = await storage.location(file.storage).read(file.filename_disk, range);
-                const transformer = (0, sharp_1.default)({
-                    limitInputPixels: Math.pow(env_1.default.ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION, 2),
-                    sequentialRead: true,
-                    failOn: env_1.default.ASSETS_INVALID_IMAGE_SENSITIVITY_LEVEL,
+            const { queue, process } = sharp_1.default.counters();
+            if (queue + process > env_1.default.ASSETS_TRANSFORM_MAX_CONCURRENT) {
+                throw new service_unavailable_1.ServiceUnavailableException('Server too busy', {
+                    service: 'files',
                 });
-                if (transforms.find((transform) => transform[0] === 'rotate') === undefined)
-                    transformer.rotate();
-                transforms.forEach(([method, ...args]) => transformer[method].apply(transformer, args));
-                readStream.on('error', (e) => {
-                    logger_1.default.error(e, `Couldn't transform file ${file.id}`);
-                    readStream.unpipe(transformer);
-                });
-                await storage.location(file.storage).write(assetFilename, readStream.pipe(transformer), type);
-                return {
-                    stream: await storage.location(file.storage).read(assetFilename, range),
-                    stat: await storage.location(file.storage).stat(assetFilename),
-                    file,
-                };
+            }
+            const readStream = await storage.location(file.storage).read(file.filename_disk, range);
+            const transformer = (0, sharp_1.default)({
+                limitInputPixels: Math.pow(env_1.default.ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION, 2),
+                sequentialRead: true,
+                failOn: env_1.default.ASSETS_INVALID_IMAGE_SENSITIVITY_LEVEL,
+            });
+            transformer.timeout({
+                seconds: (0, lodash_1.clamp)(Math.round((0, get_milliseconds_1.getMilliseconds)(env_1.default.ASSETS_TRANSFORM_TIMEOUT, 0) / 1000), 1, 3600),
+            });
+            if (transforms.find((transform) => transform[0] === 'rotate') === undefined)
+                transformer.rotate();
+            transforms.forEach(([method, ...args]) => transformer[method].apply(transformer, args));
+            readStream.on('error', (e) => {
+                logger_1.default.error(e, `Couldn't transform file ${file.id}`);
+                readStream.unpipe(transformer);
             });
+            await storage.location(file.storage).write(assetFilename, readStream.pipe(transformer), type);
+            return {
+                stream: await storage.location(file.storage).read(assetFilename, range),
+                stat: await storage.location(file.storage).stat(assetFilename),
+                file,
+            };
         }
         else {
             const readStream = await storage.location(file.storage).read(file.filename_disk, range);

package/dist/services/authentication.d.ts

@@ -1,6 +1,6 @@
 import { Accountability, SchemaOverview } from '@directus/shared/types';
-import { Knex } from 'knex';
-import { AbstractServiceOptions, LoginResult } from '../types';
+import type { Knex } from 'knex';
+import type { AbstractServiceOptions, LoginResult } from '../types';
 import { ActivityService } from './activity';
 export declare class AuthenticationService {
     knex: Knex;