@directus/api 14.1.2 → 16.0.0

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 { version } from '../utils/package.js';
-import { GraphQLService } from './graphql/index.js';
 import { reduceSchema } from '../utils/reduce-schema.js';
+import { GraphQLService } from './graphql/index.js';
+const env = useEnv();
 export class SpecificationService {
     accountability;
     knex;
@@ -19,7 +20,7 @@ export class SpecificationService {
         this.knex = knex || getDatabase();
         this.schema = schema;
         this.oas = new OASSpecsService({ knex, schema, accountability });
-        this.graphql = new GraphQLSpecsService({ knex, schema });
+        this.graphql = new GraphQLSpecsService({ knex, schema, accountability });
     }
 }
 class OASSpecsService {

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);
@@ -116,7 +116,7 @@ export class UsersService extends ItemsService {
      */
     async getUserByEmail(email) {
         return await this.knex
-            .select('id', 'role', 'status', 'password')
+            .select('id', 'role', 'status', 'password', 'email')
             .from('directus_users')
             .whereRaw(`LOWER(??) = ?`, ['email', email.toLowerCase()])
             .first();
@@ -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: email,
+                    to: user?.email ?? email,
                     subject: subjectLine,
                     template: {
                         name: 'user-invitation',
                         data: {
-                            url: this.inviteUrl(email, url),
-                            email,
+                            url: this.inviteUrl(user?.email ?? email, url),
+                            email: user?.email ?? email,
                         },
                     },
                 });
@@ -369,20 +380,20 @@ export class UsersService extends ItemsService {
             knex: this.knex,
             accountability: this.accountability,
         });
