@directus/api 14.1.2 → 16.0.0

package/dist/cli/commands/schema/apply.js

@@ -5,13 +5,14 @@ import inquirer from 'inquirer';
 import { load as loadYaml } from 'js-yaml';
 import path from 'path';
 import getDatabase, { isInstalled, validateDatabaseConnection } from '../../../database/index.js';
-import logger from '../../../logger.js';
+import { useLogger } from '../../../logger.js';
 import { DiffKind } from '../../../types/index.js';
 import { isNestedMetaUpdate } from '../../../utils/apply-diff.js';
 import { applySnapshot } from '../../../utils/apply-snapshot.js';
 import { getSnapshotDiff } from '../../../utils/get-snapshot-diff.js';
 import { getSnapshot } from '../../../utils/get-snapshot.js';
 export async function apply(snapshotPath, options) {
+    const logger = useLogger();
     const filename = path.resolve(process.cwd(), snapshotPath);
     const database = getDatabase();
     await validateDatabaseConnection(database);
@@ -41,92 +42,90 @@ export async function apply(snapshotPath, options) {
         const dryRun = options?.dryRun === true;
         const promptForChanges = !dryRun && options?.yes !== true;
         if (dryRun || promptForChanges) {
-            let message = '';
+            const sections = [];
             if (snapshotDiff.collections.length > 0) {
-                message += chalk.black.underline.bold('Collections:');
+                const lines = [chalk.underline.bold('Collections:')];
                 for (const { collection, diff } of snapshotDiff.collections) {
                     if (diff[0]?.kind === DiffKind.EDIT) {
-                        message += `\n  - ${chalk.blue('Update')} ${collection}`;
+                        lines.push(`  - ${chalk.magenta('Update')} ${collection}`);
                         for (const change of diff) {
                             if (change.kind === DiffKind.EDIT) {
-                                const path = change.path.slice(1).join('.');
-                                message += `\n    - Set ${path} to ${change.rhs}`;
+                                const path = formatPath(change.path);
+                                lines.push(`    - Set ${path} to ${change.rhs}`);
                             }
                         }
                     }
                     else if (diff[0]?.kind === DiffKind.DELETE) {
-                        message += `\n  - ${chalk.red('Delete')} ${collection}`;
+                        lines.push(`  - ${chalk.red('Delete')} ${collection}`);
                     }
                     else if (diff[0]?.kind === DiffKind.NEW) {
-                        message += `\n  - ${chalk.green('Create')} ${collection}`;
+                        lines.push(`  - ${chalk.green('Create')} ${collection}`);
                     }
                     else if (diff[0]?.kind === DiffKind.ARRAY) {
-                        message += `\n  - ${chalk.blue('Update')} ${collection}`;
+                        lines.push(`  - ${chalk.magenta('Update')} ${collection}`);
                     }
                 }
+                sections.push(lines.join('\n'));
             }
             if (snapshotDiff.fields.length > 0) {
-                message += '\n\n' + chalk.black.underline.bold('Fields:');
+                const lines = [chalk.underline.bold('Fields:')];
                 for (const { collection, field, diff } of snapshotDiff.fields) {
                     if (diff[0]?.kind === DiffKind.EDIT || isNestedMetaUpdate(diff[0])) {
-                        message += `\n  - ${chalk.blue('Update')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.magenta('Update')} ${collection}.${field}`);
                         for (const change of diff) {
-                            const path = change.path.slice(1).join('.');
+                            const path = formatPath(change.path);
                             if (change.kind === DiffKind.EDIT) {
-                                message += `\n    - Set ${path} to ${change.rhs}`;
+                                lines.push(`    - Set ${path} to ${change.rhs}`);
                             }
                             else if (change.kind === DiffKind.DELETE) {
-                                message += `\n    - Remove ${path}`;
+                                lines.push(`    - Remove ${path}`);
                             }
                             else if (change.kind === DiffKind.NEW) {
-                                message += `\n    - Add ${path} and set it to ${change.rhs}`;
+                                lines.push(`    - Add ${path} and set it to ${change.rhs}`);
                             }
                         }
                     }
                     else if (diff[0]?.kind === DiffKind.DELETE) {
-                        message += `\n  - ${chalk.red('Delete')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.red('Delete')} ${collection}.${field}`);
                     }
                     else if (diff[0]?.kind === DiffKind.NEW) {
-                        message += `\n  - ${chalk.green('Create')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.green('Create')} ${collection}.${field}`);
                     }
                     else if (diff[0]?.kind === DiffKind.ARRAY) {
-                        message += `\n  - ${chalk.blue('Update')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.magenta('Update')} ${collection}.${field}`);
                     }
                 }
