@directus/api 15.0.0 → 16.0.0

package/dist/services/versions.js

@@ -172,26 +172,27 @@ export class VersionsService extends ItemsService {
             knex: this.knex,
             schema: this.schema,
         });
+        const { item, collection } = version;
         const activity = await activityService.createOne({
             action: Action.VERSION_SAVE,
             user: this.accountability?.user ?? null,
-            collection: version['collection'],
+            collection,
             ip: this.accountability?.ip ?? null,
             user_agent: this.accountability?.userAgent ?? null,
             origin: this.accountability?.origin ?? null,
-            item: version['item'],
+            item,
         });
         const revisionDelta = await payloadService.prepareDelta(data);
         await revisionsService.createOne({
             activity,
             version: key,
-            collection: version['collection'],
-            item: version['item'],
+            collection,
+            item,
             data: revisionDelta,
             delta: revisionDelta,
         });
         const { cache } = getCache();
-        if (shouldClearCache(cache, undefined, version['collection'])) {
+        if (shouldClearCache(cache, undefined, collection)) {
             cache.clear();
         }
         return data;

package/dist/services/webhooks.d.ts

@@ -1,8 +1,8 @@
-import type { Messenger } from '../messenger.js';
+import type { Bus } from '@directus/memory';
 import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey, Webhook } from '../types/index.js';
 import { ItemsService } from './items.js';
 export declare class WebhooksService extends ItemsService<Webhook> {
-    messenger: Messenger;
+    messenger: Bus;
     constructor(options: AbstractServiceOptions);
     createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
     createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;

package/dist/services/webhooks.js

@@ -1,10 +1,10 @@
-import { getMessenger } from '../messenger.js';
+import { useBus } from '../bus/index.js';
 import { ItemsService } from './items.js';
 export class WebhooksService extends ItemsService {
     messenger;
     constructor(options) {
         super('directus_webhooks', options);
-        this.messenger = getMessenger();
+        this.messenger = useBus();
     }
     async createOne(data, opts) {
         const result = await super.createOne(data, opts);

package/dist/services/websocket.d.ts

@@ -1,6 +1,6 @@
 import type { ActionHandler } from '@directus/types';
-import type { WebSocketClient } from '../websocket/types.js';
 import type { WebSocketMessage } from '../websocket/messages.js';
+import type { WebSocketClient } from '../websocket/types.js';
 export declare class WebSocketService {
     private controller;
     constructor();

package/dist/services/websocket.js

@@ -1,8 +1,9 @@
-import { getWebSocketController } from '../websocket/controllers/index.js';
+import { useEnv } from '@directus/env';
 import { ServiceUnavailableError } from '@directus/errors';
-import { toBoolean } from '../utils/to-boolean.js';
+import { toBoolean } from '@directus/utils';
 import emitter from '../emitter.js';
-import env from '../env.js';
+import { getWebSocketController } from '../websocket/controllers/index.js';
+const env = useEnv();
 export class WebSocketService {
     controller;
     constructor() {

package/dist/storage/register-drivers.js

@@ -1,6 +1,7 @@
-import env from '../env.js';
+import { useEnv } from '@directus/env';
 import { getStorageDriver } from './get-storage-driver.js';
 export const registerDrivers = async (storage) => {
+    const env = useEnv();
     const usedDrivers = [];
     for (const [key, value] of Object.entries(env)) {
         if ((key.startsWith('STORAGE_') && key.endsWith('_DRIVER')) === false)

package/dist/storage/register-locations.js

@@ -1,7 +1,8 @@
+import { useEnv } from '@directus/env';
 import { toArray } from '@directus/utils';
-import env from '../env.js';
 import { getConfigFromEnv } from '../utils/get-config-from-env.js';
 export const registerLocations = async (storage) => {
+    const env = useEnv();
     const locations = toArray(env['STORAGE_LOCATIONS']);
     locations.forEach((location) => {
         location = location.trim();

package/dist/synchronization.js

@@ -1,10 +1,11 @@
+import { useEnv } from '@directus/env';
 import { Redis } from 'ioredis';
-import env from './env.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 let synchronizationManager;
 function getSynchronizationManager() {
     if (synchronizationManager)
         return synchronizationManager;
+    const env = useEnv();
     if (env['SYNCHRONIZATION_STORE'] === 'redis') {
         synchronizationManager = new SynchronizationManagerRedis();
     }
@@ -73,6 +74,7 @@ class SynchronizationManagerRedis {
     namespace;
     client;
     constructor() {
+        const env = useEnv();
         const config = getConfigFromEnv('REDIS');
         this.client = new Redis(env['REDIS'] ?? config);
         this.namespace = env['SYNCHRONIZATION_NAMESPACE'] ?? 'directus-sync';

package/dist/telemetry/lib/get-report.js

@@ -1,6 +1,6 @@
+import { useEnv } from '@directus/env';
 import { version } from 'directus/version';
 import { getDatabase, getDatabaseClient } from '../../database/index.js';
-import { useEnv } from '../../env.js';
 import { getItemCount } from '../utils/get-item-count.js';
 import { getUserCount } from '../utils/get-user-count.js';
 import { getUserItemCount } from '../utils/get-user-item-count.js';

package/dist/telemetry/lib/init-telemetry.js

@@ -1,7 +1,7 @@
+import { useEnv } from '@directus/env';
+import { toBoolean } from '@directus/utils';
 import { getCache } from '../../cache.js';
-import { useEnv } from '../../env.js';
 import { scheduleSynchronizedJob } from '../../utils/schedule.js';
-import { toBoolean } from '../../utils/to-boolean.js';
 import { track } from './track.js';
 /**
  * Exported to be able to test the anonymous callback function

package/dist/telemetry/lib/send-report.js

@@ -1,5 +1,5 @@
+import { useEnv } from '@directus/env';
 import { URL } from 'node:url';
-import { useEnv } from '../../env.js';
 /**
  * Post an anonymous usage report to the centralized intake server
  */

package/dist/telemetry/lib/track.js

@@ -1,5 +1,5 @@
+import { getNodeEnv } from '@directus/utils/node';
 import { setTimeout } from 'timers/promises';
-import { useEnv } from '../../env.js';
 import { useLogger } from '../../logger.js';
 import { getRandomWaitTime } from '../utils/get-random-wait-time.js';
 import { getReport } from './get-report.js';
@@ -12,7 +12,6 @@ import { sendReport } from './send-report.js';
  * @returns whether or not the tracking was successful
  */
 export const track = async (opts = { wait: true }) => {
-    const env = useEnv();
     const logger = useLogger();
     if (opts.wait) {
         await setTimeout(getRandomWaitTime());
@@ -23,7 +22,7 @@ export const track = async (opts = { wait: true }) => {
         return true;
     }
     catch (err) {
-        if (env['NODE_ENV'] === 'development') {
+        if (getNodeEnv() === 'development') {
             logger.error(err);
         }
         return false;

package/dist/telemetry/utils/get-user-count.js

@@ -1,5 +1,5 @@
+import { toBoolean } from '@directus/utils';
 import {} from 'knex';
-import { toBoolean } from '../../utils/to-boolean.js';
 export const getUserCount = async (db) => {
     const counts = {
         admin: 0,

package/dist/types/assets.d.ts

@@ -12,6 +12,8 @@ export type TransformationParams = {
     transforms?: Transformation[];
     format?: TransformationFormat | 'auto';
     quality?: number;
+    focal_point_x?: number;
+    focal_point_y?: number;
 } & TransformationResize;
 export type TransformationSet = {
     transformationParams: TransformationParams;

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) {