-        const payload = { email, scope: 'password-reset', hash: getSimpleHash('' + user.password) };
+        const payload = { email: user.email, scope: 'password-reset', hash: getSimpleHash('' + user.password) };
         const token = jwt.sign(payload, env['SECRET'], { expiresIn: '1d', issuer: 'directus' });
         const acceptURL = url
             ? new Url(url).setQuery('token', token).toString()
             : new Url(env['PUBLIC_URL']).addPath('admin', 'reset-password').setQuery('token', token).toString();
         const subjectLine = subject ? subject : 'Password Reset Request';
         await mailService.send({
-            to: email,
+            to: user.email,
             subject: subjectLine,
             template: {
                 name: 'password-reset',
                 data: {
                     url: acceptURL,
-                    email,
+                    email: user.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/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/get-report.js';
+export * from './lib/init-telemetry.js';
+export * from './lib/send-report.js';
+export * from './lib/track.js';

package/dist/telemetry/index.js

@@ -0,0 +1,4 @@
+export * from './lib/get-report.js';
+export * from './lib/init-telemetry.js';
+export * from './lib/send-report.js';
+export * from './lib/track.js';

package/dist/telemetry/lib/get-report.d.ts

@@ -0,0 +1,5 @@
+import type { TelemetryReport } from '../types/report.js';
+/**
+ * Create a telemetry report about the anonymous usage of the current installation
+ */
+export declare const getReport: () => Promise<TelemetryReport>;

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

@@ -0,0 +1,42 @@
+import { useEnv } from '@directus/env';
+import { version } from 'directus/version';
+import { getDatabase, getDatabaseClient } from '../../database/index.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';
+const basicCountCollections = [
+    'directus_dashboards',
+    'directus_extensions',
+    'directus_files',
+    'directus_flows',
+    'directus_roles',
+    'directus_shares',
+];
+/**
+ * Create a telemetry report about the anonymous usage of the current installation
+ */
+export const getReport = async () => {
+    const db = getDatabase();
+    const env = useEnv();
+    const [basicCounts, userCounts, userItemCount] = await Promise.all([
+        getItemCount(db, basicCountCollections),
+        getUserCount(db),
+        getUserItemCount(db),
+    ]);
+    return {
+        url: env['PUBLIC_URL'],
+        version: version,
+        database: getDatabaseClient(),
+        dashboards: basicCounts.directus_dashboards,
+        extensions: basicCounts.directus_extensions,
+        files: basicCounts.directus_files,
+        flows: basicCounts.directus_flows,
+        roles: basicCounts.directus_roles,
+        shares: basicCounts.directus_shares,
+        admin_users: userCounts.admin,
+        app_users: userCounts.app,
+        api_users: userCounts.api,
+        collections: userItemCount.collections,
+        items: userItemCount.items,
+    };
+};

package/dist/telemetry/lib/init-telemetry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Exported to be able to test the anonymous callback function
+ */
+export declare const jobCallback: () => void;
+/**
+ * Initialize the telemetry tracking. Will generate a report on start, and set a schedule to report
+ * every 6 hours
+ *
+ * @returns Whether or not telemetry has been initialized
+ */
+export declare const initTelemetry: () => Promise<boolean>;

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

@@ -0,0 +1,30 @@
+import { useEnv } from '@directus/env';
+import { toBoolean } from '@directus/utils';
+import { getCache } from '../../cache.js';
+import { scheduleSynchronizedJob } from '../../utils/schedule.js';
+import { track } from './track.js';
+/**
+ * Exported to be able to test the anonymous callback function
+ */
+export const jobCallback = () => {
+    track();
+};
+/**
+ * Initialize the telemetry tracking. Will generate a report on start, and set a schedule to report
+ * every 6 hours
+ *
+ * @returns Whether or not telemetry has been initialized
+ */
+export const initTelemetry = async () => {
+    const env = useEnv();
+    if (toBoolean(env['TELEMETRY']) === false)
+        return false;
+    scheduleSynchronizedJob('telemetry', '0 */6 * * *', jobCallback);
+    const { lockCache } = getCache();
+    if (!(await lockCache.get('telemetry-lock'))) {
+        await lockCache.set('telemetry-lock', true, 30000);
+        track({ wait: false });
+        // Don't flush the lock. We want to debounce these calls across containers on startup
+    }
+    return true;
+};

package/dist/telemetry/lib/send-report.d.ts

@@ -0,0 +1,5 @@
+import type { TelemetryReport } from '../types/report.js';
+/**
+ * Post an anonymous usage report to the centralized intake server
+ */
+export declare const sendReport: (report: TelemetryReport) => Promise<void>;

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

@@ -0,0 +1,23 @@
+import { useEnv } from '@directus/env';
+import { URL } from 'node:url';
+/**
+ * Post an anonymous usage report to the centralized intake server
+ */
+export const sendReport = async (report) => {
+    const env = useEnv();
+    const url = new URL('/v1/metrics', env['TELEMETRY_URL']);
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (env['TELEMETRY_AUTHORIZATION']) {
+        headers['Authorization'] = env['TELEMETRY_AUTHORIZATION'];
+    }
+    const res = await fetch(url, {
+        method: 'POST',
+        body: JSON.stringify(report),
+        headers,
+    });
+    if (!res.ok) {
+        throw new Error(`[${res.status}] ${await res.text()}`);
+    }
+};

package/dist/telemetry/lib/track.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generate and send a report. Will log on error, but not throw. No need to be awaited
+ *
+ * @param opts Options for the tracking
+ * @param opts.wait Whether or not to wait a random amount of time between 0 and 30 minutes
+ * @returns whether or not the tracking was successful
+ */
+export declare const track: (opts?: {
+    wait: boolean;
+}) => Promise<boolean>;

package/dist/telemetry/lib/track.js

@@ -0,0 +1,30 @@
+import { getNodeEnv } from '@directus/utils/node';
+import { setTimeout } from 'timers/promises';
+import { useLogger } from '../../logger.js';
+import { getRandomWaitTime } from '../utils/get-random-wait-time.js';
+import { getReport } from './get-report.js';
+import { sendReport } from './send-report.js';
+/**
+ * Generate and send a report. Will log on error, but not throw. No need to be awaited
+ *
+ * @param opts Options for the tracking
+ * @param opts.wait Whether or not to wait a random amount of time between 0 and 30 minutes
+ * @returns whether or not the tracking was successful
+ */
+export const track = async (opts = { wait: true }) => {
+    const logger = useLogger();
+    if (opts.wait) {
+        await setTimeout(getRandomWaitTime());
+    }
+    try {
+        const report = await getReport();
+        await sendReport(report);
+        return true;
+    }
+    catch (err) {
+        if (getNodeEnv() === 'development') {
+            logger.error(err);
+        }
+        return false;
+    }
+};

package/dist/telemetry/types/report.d.ts

@@ -0,0 +1,58 @@
+export interface TelemetryReport {
+    /**
+     * The project's web-facing public URL
+     */
+    url: string;
+    /**
+     * Current Directus version in use
+     */
+    version: string;
+    /**
+     * Database client in use
+     */
+    database: string;
+    /**
+     * Number of users in the system that have admin access to the system
+     */
+    admin_users: number;
+    /**
+     * Number of users that can access the app, but don't have admin access
+     */
+    app_users: number;
+    /**
+     * Number of users that can only access the API
+     */
+    api_users: number;
+    /**
+     * Number of unique roles in the system
+     */
+    roles: number;
+    /**
+     * Number of unique flows in the system
+     */
+    flows: number;
+    /**
+     * Number of unique dashboards in the system
+     */
+    dashboards: number;
+    /**
+     * Number of installed extensions in the system. Does not differentiate between enabled/disabled
+     */
+    extensions: number;
+    /**
+     * Number of Directus-managed collections
+     */
+    collections: number;
+    /**
+     * Total number of items in the non-system tables
+     */
+    items: number;
+    /**
+     * Number of files in the system
+     */
+    files: number;
+    /**
+     * Number of shares in the system
+     */
+    shares: number;
+}

package/dist/telemetry/types/report.js

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

package/dist/telemetry/utils/get-item-count.d.ts

@@ -0,0 +1,26 @@
+import { type Knex } from 'knex';
+export interface CollectionCount {
+    collection: string;
+    count: number;
+}
+/**
+ * Get the item count of the given collection in the given database
+ * @param db Knex instance to count against
+ * @param collection Table to count rows in
+ * @returns Collection name and count
+ */
+export declare const countCollection: (db: Knex, collection: string) => Promise<CollectionCount>;
+/**
+ * Merge the given collection count in the object accumulator
+ * Intended for use with .reduce()
+ * @param acc Accumulator
+ * @param value Current collection count object in array
+ * @returns Updated accumulator
+ */
+export declare const mergeResults: (acc: Record<string, number>, value: CollectionCount) => Record<string, number>;
+/**
+ * Get an object of item counts for the given collections
+ * @param db Database instance to get counts in
+ * @param collections Array of table names to get count from
+ */
+export declare const getItemCount: <T extends readonly string[]>(db: Knex, collections: T) => Promise<Record<T[number], number>>;

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

@@ -0,0 +1,36 @@
+import {} from 'knex';
+import pLimit from 'p-limit';
+/**
+ * Get the item count of the given collection in the given database
+ * @param db Knex instance to count against
+ * @param collection Table to count rows in
+ * @returns Collection name and count
+ */
+export const countCollection = async (db, collection) => {
+    const count = await db.count('*', { as: 'count' }).from(collection).first();
+    return { collection, count: Number(count?.['count'] ?? 0) };
+};
+/**
+ * Merge the given collection count in the object accumulator
+ * Intended for use with .reduce()
+ * @param acc Accumulator
+ * @param value Current collection count object in array
+ * @returns Updated accumulator
+ */
+export const mergeResults = (acc, value) => {
+    acc[value.collection] = value.count;
+    return acc;
+};
+/**
+ * Get an object of item counts for the given collections
+ * @param db Database instance to get counts in
+ * @param collections Array of table names to get count from
+ */
+export const getItemCount = async (db, collections) => {
+    // Counts can be a little heavy if the table is very large, so we'll only ever execute 3 of these
+    // queries simultaneously to not overload the database
+    const limit = pLimit(3);
+    const calls = collections.map((collection) => limit(countCollection, db, collection));
+    const results = await Promise.all(calls);
+    return results.reduce(mergeResults, {});
+};

package/dist/telemetry/utils/get-random-wait-time.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns randomized value between 0 and 1.8e+6 (30min in ms) intended to be used as the randomized wait for
+ * telemetry tracking
+ */
+export declare const getRandomWaitTime: () => number;

package/dist/telemetry/utils/get-random-wait-time.js

@@ -0,0 +1,5 @@
+/**
+ * Returns randomized value between 0 and 1.8e+6 (30min in ms) intended to be used as the randomized wait for
+ * telemetry tracking
+ */
+export const getRandomWaitTime = () => Math.floor(Math.random() * 1.8e6);

package/dist/telemetry/utils/get-user-count.d.ts

@@ -0,0 +1,7 @@
+import { type Knex } from 'knex';
+export interface UserCount {
+    admin: number;
+    app: number;
+    api: number;
+}
+export declare const getUserCount: (db: Knex) => Promise<UserCount>;

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

@@ -0,0 +1,30 @@
+import { toBoolean } from '@directus/utils';
+import {} from 'knex';
+export const getUserCount = async (db) => {
+    const counts = {
+        admin: 0,
+        app: 0,
+        api: 0,
+    };
+    const result = (await db
+        .count('directus_users.id', { as: 'count' })
+        .select('directus_roles.admin_access', 'directus_roles.app_access')
+        .from('directus_users')
+        .leftJoin('directus_roles', 'directus_users.role', '=', 'directus_roles.id')
+        .groupBy('directus_roles.admin_access', 'directus_roles.app_access'));
+    for (const record of result) {
+        const adminAccess = toBoolean(record.admin_access);
+        const appAccess = toBoolean(record.app_access);
+        const count = Number(record.count);
+        if (adminAccess) {
+            counts.admin = count;
+        }
+        else if (appAccess) {
+            counts.app = count;
+        }
+        else {
+            counts.api = count;
+        }
+    }
+    return counts;
+};

package/dist/telemetry/utils/get-user-item-count.d.ts

@@ -0,0 +1,13 @@
+import { type Knex } from 'knex';
+export interface UserItemCount {
+    collections: number;
+    items: number;
+}
+/**
+ * Sum all passed values together. Meant to be used with .reduce()
+ */
+export declare const sum: (acc: number, val: number) => number;
+/**
+ * Count all the items in the non-system tables
+ */
+export declare const getUserItemCount: (db: Knex) => Promise<UserItemCount>;

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

@@ -0,0 +1,18 @@
+import {} from 'knex';
+import { getSchema } from '../../utils/get-schema.js';
+import { getItemCount } from './get-item-count.js';
+/**
+ * Sum all passed values together. Meant to be used with .reduce()
+ */
+export const sum = (acc, val) => (acc += val);
+/**
+ * Count all the items in the non-system tables
+ */
+export const getUserItemCount = async (db) => {
+    const schema = await getSchema({ database: db });
+    const userCollections = Object.keys(schema.collections).filter((collection) => collection.startsWith('directus_') === false);
+    const counts = await getItemCount(db, userCollections);
+    const collections = userCollections.length;
+    const items = Object.values(counts).reduce(sum, 0);
+    return { collections, items };
+};

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;