+                sections.push(lines.join('\n'));
             }
             if (snapshotDiff.relations.length > 0) {
-                message += '\n\n' + chalk.black.underline.bold('Relations:');
+                const lines = [chalk.underline.bold('Relations:')];
                 for (const { collection, field, related_collection, diff } of snapshotDiff.relations) {
+                    const relatedCollection = formatRelatedCollection(related_collection);
                     if (diff[0]?.kind === DiffKind.EDIT) {
-                        message += `\n  - ${chalk.blue('Update')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.magenta('Update')} ${collection}.${field}${relatedCollection}`);
                         for (const change of diff) {
                             if (change.kind === DiffKind.EDIT) {
-                                const path = change.path.slice(1).join('.');
-                                message += `\n    - Set ${path} to ${change.rhs}`;
+                                const path = formatPath(change.path);
+                                lines.push(`    - Set ${path} to ${change.rhs}`);
                             }
                         }
                     }
                     else if (diff[0]?.kind === DiffKind.DELETE) {
-                        message += `\n  - ${chalk.red('Delete')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.red('Delete')} ${collection}.${field}${relatedCollection}`);
                     }
                     else if (diff[0]?.kind === DiffKind.NEW) {
-                        message += `\n  - ${chalk.green('Create')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.green('Create')} ${collection}.${field}${relatedCollection}`);
                     }
                     else if (diff[0]?.kind === DiffKind.ARRAY) {
-                        message += `\n  - ${chalk.blue('Update')} ${collection}.${field}`;
-                    }
-                    else {
-                        continue;
-                    }
-                    // Related collection doesn't exist for a2o relationship types
-                    if (related_collection) {
-                        message += `-> ${related_collection}`;
+                        lines.push(`  - ${chalk.magenta('Update')} ${collection}.${field}${relatedCollection}`);
                     }
                 }
+                sections.push(lines.join('\n'));
             }
