@directus/api 15.0.0 → 17.0.0

package/dist/types/items.d.ts

@@ -1,20 +1,12 @@
-/**
- * I know this looks a little silly, but it allows us to explicitly differentiate between when we're
- * expecting an item vs any other generic object.
- */
 import type { DirectusError } from '@directus/errors';
 import type { EventContext } from '@directus/types';
 import type { MutationTracker } from '../services/items.js';
 export type Item = Record<string, any>;
 export type PrimaryKey = string | number;
-export type Alterations = {
-    create: {
-        [key: string]: any;
-    }[];
-    update: {
-        [key: string]: any;
-    }[];
-    delete: (number | string)[];
+export type Alterations<T extends Item = Item, K extends keyof T | undefined = undefined> = {
+    create: Partial<T>[];
+    update: (K extends keyof T ? Partial<T> & Pick<T, K> : Partial<T>)[];
+    delete: (K extends keyof T ? T[K] : PrimaryKey)[];
 };
 export type MutationOptions = {
     /**

package/dist/types/items.js

@@ -1,5 +1 @@
-/**
- * I know this looks a little silly, but it allows us to explicitly differentiate between when we're
- * expecting an item vs any other generic object.
- */
 export {};

package/dist/utils/apply-diff.js

@@ -4,12 +4,13 @@ import { flushCaches } from '../cache.js';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { CollectionsService } from '../services/collections.js';
 import { FieldsService } from '../services/fields.js';
 import { RelationsService } from '../services/relations.js';
 import { DiffKind } from '../types/index.js';
 import { getSchema } from './get-schema.js';
+const logger = useLogger();
 export async function applyDiff(currentSnapshot, snapshotDiff, options) {
     const database = options?.database ?? getDatabase();
     const helpers = getHelpers(database);

package/dist/utils/apply-query.js

@@ -408,9 +408,6 @@ export function applyFilter(knex, schema, rootQuery, rootFilter, collection, ali
                 if (['integer', 'float', 'decimal'].includes(type)) {
                     compareValue = Number(compareValue);
                 }
-                else if (type === 'bigInteger') {
-                    compareValue = BigInt(compareValue);
-                }
             }
             // Cast filter value (compareValue) based on type of field being filtered against
             const [collection, field] = key.split('.');
@@ -433,14 +430,6 @@ export function applyFilter(knex, schema, rootQuery, rootFilter, collection, ali
                         compareValue = Number(compareValue);
                     }
                 }
-                if (type === 'bigInteger') {
-                    if (Array.isArray(compareValue)) {
-                        compareValue = compareValue.map((val) => BigInt(val));
-                    }
-                    else {
-                        compareValue = BigInt(compareValue);
-                    }
-                }
             }
             if (operator === '_eq') {
                 dbQuery[logical].where(selectionRaw, '=', compareValue);

package/dist/utils/delete-from-require-cache.js

@@ -1,7 +1,8 @@
 import { createRequire } from 'node:module';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 const require = createRequire(import.meta.url);
 export function deleteFromRequireCache(modulePath) {
+    const logger = useLogger();
     try {
         const moduleCachePath = require.resolve(modulePath);
         delete require.cache[moduleCachePath];

package/dist/utils/get-accountability-for-token.js

@@ -1,9 +1,10 @@
-import getDatabase from '../database/index.js';
-import env from '../env.js';
+import { useEnv } from '@directus/env';
 import { InvalidCredentialsError } from '@directus/errors';
+import getDatabase from '../database/index.js';
 import isDirectusJWT from './is-directus-jwt.js';
 import { verifyAccessJWT } from './jwt.js';
 export async function getAccountabilityForToken(token, accountability) {
+    const env = useEnv();
     if (!accountability) {
         accountability = {
             user: null,

package/dist/utils/get-auth-providers.js

@@ -1,6 +1,7 @@
+import { useEnv } from '@directus/env';
 import { toArray } from '@directus/utils';
-import env from '../env.js';
 export function getAuthProviders() {
+    const env = useEnv();
     return toArray(env['AUTH_PROVIDERS'])
         .filter((provider) => provider && env[`AUTH_${provider.toUpperCase()}_DRIVER`])
         .map((provider) => ({

package/dist/utils/get-cache-headers.js

@@ -1,4 +1,4 @@
-import env from '../env.js';
+import { useEnv } from '@directus/env';
 import { shouldSkipCache } from './should-skip-cache.js';
 /**
  * Returns the Cache-Control header for the current request
@@ -9,6 +9,7 @@ import { shouldSkipCache } from './should-skip-cache.js';
  * @param personalized Whether requests depend on the authentication status of users
  */
 export function getCacheControlHeader(req, ttl, globalCacheSettings, personalized) {
+    const env = useEnv();
     // When the user explicitly asked to skip the cache
     if (shouldSkipCache(req))
         return 'no-store';
@@ -29,7 +30,9 @@ export function getCacheControlHeader(req, ttl, globalCacheSettings, personalize
     const ttlSeconds = Math.round(ttl / 1000);
     headerValues.push(`max-age=${ttlSeconds}`);
     // When the s-maxage flag should be included
-    if (globalCacheSettings && Number.isInteger(env['CACHE_CONTROL_S_MAXAGE']) && env['CACHE_CONTROL_S_MAXAGE'] >= 0) {
+    if (globalCacheSettings &&
+        Number.isInteger(env['CACHE_CONTROL_S_MAXAGE']) &&
+        env['CACHE_CONTROL_S_MAXAGE'] >= 0) {
         headerValues.push(`s-maxage=${env['CACHE_CONTROL_S_MAXAGE']}`);
     }
     return headerValues.join(', ');

package/dist/utils/get-config-from-env.js

@@ -1,7 +1,8 @@
+import { useEnv } from '@directus/env';
 import camelcase from 'camelcase';
 import { set } from 'lodash-es';
-import env from '../env.js';
 export function getConfigFromEnv(prefix, omitPrefix, type = 'camelcase') {
+    const env = useEnv();
     const config = {};
     for (const [key, value] of Object.entries(env)) {
         if (key.toLowerCase().startsWith(prefix.toLowerCase()) === false)

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

@@ -1,6 +1,6 @@
 import { parseJSON } from '@directus/utils';
-import env from '../env.js';
-import logger from '../logger.js';
+import { getNodeEnv } from '@directus/utils/node';
+import { useLogger } from '../logger.js';
 import getLocalType from './get-local-type.js';
 export default function getDefaultValue(column, field) {
     const type = getLocalType(column, field);
@@ -37,6 +37,7 @@ function castToBoolean(value) {
     return Boolean(value);
 }
 function castToObject(value) {
+    const logger = useLogger();
     if (!value)
         return value;
     if (typeof value === 'object')
@@ -46,7 +47,7 @@ function castToObject(value) {
             return parseJSON(value);
         }
         catch (err) {
-            if (env['NODE_ENV'] === 'development') {
+            if (getNodeEnv() === 'development') {
                 logger.error(err);
             }
             return value;

package/dist/utils/get-ip-from-req.js

@@ -1,7 +1,9 @@
+import { useEnv } from '@directus/env';
 import { isIP } from 'net';
-import env from '../env.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 export function getIPFromReq(req) {
+    const env = useEnv();
+    const logger = useLogger();
     let ip = req.ip;
     if (env['IP_CUSTOM_HEADER']) {
         const customIPHeaderValue = req.get(env['IP_CUSTOM_HEADER']);

package/dist/utils/get-permissions.js

@@ -1,18 +1,20 @@
+import { useEnv } from '@directus/env';
 import { deepMap, parseFilter, parseJSON, parsePreset } from '@directus/utils';
 import { cloneDeep } from 'lodash-es';
 import hash from 'object-hash';
 import { getCache, getCacheValue, getSystemCache, setCacheValue, setSystemCache } from '../cache.js';
 import getDatabase from '../database/index.js';
 import { appAccessMinimalPermissions } from '../database/system-data/app-access-permissions/index.js';
-import env from '../env.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { RolesService } from '../services/roles.js';
 import { UsersService } from '../services/users.js';
-import { mergePermissions } from './merge-permissions.js';
 import { mergePermissionsForShare } from './merge-permissions-for-share.js';
+import { mergePermissions } from './merge-permissions.js';
 export async function getPermissions(accountability, schema) {
     const database = getDatabase();
     const { cache } = getCache();
+    const env = useEnv();
+    const logger = useLogger();
     let permissions = [];
     const { user, role, app, admin, share_scope } = accountability;
     const cacheKey = `permissions-${hash({ user, role, app, admin, share_scope })}`;

package/dist/utils/get-schema.js

@@ -1,3 +1,4 @@
+import { useEnv } from '@directus/env';
 import { createInspector } from '@directus/schema';
 import { parseJSON, toArray } from '@directus/utils';
 import { mapValues } from 'lodash-es';
@@ -6,12 +7,13 @@ import { ALIAS_TYPES } from '../constants.js';
 import getDatabase from '../database/index.js';
 import { systemCollectionRows } from '../database/system-data/collections/index.js';
 import { systemFieldRows } from '../database/system-data/fields/index.js';
-import env from '../env.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { RelationsService } from '../services/relations.js';
 import getDefaultValue from './get-default-value.js';
 import getLocalType from './get-local-type.js';
+const logger = useLogger();
 export async function getSchema(options) {
+    const env = useEnv();
     const database = options?.database || getDatabase();
     const schemaInspector = createInspector(database);
     let result;
@@ -42,6 +44,7 @@ export async function getSchema(options) {
     return result;
 }
 async function getDatabaseSchema(database, schemaInspector) {
+    const env = useEnv();
     const result = {
         collections: {},
         relations: [],

package/dist/utils/get-snapshot-diff.js

@@ -1,10 +1,9 @@
 import deepDiff from 'deep-diff';
-import { orderBy } from 'lodash-es';
 import { DiffKind } from '../types/index.js';
 import { sanitizeCollection, sanitizeField, sanitizeRelation } from './sanitize-schema.js';
 export function getSnapshotDiff(current, after) {
     const diffedSnapshot = {
-        collections: orderBy([
+        collections: [
             ...current.collections.map((currentCollection) => {
                 const afterCollection = after.collections.find((afterCollection) => afterCollection.collection === currentCollection.collection);
                 return {
@@ -21,8 +20,8 @@ export function getSnapshotDiff(current, after) {
                 collection: afterCollection.collection,
                 diff: deepDiff.diff(undefined, sanitizeCollection(afterCollection)),
             })),
-        ].filter((obj) => Array.isArray(obj.diff)), 'collection'),
-        fields: orderBy([
+        ].filter((obj) => Array.isArray(obj.diff)),
+        fields: [
             ...current.fields.map((currentField) => {
                 const afterField = after.fields.find((afterField) => afterField.collection === currentField.collection && afterField.field === currentField.field);
                 const isAutoIncrementPrimaryKey = !!currentField.schema?.is_primary_key && !!currentField.schema?.has_auto_increment;
@@ -42,8 +41,8 @@ export function getSnapshotDiff(current, after) {
                 field: afterField.field,
                 diff: deepDiff.diff(undefined, sanitizeField(afterField)),
             })),
-        ].filter((obj) => Array.isArray(obj.diff)), ['collection']),
-        relations: orderBy([
+        ].filter((obj) => Array.isArray(obj.diff)),
+        relations: [
             ...current.relations.map((currentRelation) => {
                 const afterRelation = after.relations.find((afterRelation) => afterRelation.collection === currentRelation.collection && afterRelation.field === currentRelation.field);
                 return {
@@ -55,8 +54,7 @@ export function getSnapshotDiff(current, after) {
             }),
             ...after.relations
                 .filter((afterRelation) => {
-                const currentRelation = current.relations.find((currentRelation) => currentRelation.collection === afterRelation.collection &&
-                    afterRelation.field === currentRelation.field);
+                const currentRelation = current.relations.find((currentRelation) => currentRelation.collection === afterRelation.collection && afterRelation.field === currentRelation.field);
                 return !!currentRelation === false;
             })
                 .map((afterRelation) => ({
@@ -65,7 +63,7 @@ export function getSnapshotDiff(current, after) {
                 related_collection: afterRelation.related_collection,
                 diff: deepDiff.diff(undefined, sanitizeRelation(afterRelation)),
             })),
-        ].filter((obj) => Array.isArray(obj.diff)), ['collection']),
+        ].filter((obj) => Array.isArray(obj.diff)),
     };
     /**
      * When you delete a collection, we don't have to individually drop all the fields/relations as well

package/dist/utils/get-snapshot.js

@@ -19,11 +19,11 @@ export async function getSnapshot(options) {
         relationsService.readAll(),
     ]);
     const collectionsFiltered = collectionsRaw.filter((item) => excludeSystem(item));
-    const fieldsFiltered = fieldsRaw.filter((item) => excludeSystem(item)).map(omitID);
-    const relationsFiltered = relationsRaw.filter((item) => excludeSystem(item)).map(omitID);
+    const fieldsFiltered = fieldsRaw.filter((item) => excludeSystem(item));
+    const relationsFiltered = relationsRaw.filter((item) => excludeSystem(item));
     const collectionsSorted = sortBy(mapValues(collectionsFiltered, sortDeep), ['collection']);
-    const fieldsSorted = sortBy(mapValues(fieldsFiltered, sortDeep), ['collection', 'field']);
-    const relationsSorted = sortBy(mapValues(relationsFiltered, sortDeep), ['collection', 'field']);
+    const fieldsSorted = sortBy(mapValues(fieldsFiltered, sortDeep), ['collection', 'meta.id']).map(omitID);
+    const relationsSorted = sortBy(mapValues(relationsFiltered, sortDeep), ['collection', 'meta.id']).map(omitID);
     return {
         version: 1,
         directus: version,

package/dist/utils/ip-in-networks.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks if an IP address is contained in a list of networks
+ * @param networks List of IP addresses (192.168.0.1), CIDR notations (192.168.0.0/24) or IP ranges (192-168.0.0-192.168.2.0)
+ * @throws Will throw if list contains invalid network definitions
+ */
+export declare function ipInNetworks(ip: string, networks: string[]): boolean;

package/dist/utils/ip-in-networks.js

@@ -0,0 +1,13 @@
+import { matches } from 'ip-matching';
+/**
+ * Checks if an IP address is contained in a list of networks
+ * @param networks List of IP addresses (192.168.0.1), CIDR notations (192.168.0.0/24) or IP ranges (192-168.0.0-192.168.2.0)
+ * @throws Will throw if list contains invalid network definitions
+ */
+export function ipInNetworks(ip, networks) {
+    for (const allowedIp of networks) {
+        if (matches(ip, allowedIp))
+            return true;
+    }
+    return false;
+}

package/dist/utils/is-url-allowed.js

@@ -1,10 +1,11 @@
 import { toArray } from '@directus/utils';
-import logger from '../logger.js';
 import { URL } from 'url';
+import { useLogger } from '../logger.js';
 /**
  * Check if url matches allow list either exactly or by domain+path
  */
 export default function isUrlAllowed(url, allowList) {
+    const logger = useLogger();
     const urlAllowList = toArray(allowList);
     if (urlAllowList.includes(url))
         return true;

package/dist/utils/job-queue.d.ts

@@ -5,4 +5,5 @@ export declare class JobQueue {
     constructor();
     enqueue(job: PromiseCallback): void;
     private run;
+    get size(): number;
 }

package/dist/utils/job-queue.js

@@ -19,4 +19,7 @@ export class JobQueue {
         }
         this.running = false;
     }
+    get size() {
+        return this.jobs.length;
+    }
 }

package/dist/utils/sanitize-query.js

@@ -1,9 +1,10 @@
+import { useEnv } from '@directus/env';
 import { parseFilter, parseJSON } from '@directus/utils';
 import { flatten, get, isPlainObject, merge, set } from 'lodash-es';
-import env from '../env.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { Meta } from '../types/index.js';
 export function sanitizeQuery(rawQuery, accountability) {
+    const env = useEnv();
     const query = {};
     const hasMaxLimit = 'QUERY_LIMIT_MAX' in env &&
         Number(env['QUERY_LIMIT_MAX']) >= 0 &&
@@ -84,6 +85,7 @@ function sanitizeSort(rawSort) {
     return fields;
 }
 function sanitizeAggregate(rawAggregate) {
+    const logger = useLogger();
     let aggregate = rawAggregate;
     if (typeof rawAggregate === 'string') {
         try {
@@ -102,6 +104,7 @@ function sanitizeAggregate(rawAggregate) {
     return aggregate;
 }
 function sanitizeFilter(rawFilter, accountability) {
+    const logger = useLogger();
     let filters = rawFilter;
     if (typeof rawFilter === 'string') {
         try {
@@ -137,6 +140,7 @@ function sanitizeMeta(rawMeta) {
     return [rawMeta];
 }
 function sanitizeDeep(deep, accountability) {
+    const logger = useLogger();
     const result = {};
     if (typeof deep === 'string') {
         try {
@@ -175,6 +179,7 @@ function sanitizeDeep(deep, accountability) {
     }
 }
 function sanitizeAlias(rawAlias) {
+    const logger = useLogger();
     let alias = rawAlias;
     if (typeof rawAlias === 'string') {
         try {

package/dist/utils/sanitize-schema.d.ts

@@ -16,7 +16,7 @@ export declare function sanitizeCollection(collection: Collection | undefined):
  * @returns sanitized field
  */
 export declare function sanitizeField(field: Field | undefined, sanitizeAllSchema?: boolean): Partial<Field> | undefined;
-export declare function sanitizeColumn(column: Column): Pick<Column, "table" | "name" | "numeric_precision" | "numeric_scale" | "data_type" | "default_value" | "max_length" | "is_nullable" | "is_unique" | "is_primary_key" | "is_generated" | "generation_expression" | "has_auto_increment" | "foreign_key_table" | "foreign_key_column">;
+export declare function sanitizeColumn(column: Column): Pick<Column, "name" | "table" | "numeric_precision" | "numeric_scale" | "data_type" | "default_value" | "max_length" | "is_nullable" | "is_unique" | "is_primary_key" | "is_generated" | "generation_expression" | "has_auto_increment" | "foreign_key_table" | "foreign_key_column">;
 /**
  * Pick certain database vendor specific relation properties that should be compared when performing diff
  *

package/dist/utils/should-clear-cache.js

@@ -1,4 +1,4 @@
-import env from '../env.js';
+import { useEnv } from '@directus/env';
 /**
  * Check whether cache should be cleared
  *
@@ -7,6 +7,7 @@ import env from '../env.js';
  * @param collection Collection name to check if cache purging should be ignored
  */
 export function shouldClearCache(cache, opts, collection) {
+    const env = useEnv();
     if (env['CACHE_AUTO_PURGE']) {
         if (collection && env['CACHE_AUTO_PURGE_IGNORE_LIST'].includes(collection)) {
             return false;

package/dist/utils/should-skip-cache.js

@@ -1,6 +1,6 @@
+import { useEnv } from '@directus/env';
 import { getEndpoint } from '@directus/utils';
 import url from 'url';
-import env from '../env.js';
 import { Url } from './url.js';
 /**
  * Whether to skip caching for the current request
@@ -8,6 +8,7 @@ import { Url } from './url.js';
  * @param req Express request object
  */
 export function shouldSkipCache(req) {
+    const env = useEnv();
     // Always skip cache for requests coming from the data studio based on Referer header
     const referer = req.get('Referer');
     if (referer) {

package/dist/utils/transformations.js

@@ -1,3 +1,4 @@
+import { clamp } from 'lodash-es';
 export function resolvePreset({ transformationParams, acceptFormat }, file) {
     const transforms = transformationParams.transforms ? [...transformationParams.transforms] : [];
     if (transformationParams.format || transformationParams.quality) {
@@ -9,18 +10,54 @@ export function resolvePreset({ transformationParams, acceptFormat }, file) {
             },
         ]);
     }
-    if (transformationParams.width || transformationParams.height) {
-        transforms.push([
-            'resize',
-            {
-                width: transformationParams.width ? Number(transformationParams.width) : undefined,
-                height: transformationParams.height ? Number(transformationParams.height) : undefined,
-                fit: transformationParams.fit,
-                withoutEnlargement: transformationParams.withoutEnlargement
-                    ? Boolean(transformationParams.withoutEnlargement)
-                    : undefined,
-            },
-        ]);
+    if ((transformationParams.width || transformationParams.height) && file.width && file.height) {
+        const toWidth = transformationParams.width ? Number(transformationParams.width) : undefined;
+        const toHeight = transformationParams.height ? Number(transformationParams.height) : undefined;
+        const toFocalPointX = transformationParams.focal_point_x
+            ? Number(transformationParams.focal_point_x)
+            : file.focal_point_x;
+        const toFocalPointY = transformationParams.focal_point_y
+            ? Number(transformationParams.focal_point_y)
+            : file.focal_point_y;
+        /*
+         * Focal point cropping only works with a fixed size (width x height) when `cover`ing,
+         * since the other modes show the whole image. Sharp by default also simply scales up/down
+         * when only supplied with one dimension, so we **must** check, else we break existing behaviour.
+         * See: https://sharp.pixelplumbing.com/api-resize#resize
+         * Also only crop to focal point when explicitly defined so that users can still `cover` with
+         * other parameters like `position` and `gravity` - Else fall back to regular behaviour
+         */
+        if ((transformationParams.fit === undefined || transformationParams.fit === 'cover') &&
+            toWidth &&
+            toHeight &&
+            toFocalPointX !== null &&
+            toFocalPointY !== null) {
+            const transformArgs = getResizeArguments({ w: file.width, h: file.height }, { w: toWidth, h: toHeight }, { x: toFocalPointX, y: toFocalPointY });
+            transforms.push([
+                'resize',
+                {
+                    width: transformArgs.width,
+                    height: transformArgs.height,
+                    fit: transformationParams.fit,
+                    withoutEnlargement: transformationParams.withoutEnlargement
+                        ? Boolean(transformationParams.withoutEnlargement)
+                        : undefined,
+                },
+            ], ['extract', transformArgs.region]);
+        }
+        else {
+            transforms.push([
+                'resize',
+                {
+                    width: toWidth,
+                    height: toHeight,
+                    fit: transformationParams.fit,
+                    withoutEnlargement: transformationParams.withoutEnlargement
+                        ? Boolean(transformationParams.withoutEnlargement)
+                        : undefined,
+                },
+            ]);
+        }
     }
     return transforms;
 }
@@ -47,3 +84,49 @@ export function maybeExtractFormat(transforms) {
     const lastToFormat = toFormats[toFormats.length - 1];
     return lastToFormat ? lastToFormat[1]?.toString() : undefined;
 }
+/**
+ * Resize an image but keep it centered on the focal point.
+ * Based on the method outlined in https://github.com/lovell/sharp/issues/1198#issuecomment-384591756
+ */
+function getResizeArguments(original, target, focalPoint) {
+    const { width, height, factor } = getIntermediateDimensions(original, target);
+    const region = getExtractionRegion(factor, focalPoint ?? { x: original.w / 2, y: original.h / 2 }, target, {
+        w: width,
+        h: height,
+    });
+    return { width, height, region };
+}
+/**
+ * Calculates the dimensions of the intermediate (resized) image.
+ */
+function getIntermediateDimensions(original, target) {
+    const hRatio = original.h / target.h;
+    const wRatio = original.w / target.w;
+    let factor;
+    let width;
+    let height;
+    if (hRatio < wRatio) {
+        factor = hRatio;
+        height = Math.round(target.h);
+        width = Math.round(original.w / factor);
+    }
+    else {
+        factor = wRatio;
+        width = Math.round(target.w);
+        height = Math.round(original.h / factor);
+    }
+    return { width, height, factor };
+}
+/**
+ * Calculates the Region to extract from the intermediate image.
+ */
+function getExtractionRegion(factor, focalPoint, target, intermediate) {
+    const newXCenter = focalPoint.x / factor;
+    const newYCenter = focalPoint.y / factor;
+    return {
+        left: clamp(Math.round(newXCenter - target.w / 2), 0, intermediate.w - target.w),
+        top: clamp(Math.round(newYCenter - target.h / 2), 0, intermediate.h - target.h),
+        width: target.w,
+        height: target.h,
+    };
+}

package/dist/utils/validate-env.js

@@ -1,6 +1,8 @@
-import env from '../env.js';
-import logger from '../logger.js';
+import { useEnv } from '@directus/env';
+import { useLogger } from '../logger.js';
 export function validateEnv(requiredKeys) {
+    const env = useEnv();
+    const logger = useLogger();
     for (const requiredKey of requiredKeys) {
         if (requiredKey in env === false) {
             logger.error(`"${requiredKey}" Environment Variable is missing.`);

package/dist/utils/validate-query.js

@@ -1,16 +1,20 @@
+import { useEnv } from '@directus/env';
+import { InvalidQueryError } from '@directus/errors';
 import Joi from 'joi';
 import { isPlainObject, uniq } from 'lodash-es';
 import { stringify } from 'wellknown';
-import env from '../env.js';
-import { InvalidQueryError } from '@directus/errors';
 import { calculateFieldDepth } from './calculate-field-depth.js';
+const env = useEnv();
 const querySchema = Joi.object({
     fields: Joi.array().items(Joi.string()),
     group: Joi.array().items(Joi.string()),
     sort: Joi.array().items(Joi.string()),
     filter: Joi.object({}).unknown(),
     limit: 'QUERY_LIMIT_MAX' in env && env['QUERY_LIMIT_MAX'] !== -1
-        ? Joi.number().integer().min(-1).max(env['QUERY_LIMIT_MAX']) // min should be 0
+        ? Joi.number()
+            .integer()
+            .min(-1)
+            .max(env['QUERY_LIMIT_MAX']) // min should be 0
         : Joi.number().integer().min(-1),
     offset: Joi.number().integer().min(0),
     page: Joi.number().integer().min(0),

package/dist/utils/validate-storage.js

@@ -1,11 +1,13 @@
+import { useEnv } from '@directus/env';
 import { toArray } from '@directus/utils';
 import { constants } from 'fs';
 import { access } from 'node:fs/promises';
 import path from 'path';
-import env from '../env.js';
 import { getExtensionsPath } from '../extensions/lib/get-extensions-path.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 export async function validateStorage() {
+    const env = useEnv();
+    const logger = useLogger();
     if (env['DB_CLIENT'] === 'sqlite3') {
         try {
             await access(path.dirname(env['DB_FILENAME']), constants.R_OK | constants.W_OK);