@directus/api 15.0.0 → 17.0.0

package/dist/services/permissions.d.ts

@@ -1,8 +1,8 @@
-import type { PermissionsAction, Query } from '@directus/types';
+import type { ItemPermissions, PermissionsAction, Query } from '@directus/types';
 import type Keyv from 'keyv';
+import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
 import type { QueryOptions } from './items.js';
 import { ItemsService } from './items.js';
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
 export declare class PermissionsService extends ItemsService {
     systemCache: Keyv<any>;
     constructor(options: AbstractServiceOptions);
@@ -15,4 +15,5 @@ export declare class PermissionsService extends ItemsService {
     updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
     upsertMany(payloads: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
     deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    getItemPermissions(collection: string, primaryKey?: string): Promise<ItemPermissions>;
 }

package/dist/services/permissions.js

@@ -1,7 +1,9 @@
+import { ForbiddenError } from '@directus/errors';
 import { clearSystemCache, getCache } from '../cache.js';
 import { appAccessMinimalPermissions } from '../database/system-data/app-access-permissions/index.js';
-import { ItemsService } from './items.js';
 import { filterItems } from '../utils/filter-items.js';
+import { AuthorizationService } from './authorization.js';
+import { ItemsService } from './items.js';
 export class PermissionsService extends ItemsService {
     systemCache;
     constructor(options) {
@@ -95,4 +97,77 @@ export class PermissionsService extends ItemsService {
         }
         return res;
     }
+    async getItemPermissions(collection, primaryKey) {
+        if (!this.accountability?.user)
+            throw new ForbiddenError();
+        if (this.accountability?.admin) {
+            return {
+                update: { access: true },
+                delete: { access: true },
+                share: { access: true },
+            };
+        }
+        const itemPermissions = {
+            update: { access: false },
+            delete: { access: false },
+            share: { access: false },
+        };
+        let updateAction = 'update';
+        const schema = this.schema.collections[collection];
+        if (schema?.singleton) {
+            const itemsService = new ItemsService(collection, {
+                knex: this.knex,
+                schema: this.schema,
+            });
+            const query = {
+                fields: [schema.primary],
+                limit: 1,
+            };
+            try {
+                const result = await itemsService.readByQuery(query);
+                if (!result[0])
+                    updateAction = 'create';
+            }
+            catch {
+                updateAction = 'create';
+            }
+        }
+        const authorizationService = new AuthorizationService({
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+        });
+        await Promise.all(Object.keys(itemPermissions).map((key) => {
+            const action = key;
+            const checkAction = action === 'update' ? updateAction : action;
+            return authorizationService
+                .checkAccess(checkAction, collection, primaryKey)
+                .then(() => (itemPermissions[action].access = true))
+                .catch(() => { });
+        }));
+        if (schema?.singleton && itemPermissions.update.access) {
+            const query = {
+                filter: {
+                    _and: [
+                        ...(this.accountability?.role ? [{ role: { _eq: this.accountability.role } }] : []),
+                        { collection: { _eq: collection } },
+                        { action: { _eq: updateAction } },
+                    ],
+                },
+                fields: ['presets', 'fields'],
+            };
+            try {
+                const result = await this.readByQuery(query);
+                const permission = result[0];
+                if (permission) {
+                    itemPermissions.update.presets = permission['presets'];
+                    itemPermissions.update.fields = permission['fields'];
+                }
+            }
+            catch {
+                // No permission
+            }
+        }
+        return itemPermissions;
+    }
 }

package/dist/services/relations.js

@@ -1,3 +1,4 @@
+import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { createInspector } from '@directus/schema';
 import { toArray } from '@directus/utils';
 import { clearSystemCache, getCache } from '../cache.js';
@@ -5,7 +6,6 @@ import { getHelpers } from '../database/helpers/index.js';
 import getDatabase, { getSchemaInspector } from '../database/index.js';
 import { systemRelationRows } from '../database/system-data/relations/index.js';
 import emitter from '../emitter.js';
-import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { getDefaultIndexName } from '../utils/get-default-index-name.js';
 import { getSchema } from '../utils/get-schema.js';
 import { ItemsService } from './items.js';
@@ -115,16 +115,18 @@ export class RelationsService {
         if (!relation.field) {
             throw new InvalidPayloadError({ reason: '"field" is required' });
         }
-        if (relation.collection in this.schema.collections === false) {
+        const collectionSchema = this.schema.collections[relation.collection];
+        if (!collectionSchema) {
             throw new InvalidPayloadError({ reason: `Collection "${relation.collection}" doesn't exist` });
         }
-        if (relation.field in this.schema.collections[relation.collection].fields === false) {
+        const fieldSchema = collectionSchema.fields[relation.field];
+        if (!fieldSchema) {
             throw new InvalidPayloadError({
                 reason: `Field "${relation.field}" doesn't exist in collection "${relation.collection}"`,
             });
         }
         // A primary key should not be a foreign key
-        if (this.schema.collections[relation.collection].primary === relation.field) {
+        if (collectionSchema.primary === relation.field) {
             throw new InvalidPayloadError({
                 reason: `Field "${relation.field}" in collection "${relation.collection}" is a primary key`,
             });
@@ -151,7 +153,7 @@ export class RelationsService {
             await this.knex.transaction(async (trx) => {
                 if (relation.related_collection) {
                     await trx.schema.alterTable(relation.collection, async (table) => {
-                        this.alterType(table, relation);
+                        this.alterType(table, relation, fieldSchema.nullable);
                         const constraintName = getDefaultIndexName('foreign', relation.collection, relation.field);
                         const builder = table
                             .foreign(relation.field, constraintName)
@@ -198,10 +200,12 @@ export class RelationsService {
         if (this.accountability && this.accountability.admin !== true) {
             throw new ForbiddenError();
         }
-        if (collection in this.schema.collections === false) {
+        const collectionSchema = this.schema.collections[collection];
+        if (!collectionSchema) {
             throw new InvalidPayloadError({ reason: `Collection "${collection}" doesn't exist` });
         }
-        if (field in this.schema.collections[collection].fields === false) {
+        const fieldSchema = collectionSchema.fields[field];
+        if (!fieldSchema) {
             throw new InvalidPayloadError({ reason: `Field "${field}" doesn't exist in collection "${collection}"` });
         }
         const existingRelation = this.schema.relations.find((existingRelation) => existingRelation.collection === collection && existingRelation.field === field);
@@ -225,7 +229,7 @@ export class RelationsService {
                             constraintName = this.helpers.schema.constraintName(constraintName);
                             existingRelation.schema.constraint_name = constraintName;
                         }
-                        this.alterType(table, relation);
+                        this.alterType(table, relation, fieldSchema.nullable);
                         const builder = table
                             .foreign(field, constraintName || undefined)
                             .references(`${existingRelation.related_collection}.${this.schema.collections[existingRelation.related_collection].primary}`);
@@ -447,11 +451,16 @@ export class RelationsService {
      *
      * @TODO This is a bit of a hack, and might be better of abstracted elsewhere
      */
-    alterType(table, relation) {
+    alterType(table, relation, nullable) {
         const m2oFieldDBType = this.schema.collections[relation.collection].fields[relation.field].dbType;
         const relatedFieldDBType = this.schema.collections[relation.related_collection].fields[this.schema.collections[relation.related_collection].primary].dbType;
         if (m2oFieldDBType !== relatedFieldDBType && m2oFieldDBType === 'int' && relatedFieldDBType === 'int unsigned') {
-            table.specificType(relation.field, 'int unsigned').alter();
+            const alterField = table.specificType(relation.field, 'int unsigned');
+            // Maintains the non-nullable state
+            if (!nullable) {
+                alterField.notNullable();
+            }
+            alterField.alter();
         }
     }
 }

package/dist/services/roles.js

@@ -15,7 +15,7 @@ export class RolesService extends ItemsService {
             .whereNotIn('id', excludeKeys)
             .andWhere({ admin_access: true })
             .first();
-        const otherAdminRolesCount = +(otherAdminRoles?.count || 0);
+        const otherAdminRolesCount = Number(otherAdminRoles?.count ?? 0);
         if (otherAdminRolesCount === 0) {
             throw new UnprocessableContentError({ reason: `You can't delete the last admin role` });
         }
@@ -24,30 +24,98 @@ export class RolesService extends ItemsService {
         const role = await this.knex.select('admin_access').from('directus_roles').where('id', '=', key).first();
         if (!role)
             throw new ForbiddenError();
-        // The users that will now be in this new non-admin role
-        let userKeys = [];
+        const usersBefore = (await this.knex.select('id').from('directus_users').where('role', '=', key)).map((user) => user.id);
+        const usersAdded = [];
+        const usersUpdated = [];
+        const usersCreated = [];
+        const usersRemoved = [];
         if (Array.isArray(users)) {
-            userKeys = users.map((user) => (typeof user === 'string' ? user : user['id'])).filter((id) => id);
+            const usersKept = [];
+            for (const user of users) {
+                if (typeof user === 'string') {
+                    if (usersBefore.includes(user)) {
+                        usersKept.push(user);
+                    }
+                    else {
+                        usersAdded.push({ id: user });
+                    }
+                }
+                else if (user.id) {
+                    if (usersBefore.includes(user.id)) {
+                        usersKept.push(user.id);
+                        usersUpdated.push(user);
+                    }
+                    else {
+                        usersAdded.push(user);
+                    }
+                }
+                else {
+                    usersCreated.push(user);
+                }
+            }
+            usersRemoved.push(...usersBefore.filter((user) => !usersKept.includes(user)));
         }
         else {
-            userKeys = users.update.map((user) => user['id']).filter((id) => id);
+            for (const user of users.update) {
+                if (usersBefore.includes(user['id'])) {
+                    usersUpdated.push(user);
+                }
+                else {
+                    usersAdded.push(user);
+                }
+            }
+            usersCreated.push(...users.create);
+            usersRemoved.push(...users.delete);
+        }
+        if (role.admin_access === false || role.admin_access === 0) {
+            // Admin users might have moved in from other role, thus becoming non-admin
+            if (usersAdded.length > 0) {
+                const otherAdminUsers = await this.knex
+                    .count('*', { as: 'count' })
+                    .from('directus_users')
+                    .leftJoin('directus_roles', 'directus_users.role', 'directus_roles.id')
+                    .whereNotIn('directus_users.id', usersAdded)
+                    .andWhere({ 'directus_roles.admin_access': true, status: 'active' })
+                    .first();
+                const otherAdminUsersCount = Number(otherAdminUsers?.count ?? 0);
+                if (otherAdminUsersCount === 0) {
+                    throw new UnprocessableContentError({ reason: `You can't remove the last admin user from the admin role` });
+                }
+            }
+            return;
         }
-        const usersThatWereInRoleBefore = (await this.knex.select('id').from('directus_users').where('role', '=', key)).map((user) => user.id);
-        const usersThatAreRemoved = usersThatWereInRoleBefore.filter((id) => Array.isArray(users) ? userKeys.includes(id) === false : users.delete.includes(id) === true);
-        const usersThatAreAdded = Array.isArray(users) ? users : users.create;
-        // If the role the users are moved to is an admin-role, and there's at least 1 (new) admin
-        // user, we don't have to check for other admin
-        // users
-        if ((role.admin_access === true || role.admin_access === 1) && usersThatAreAdded.length > 0)
+        // Only added or created new users
+        if (usersUpdated.length === 0 && usersRemoved.length === 0)
+            return;
+        // Active admin user(s) about to be created
+        if (usersCreated.some((user) => !('status' in user) || user.status === 'active'))
             return;
+        const usersDeactivated = [...usersAdded, ...usersUpdated]
+            .filter((user) => 'status' in user && user.status !== 'active')
+            .map((user) => user.id);
+        const usersAddedNonDeactivated = usersAdded
+            .filter((user) => !usersDeactivated.includes(user.id))
+            .map((user) => user.id);
+        // Active user(s) about to become admin
+        if (usersAddedNonDeactivated.length > 0) {
+            const userCount = await this.knex
+                .count('*', { as: 'count' })
+                .from('directus_users')
+                .whereIn('id', usersAddedNonDeactivated)
+                .andWhere({ status: 'active' })
+                .first();
+            if (Number(userCount?.count ?? 0) > 0) {
+                return;
+            }
+        }
         const otherAdminUsers = await this.knex
             .count('*', { as: 'count' })
             .from('directus_users')
-            .whereNotIn('directus_users.id', [...userKeys, ...usersThatAreRemoved])
-            .andWhere({ 'directus_roles.admin_access': true })
             .leftJoin('directus_roles', 'directus_users.role', 'directus_roles.id')
+            .whereNotIn('directus_users.id', [...usersDeactivated, ...usersRemoved])
+            .andWhere({ 'directus_roles.admin_access': true, status: 'active' })
             .first();
-        const otherAdminUsersCount = +(otherAdminUsers?.count || 0);
+        const otherAdminUsersCount = Number(otherAdminUsers?.count ?? 0);
         if (otherAdminUsersCount === 0) {
             throw new UnprocessableContentError({ reason: `You can't remove the last admin user from the admin role` });
         }

package/dist/services/server.js

@@ -1,19 +1,20 @@
-import { toArray } from '@directus/utils';
+import { useEnv } from '@directus/env';
+import { toArray, toBoolean } from '@directus/utils';
 import { version } from 'directus/version';
 import { merge } from 'lodash-es';
 import { Readable } from 'node:stream';
 import { performance } from 'perf_hooks';
 import { getCache } from '../cache.js';
 import getDatabase, { hasDatabaseConnection } from '../database/index.js';
-import env from '../env.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import getMailer from '../mailer.js';
 import { rateLimiterGlobal } from '../middleware/rate-limiter-global.js';
 import { rateLimiter } from '../middleware/rate-limiter-ip.js';
 import { SERVER_ONLINE } from '../server.js';
 import { getStorage } from '../storage/index.js';
-import { toBoolean } from '../utils/to-boolean.js';
 import { SettingsService } from './settings.js';
+const env = useEnv();
+const logger = useLogger();
 export class ServerService {
     knex;
     accountability;
@@ -40,7 +41,8 @@ export class ServerService {
                 'theme_dark_overrides',
                 'default_language',
                 'public_foreground',
-                'public_background',
+                'public_background.id',
+                'public_background.type',
                 'public_favicon',
                 'public_note',
                 'custom_css',

package/dist/services/shares.js

@@ -1,7 +1,7 @@
+import { useEnv } from '@directus/env';
+import { ForbiddenError, InvalidCredentialsError } from '@directus/errors';
 import argon2 from 'argon2';
 import jwt from 'jsonwebtoken';
-import env from '../env.js';
-import { ForbiddenError, InvalidCredentialsError } from '@directus/errors';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { md } from '../utils/md.js';
 import { Url } from '../utils/url.js';
@@ -10,6 +10,7 @@ import { AuthorizationService } from './authorization.js';
 import { ItemsService } from './items.js';
 import { MailService } from './mail/index.js';
 import { UsersService } from './users.js';
+const env = useEnv();
 export class SharesService extends ItemsService {
     authorizationService;
     constructor(options) {

package/dist/services/specifications.js

@@ -1,13 +1,14 @@
+import { useEnv } from '@directus/env';
 import formatTitle from '@directus/format-title';
 import { spec } from '@directus/specs';
 import { version } from 'directus/version';
 import { cloneDeep, mergeWith } from 'lodash-es';
 import { OAS_REQUIRED_SCHEMAS } from '../constants.js';
 import getDatabase from '../database/index.js';
-import env from '../env.js';
 import { getRelationType } from '../utils/get-relation-type.js';
 import { reduceSchema } from '../utils/reduce-schema.js';
 import { GraphQLService } from './graphql/index.js';
+const env = useEnv();
 export class SpecificationService {
     accountability;
     knex;

package/dist/services/users.js

@@ -1,3 +1,5 @@
+import { useEnv } from '@directus/env';
+import { ForbiddenError, InvalidPayloadError, RecordNotUniqueError, UnprocessableContentError } from '@directus/errors';
 import { getSimpleHash, toArray } from '@directus/utils';
 import { FailedValidationError, joiValidationErrorItemToErrorExtensions } from '@directus/validation';
 import Joi from 'joi';
@@ -5,9 +7,6 @@ import jwt from 'jsonwebtoken';
 import { cloneDeep, isEmpty } from 'lodash-es';
 import { performance } from 'perf_hooks';
 import getDatabase from '../database/index.js';
-import env from '../env.js';
-import { ForbiddenError } from '@directus/errors';
-import { InvalidPayloadError, RecordNotUniqueError, UnprocessableContentError } from '@directus/errors';
 import isUrlAllowed from '../utils/is-url-allowed.js';
 import { verifyJWT } from '../utils/jwt.js';
 import { stall } from '../utils/stall.js';
@@ -15,6 +14,7 @@ import { Url } from '../utils/url.js';
 import { ItemsService } from './items.js';
 import { MailService } from './mail/index.js';
 import { SettingsService } from './settings.js';
+const env = useEnv();
 export class UsersService extends ItemsService {
     constructor(options) {
         super('directus_users', options);
@@ -213,9 +213,20 @@ export class UsersService extends ItemsService {
     async updateMany(keys, data, opts) {
         try {
             if (data['role']) {
-                // data['role'] will be an object with id with GraphQL mutations
-                const roleId = data['role']?.id ?? data['role'];
-                const newRole = await this.knex.select('admin_access').from('directus_roles').where('id', roleId).first();
+                /*
+                 * data['role'] has the following cases:
+                 * - a string with existing role id
+                 * - an object with existing role id for GraphQL mutations
+                 * - an object with data for new role
+                 */
+                const role = data['role']?.id ?? data['role'];
+                let newRole;
+                if (typeof role === 'string') {
+                    newRole = await this.knex.select('admin_access').from('directus_roles').where('id', role).first();
+                }
+                else {
+                    newRole = role;
+                }
                 if (!newRole?.admin_access) {
                     await this.checkRemainingAdminExistence(keys);
                 }
@@ -325,13 +336,13 @@ export class UsersService extends ItemsService {
             if (isEmpty(user) || user.status === 'invited') {
                 const subjectLine = subject ?? "You've been invited";
                 await mailService.send({
-                    to: user.email,
+                    to: user?.email ?? email,
                     subject: subjectLine,
                     template: {
                         name: 'user-invitation',
                         data: {
-                            url: this.inviteUrl(email, url),
-                            email: user.email,
+                            url: this.inviteUrl(user?.email ?? email, url),
+                            email: user?.email ?? email,
                         },
                     },
                 });

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;