-            message = 'The following changes will be applied:\n\n' + chalk.black(message);
+            const message = 'The following changes will be applied:\n\n' + sections.join('\n\n');
             if (dryRun) {
-                logger.info(message);
+                // eslint-disable-next-line no-console
+                console.log(message);
                 process.exit(0);
             }
             const { proceed } = await inquirer.prompt([
@@ -151,3 +150,16 @@ export async function apply(snapshotPath, options) {
         process.exit(1);
     }
 }
+function formatPath(path) {
+    if (path.length === 1) {
+        return path.toString();
+    }
+    return path.slice(1).join('.');
+}
+function formatRelatedCollection(relatedCollection) {
+    // Related collection doesn't exist for a2o relationship types
+    if (relatedCollection) {
+        return ` → ${relatedCollection}`;
+    }
+    return '';
+}

package/dist/cli/commands/schema/snapshot.js

@@ -1,12 +1,13 @@
-import getDatabase from '../../../database/index.js';
-import logger from '../../../logger.js';
-import { getSnapshot } from '../../../utils/get-snapshot.js';
-import { constants as fsConstants, promises as fs } from 'fs';
-import path from 'path';
+import { promises as fs, constants as fsConstants } from 'fs';
 import inquirer from 'inquirer';
 import { dump as toYaml } from 'js-yaml';
+import path from 'path';
+import getDatabase from '../../../database/index.js';
+import { useLogger } from '../../../logger.js';
+import { getSnapshot } from '../../../utils/get-snapshot.js';
 export async function snapshot(snapshotPath, options) {
     const database = getDatabase();
+    const logger = useLogger();
     try {
         const snapshot = await getSnapshot({ database });
         let snapshotString;

package/dist/cli/commands/users/create.js

@@ -1,9 +1,10 @@
-import { getSchema } from '../../../utils/get-schema.js';
-import { UsersService } from '../../../services/users.js';
 import getDatabase from '../../../database/index.js';
-import logger from '../../../logger.js';
+import { useLogger } from '../../../logger.js';
+import { UsersService } from '../../../services/users.js';
+import { getSchema } from '../../../utils/get-schema.js';
 export default async function usersCreate({ email, password, role, }) {
     const database = getDatabase();
+    const logger = useLogger();
     if (!email || !password || !role) {
         logger.error('Email, password, role are required');
         process.exit(1);

package/dist/cli/commands/users/passwd.js

@@ -1,10 +1,11 @@
-import { getSchema } from '../../../utils/get-schema.js';
-import { generateHash } from '../../../utils/generate-hash.js';
-import { UsersService } from '../../../services/users.js';
 import getDatabase from '../../../database/index.js';
-import logger from '../../../logger.js';
+import { useLogger } from '../../../logger.js';
+import { UsersService } from '../../../services/users.js';
+import { generateHash } from '../../../utils/generate-hash.js';
+import { getSchema } from '../../../utils/get-schema.js';
 export default async function usersPasswd({ email, password }) {
     const database = getDatabase();
+    const logger = useLogger();
     if (!email || !password) {
         logger.error('Email and password are required');
         process.exit(1);

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 import { Command, Option } from 'commander';
+import { version } from 'directus/version';
 import emitter from '../emitter.js';
 import { startServer } from '../server.js';
-import * as pkg from '../utils/package.js';
 import bootstrap from './commands/bootstrap/index.js';
 import count from './commands/count/index.js';
 import dbInstall from './commands/database/install.js';
@@ -20,7 +20,7 @@ export async function createCli() {
     await loadExtensions();
     await emitter.emitInit('cli.before', { program });
     program.name('directus').usage('[command] [options]');
-    program.version(pkg.version, '-v, --version');
+    program.version(version, '-v, --version');
     program.command('start').description('Start the Directus API').action(startServer);
     program.command('init').description('Create a new Directus Project').action(init);
     // Security

package/dist/cli/load-extensions.js

@@ -1,8 +1,10 @@
+import { useEnv } from '@directus/env';
 import { isInstalled, validateMigrations } from '../database/index.js';
-import env from '../env.js';
 import { getExtensionManager } from '../extensions/index.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 export const loadExtensions = async () => {
+    const env = useEnv();
+    const logger = useLogger();
     if (!('DB_CLIENT' in env))
         return;
     const installed = await isInstalled();

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

@@ -187,7 +187,7 @@ STORAGE_LOCAL_ROOT="./uploads"
 
 ## A comma-separated list of metadata keys to collect during file upload. Use * for all
 # Extracting all metadata might cause memory issues when the file has an unusually large set of metadata
-# [ifd0.Make,ifd0.Model,exif.FNumber,exif.ExposureTime,exif.FocalLength,exif.ISO]
+# [ifd0.Make,ifd0.Model,exif.FNumber,exif.ExposureTime,exif.FocalLength,exif.ISOSpeedRatings]
 # FILE_METADATA_ALLOW_LIST=
 
 ####################################################################################################

package/dist/constants.d.ts

@@ -1,7 +1,7 @@
 import type { CookieOptions } from 'express';
 import type { TransformationParams } from './types/index.js';
 export declare const SYSTEM_ASSET_ALLOW_LIST: TransformationParams[];
-export declare const ASSET_TRANSFORM_QUERY_KEYS: Array<keyof TransformationParams>;
+export declare const ASSET_TRANSFORM_QUERY_KEYS: readonly ["key", "transforms", "width", "height", "format", "fit", "quality", "withoutEnlargement", "focal_point_x", "focal_point_y"];
 export declare const FILTER_VARIABLES: string[];
 export declare const ALIAS_TYPES: string[];
 export declare const DEFAULT_AUTH_PROVIDER = "default";

package/dist/constants.js

@@ -1,5 +1,6 @@
-import env from './env.js';
+import { useEnv } from '@directus/env';
 import { getMilliseconds } from './utils/get-milliseconds.js';
+const env = useEnv();
 export const SYSTEM_ASSET_ALLOW_LIST = [
     {
         key: 'system-small-cover',
@@ -41,6 +42,8 @@ export const ASSET_TRANSFORM_QUERY_KEYS = [
     'fit',
     'quality',
     'withoutEnlargement',
+    'focal_point_x',
+    'focal_point_y',
 ];
 export const FILTER_VARIABLES = ['$NOW', '$CURRENT_USER', '$CURRENT_ROLE'];
 export const ALIAS_TYPES = ['alias', 'o2m', 'm2m', 'm2a', 'o2a', 'files', 'translations'];

package/dist/controllers/assets.js

@@ -1,12 +1,12 @@
+import { useEnv } from '@directus/env';
+import { InvalidQueryError, RangeNotSatisfiableError } from '@directus/errors';
 import { parseJSON } from '@directus/utils';
 import contentDisposition from 'content-disposition';
 import { Router } from 'express';
 import { merge, pick } from 'lodash-es';
 import { ASSET_TRANSFORM_QUERY_KEYS, SYSTEM_ASSET_ALLOW_LIST } from '../constants.js';
 import getDatabase from '../database/index.js';
-import env from '../env.js';
-import { InvalidQueryError, RangeNotSatisfiableError } from '@directus/errors';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import useCollection from '../middleware/use-collection.js';
 import { AssetsService } from '../services/assets.js';
 import { PayloadService } from '../services/payload.js';
@@ -16,6 +16,7 @@ import { getCacheControlHeader } from '../utils/get-cache-headers.js';
 import { getConfigFromEnv } from '../utils/get-config-from-env.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 const router = Router();
+const env = useEnv();
 router.use(useCollection('directus_files'));
 router.get('/:pk/:filename?', 
 // Validate query params
@@ -109,6 +110,7 @@ asyncHandler(async (req, res, next) => {
 }), 
 // Return file
 asyncHandler(async (req, res) => {
+    const logger = useLogger();
     const id = req.params['pk'].substring(0, 36);
     const service = new AssetsService({
         accountability: req.accountability,

package/dist/controllers/auth.js

@@ -1,10 +1,9 @@
-import { isDirectusError } from '@directus/errors';
+import { useEnv } from '@directus/env';
+import { ErrorCode, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import { Router } from 'express';
 import { createLDAPAuthRouter, createLocalAuthRouter, createOAuth2AuthRouter, createOpenIDAuthRouter, createSAMLAuthRouter, } from '../auth/drivers/index.js';
 import { COOKIE_OPTIONS, DEFAULT_AUTH_PROVIDER } from '../constants.js';
-import env from '../env.js';
-import { ErrorCode, InvalidPayloadError } from '@directus/errors';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { respond } from '../middleware/respond.js';
 import { AuthenticationService } from '../services/authentication.js';
 import { UsersService } from '../services/users.js';
@@ -12,6 +11,8 @@ import asyncHandler from '../utils/async-handler.js';
 import { getAuthProviders } from '../utils/get-auth-providers.js';
 import { getIPFromReq } from '../utils/get-ip-from-req.js';
 const router = Router();
+const env = useEnv();
+const logger = useLogger();
 const authProviders = getAuthProviders();
 for (const authProvider of authProviders) {
     let authRouter;

package/dist/controllers/extensions.js

@@ -1,14 +1,15 @@
-import { ForbiddenError, RouteNotFoundError } from '@directus/errors';
+import { useEnv } from '@directus/env';
+import { ErrorCode, ForbiddenError, RouteNotFoundError, isDirectusError } from '@directus/errors';
 import express from 'express';
-import env from '../env.js';
 import { getExtensionManager } from '../extensions/index.js';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
-import { ExtensionsService } from '../services/extensions.js';
+import { ExtensionReadError, ExtensionsService } from '../services/extensions.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getCacheControlHeader } from '../utils/get-cache-headers.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 const router = express.Router();
+const env = useEnv();
 router.use(useCollection('directus_extensions'));
 router.get('/', asyncHandler(async (req, res, next) => {
     const service = new ExtensionsService({
@@ -29,9 +30,20 @@ router.patch('/:bundleOrName/:name?', asyncHandler(async (req, res, next) => {
     if (bundle === undefined || !name) {
         throw new ForbiddenError();
     }
-    await service.updateOne(bundle, name, req.body);
-    const updated = await service.readOne(bundle, name);
-    res.locals['payload'] = { data: updated || null };
+    try {
+        const result = await service.updateOne(bundle, name, req.body);
+        res.locals['payload'] = { data: result || null };
+    }
+    catch (error) {
+        let finalError = error;
+        if (error instanceof ExtensionReadError) {
+            finalError = error.originalError;
+            if (isDirectusError(finalError, ErrorCode.Forbidden)) {
+                return next();
+            }
+        }
+        throw finalError;
+    }
     return next();
 }), respond);
 router.get('/sources/:chunk', asyncHandler(async (req, res) => {

package/dist/controllers/files.js

@@ -1,4 +1,5 @@
-import { isDirectusError } from '@directus/errors';
+import { useEnv } from '@directus/env';
+import { ErrorCode, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import formatTitle from '@directus/format-title';
 import { toArray } from '@directus/utils';
 import Busboy from 'busboy';
@@ -7,8 +8,6 @@ import express from 'express';
 import Joi from 'joi';
 import { minimatch } from 'minimatch';
 import path from 'path';
-import env from '../env.js';
-import { ErrorCode, InvalidPayloadError } from '@directus/errors';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
@@ -17,6 +16,7 @@ import { MetaService } from '../services/meta.js';
 import asyncHandler from '../utils/async-handler.js';
 import { sanitizeQuery } from '../utils/sanitize-query.js';
 const router = express.Router();
+const env = useEnv();
 router.use(useCollection('directus_files'));
 export const multipartHandler = (req, res, next) => {
     if (req.is('multipart/form-data') === false)

package/dist/controllers/schema.js

@@ -1,9 +1,9 @@
+import { InvalidPayloadError, UnsupportedMediaTypeError } from '@directus/errors';
 import { parseJSON } from '@directus/utils';
 import Busboy from 'busboy';
 import express from 'express';
 import { load as loadYaml } from 'js-yaml';
-import { InvalidPayloadError, UnsupportedMediaTypeError } from '@directus/errors';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { respond } from '../middleware/respond.js';
 import { SchemaService } from '../services/schema.js';
 import asyncHandler from '../utils/async-handler.js';
@@ -36,6 +36,7 @@ const schemaMultipartHandler = (req, res, next) => {
     let isFileIncluded = false;
     let upload = null;
     busboy.on('file', async (_, fileStream, { mimeType }) => {
+        const logger = useLogger();
         if (isFileIncluded)
             return next(new InvalidPayloadError({ reason: `More than one file was included in the body` }));
         isFileIncluded = true;

package/dist/controllers/shares.js

@@ -1,9 +1,8 @@
-import { isDirectusError } from '@directus/errors';
+import { useEnv } from '@directus/env';
+import { ErrorCode, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import express from 'express';
 import Joi from 'joi';
 import { COOKIE_OPTIONS, UUID_REGEX } from '../constants.js';
-import env from '../env.js';
-import { ErrorCode, InvalidPayloadError } from '@directus/errors';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
@@ -11,6 +10,7 @@ import { SharesService } from '../services/shares.js';
 import asyncHandler from '../utils/async-handler.js';
 import { sanitizeQuery } from '../utils/sanitize-query.js';
 const router = express.Router();
+const env = useEnv();
 router.use(useCollection('directus_shares'));
 const sharedLoginSchema = Joi.object({
     share: Joi.string().required(),

package/dist/database/helpers/index.d.ts

@@ -6,7 +6,7 @@ import * as geometryHelpers from './geometry/index.js';
 import * as schemaHelpers from './schema/index.js';
 import * as sequenceHelpers from './sequence/index.js';
 export declare function getHelpers(database: Knex): {
-    date: dateHelpers.mysql | dateHelpers.postgres | dateHelpers.mssql | dateHelpers.sqlite | dateHelpers.oracle;
+    date: dateHelpers.postgres | dateHelpers.oracle | dateHelpers.mysql | dateHelpers.mssql | dateHelpers.sqlite;
     st: geometryHelpers.mysql | geometryHelpers.postgres | geometryHelpers.mssql | geometryHelpers.sqlite | geometryHelpers.oracle | geometryHelpers.redshift;
     schema: schemaHelpers.mysql | schemaHelpers.cockroachdb | schemaHelpers.mssql | schemaHelpers.postgres | schemaHelpers.sqlite | schemaHelpers.oracle;
     sequence: sequenceHelpers.mysql | sequenceHelpers.postgres;

package/dist/database/index.d.ts

@@ -1,7 +1,8 @@
 import type { SchemaInspector } from '@directus/schema';
 import type { Knex } from 'knex';
 import type { DatabaseClient } from '../types/index.js';
-export default function getDatabase(): Knex;
+export default getDatabase;
+export declare function getDatabase(): Knex;
 export declare function getSchemaInspector(): SchemaInspector;
 /**
  * Get database version. Value currently exists for MySQL only.

package/dist/database/index.js

@@ -1,3 +1,4 @@
+import { useEnv } from '@directus/env';
 import { createInspector } from '@directus/schema';
 import fse from 'fs-extra';
 import knex from 'knex';
@@ -7,9 +8,8 @@ import { fileURLToPath } from 'node:url';
 import path from 'path';
 import { performance } from 'perf_hooks';
 import { promisify } from 'util';
-import env from '../env.js';
 import { getExtensionsPath } from '../extensions/lib/get-extensions-path.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { getConfigFromEnv } from '../utils/get-config-from-env.js';
 import { validateEnv } from '../utils/validate-env.js';
 import { getHelpers } from './helpers/index.js';
@@ -17,10 +17,13 @@ let database = null;
 let inspector = null;
 let databaseVersion = null;
 const __dirname = dirname(fileURLToPath(import.meta.url));
-export default function getDatabase() {
+export default getDatabase;
+export function getDatabase() {
     if (database) {
         return database;
     }
+    const env = useEnv();
+    const logger = useLogger();
     const { client, version, searchPath, connectionString, pool: poolConfig = {}, ...connectionConfig } = getConfigFromEnv('DB_', ['DB_EXCLUDE_TABLES']);
     const requiredEnvVars = ['DB_CLIENT'];
     switch (client) {
@@ -164,6 +167,7 @@ export async function hasDatabaseConnection(database) {
 }
 export async function validateDatabaseConnection(database) {
     database = database ?? getDatabase();
+    const logger = useLogger();
     try {
         if (getDatabaseClient(database) === 'oracle') {
             await database.raw('select 1 from DUAL');
@@ -208,6 +212,7 @@ export async function isInstalled() {
 }
 export async function validateMigrations() {
     const database = getDatabase();
+    const logger = useLogger();
     try {
         let migrationFiles = await fse.readdir(path.join(__dirname, 'migrations'));
         const customMigrationsPath = path.resolve(getExtensionsPath(), 'migrations');
@@ -233,6 +238,7 @@ export async function validateDatabaseExtensions() {
     const client = getDatabaseClient(database);
     const helpers = getHelpers(database);
     const geometrySupport = await helpers.st.supported();
+    const logger = useLogger();
     if (!geometrySupport) {
         switch (client) {
             case 'postgres':
@@ -247,7 +253,9 @@ export async function validateDatabaseExtensions() {
     }
 }
 async function validateDatabaseCharset(database) {
+    const env = useEnv();
     database = database ?? getDatabase();
+    const logger = useLogger();
     if (getDatabaseClient(database) === 'mysql') {
         const { collation } = await database.select(database.raw(`@@collation_database as collation`)).first();
         const tables = await database('information_schema.tables')

package/dist/database/migrations/20210518A-add-foreign-key-constraints.js

@@ -1,7 +1,8 @@
 import { createInspector } from '@directus/schema';
-import logger from '../../logger.js';
+import { useLogger } from '../../logger.js';
 import { getDefaultIndexName } from '../../utils/get-default-index-name.js';
 export async function up(knex) {
+    const logger = useLogger();
     const inspector = createInspector(knex);
     const foreignKeys = await inspector.foreignKeys();
     const relations = await knex
@@ -87,6 +88,7 @@ export async function up(knex) {
     }
 }
 export async function down(knex) {
+    const logger = useLogger();
     const relations = await knex
         .select('many_collection', 'many_field', 'one_collection')
         .from('directus_relations');

package/dist/database/migrations/20210519A-add-system-fk-triggers.js

@@ -1,5 +1,5 @@
 import { createInspector } from '@directus/schema';
-import logger from '../../logger.js';
+import { useLogger } from '../../logger.js';
 /**
  * Things to keep in mind:
  *
@@ -77,6 +77,7 @@ const updates = [
     },
 ];
 export async function up(knex) {
+    const logger = useLogger();
     const inspector = createInspector(knex);
     const foreignKeys = await inspector.foreignKeys();
     for (const update of updates) {
@@ -123,6 +124,7 @@ export async function up(knex) {
     }
 }
 export async function down(knex) {
+    const logger = useLogger();
     for (const update of updates) {
         for (const constraint of update.constraints) {
             try {

package/dist/database/migrations/20210802A-replace-groups.js

@@ -1,6 +1,7 @@
 import { parseJSON } from '@directus/utils';
-import logger from '../../logger.js';
+import { useLogger } from '../../logger.js';
 export async function up(knex) {
+    const logger = useLogger();
     const dividerGroups = await knex.select('*').from('directus_fields').where('interface', '=', 'group-divider');
     for (const dividerGroup of dividerGroups) {
         const newOptions = { showHeader: true };

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

@@ -1,5 +1,5 @@
 import { createInspector } from '@directus/schema';
-import logger from '../../logger.js';
+import { useLogger } from '../../logger.js';
 import { getHelpers } from '../helpers/index.js';
 export async function up(knex) {
     const helper = getHelpers(knex).schema;
@@ -33,6 +33,7 @@ export async function down(knex) {
  * Temporarily drop foreign key constraint for MySQL instances, see https://github.com/directus/directus/issues/19399
  */
 async function dropConstraint(knex) {
+    const logger = useLogger();
     const inspector = createInspector(knex);
     const foreignKeys = await inspector.foreignKeys('directus_shares');
     const collectionForeignKeys = foreignKeys.filter((fk) => fk.column === 'collection');

package/dist/database/migrations/20231215A-add-focalpoints.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20231215A-add-focalpoints.js

@@ -0,0 +1,12 @@
+export async function up(knex) {
+    await knex.schema.alterTable('directus_files', (table) => {
+        table.integer('focal_point_x').nullable();
+        table.integer('focal_point_y').nullable();
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_files', (table) => {
+        table.dropColumn('focal_point_x');
+        table.dropColumn('focal_point_y');
+    });
+}

package/dist/database/migrations/run.js

@@ -6,10 +6,11 @@ import { fileURLToPath } from 'node:url';
 import path from 'path';
 import { flushCaches } from '../../cache.js';
 import { getExtensionsPath } from '../../extensions/lib/get-extensions-path.js';
-import logger from '../../logger.js';
+import { useLogger } from '../../logger.js';
 import getModuleDefault from '../../utils/get-module-default.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export default async function run(database, direction, log = true) {
+    const logger = useLogger();
     let migrationFiles = await fse.readdir(__dirname);
     const customMigrationsPath = path.resolve(getExtensionsPath(), 'migrations');
     let customMigrationFiles = ((await fse.pathExists(customMigrationsPath)) && (await fse.readdir(customMigrationsPath))) || [];