@directus/api 9.25.0

package/dist/services/roles.js

@@ -0,0 +1,144 @@
+import { ForbiddenException, UnprocessableEntityException } from '../exceptions/index.js';
+import { ItemsService } from './items.js';
+import { PermissionsService } from './permissions.js';
+import { PresetsService } from './presets.js';
+import { UsersService } from './users.js';
+export class RolesService extends ItemsService {
+    constructor(options) {
+        super('directus_roles', options);
+    }
+    async checkForOtherAdminRoles(excludeKeys) {
+        // Make sure there's at least one admin role left after this deletion is done
+        const otherAdminRoles = await this.knex
+            .count('*', { as: 'count' })
+            .from('directus_roles')
+            .whereNotIn('id', excludeKeys)
+            .andWhere({ admin_access: true })
+            .first();
+        const otherAdminRolesCount = +(otherAdminRoles?.count || 0);
+        if (otherAdminRolesCount === 0)
+            throw new UnprocessableEntityException(`You can't delete the last admin role.`);
+    }
+    async checkForOtherAdminUsers(key, users) {
+        const role = await this.knex.select('admin_access').from('directus_roles').where('id', '=', key).first();
+        if (!role)
+            throw new ForbiddenException();
+        // The users that will now be in this new non-admin role
+        let userKeys = [];
+        if (Array.isArray(users)) {
+            userKeys = users.map((user) => (typeof user === 'string' ? user : user['id'])).filter((id) => id);
+        }
+        else {
+            userKeys = users.update.map((user) => user['id']).filter((id) => id);
+        }
+        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)
+            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')
+            .first();
+        const otherAdminUsersCount = +(otherAdminUsers?.count || 0);
+        if (otherAdminUsersCount === 0) {
+            throw new UnprocessableEntityException(`You can't remove the last admin user from the admin role.`);
+        }
+        return;
+    }
+    async updateOne(key, data, opts) {
+        try {
+            if ('users' in data) {
+                await this.checkForOtherAdminUsers(key, data['users']);
+            }
+        }
+        catch (err) {
+            (opts || (opts = {})).preMutationException = err;
+        }
+        return super.updateOne(key, data, opts);
+    }
+    async updateBatch(data, opts) {
+        const primaryKeyField = this.schema.collections[this.collection].primary;
+        const keys = data.map((item) => item[primaryKeyField]);
+        const setsToNoAdmin = data.some((item) => item['admin_access'] === false);
+        try {
+            if (setsToNoAdmin) {
+                await this.checkForOtherAdminRoles(keys);
+            }
+        }
+        catch (err) {
+            (opts || (opts = {})).preMutationException = err;
+        }
+        return super.updateBatch(data, opts);
+    }
+    async updateMany(keys, data, opts) {
+        try {
+            if ('admin_access' in data && data['admin_access'] === false) {
+                await this.checkForOtherAdminRoles(keys);
+            }
+        }
+        catch (err) {
+            (opts || (opts = {})).preMutationException = err;
+        }
+        return super.updateMany(keys, data, opts);
+    }
+    async deleteOne(key) {
+        await this.deleteMany([key]);
+        return key;
+    }
+    async deleteMany(keys) {
+        const opts = {};
+        try {
+            await this.checkForOtherAdminRoles(keys);
+        }
+        catch (err) {
+            opts.preMutationException = err;
+        }
+        await this.knex.transaction(async (trx) => {
+            const itemsService = new ItemsService('directus_roles', {
+                knex: trx,
+                accountability: this.accountability,
+                schema: this.schema,
+            });
+            const permissionsService = new PermissionsService({
+                knex: trx,
+                accountability: this.accountability,
+                schema: this.schema,
+            });
+            const presetsService = new PresetsService({
+                knex: trx,
+                accountability: this.accountability,
+                schema: this.schema,
+            });
+            const usersService = new UsersService({
+                knex: trx,
+                accountability: this.accountability,
+                schema: this.schema,
+            });
+            // Delete permissions/presets for this role, suspend all remaining users in role
+            await permissionsService.deleteByQuery({
+                filter: { role: { _in: keys } },
+            }, { ...opts, bypassLimits: true });
+            await presetsService.deleteByQuery({
+                filter: { role: { _in: keys } },
+            }, { ...opts, bypassLimits: true });
+            await usersService.updateByQuery({
+                filter: { role: { _in: keys } },
+            }, {
+                status: 'suspended',
+                role: null,
+            }, { ...opts, bypassLimits: true });
+            await itemsService.deleteMany(keys, opts);
+        });
+        return keys;
+    }
+    deleteByQuery(query, opts) {
+        return super.deleteByQuery(query, opts);
+    }
+}

package/dist/services/roles.test.d.ts

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

package/dist/services/schema.d.ts

@@ -0,0 +1,15 @@
+import type { Accountability } from '@directus/types';
+import type { Knex } from 'knex';
+import type { AbstractServiceOptions, Snapshot, SnapshotDiff, SnapshotDiffWithHash, SnapshotWithHash } from '../types/index.js';
+export declare class SchemaService {
+    knex: Knex;
+    accountability: Accountability | null;
+    constructor(options: Omit<AbstractServiceOptions, 'schema'>);
+    snapshot(): Promise<Snapshot>;
+    apply(payload: SnapshotDiffWithHash): Promise<void>;
+    diff(snapshot: Snapshot, options?: {
+        currentSnapshot?: Snapshot;
+        force?: boolean;
+    }): Promise<SnapshotDiff | null>;
+    getHashedSnapshot(snapshot: Snapshot): SnapshotWithHash;
+}

package/dist/services/schema.js

@@ -0,0 +1,49 @@
+import getDatabase from '../database/index.js';
+import { ForbiddenException } from '../exceptions/index.js';
+import { applyDiff } from '../utils/apply-diff.js';
+import { getSnapshot } from '../utils/get-snapshot.js';
+import { getSnapshotDiff } from '../utils/get-snapshot-diff.js';
+import { getVersionedHash } from '../utils/get-versioned-hash.js';
+import { validateApplyDiff } from '../utils/validate-diff.js';
+import { validateSnapshot } from '../utils/validate-snapshot.js';
+export class SchemaService {
+    knex;
+    accountability;
+    constructor(options) {
+        this.knex = options.knex ?? getDatabase();
+        this.accountability = options.accountability ?? null;
+    }
+    async snapshot() {
+        if (this.accountability?.admin !== true)
+            throw new ForbiddenException();
+        const currentSnapshot = await getSnapshot({ database: this.knex });
+        return currentSnapshot;
+    }
+    async apply(payload) {
+        if (this.accountability?.admin !== true)
+            throw new ForbiddenException();
+        const currentSnapshot = await this.snapshot();
+        const snapshotWithHash = this.getHashedSnapshot(currentSnapshot);
+        if (!validateApplyDiff(payload, snapshotWithHash))
+            return;
+        await applyDiff(currentSnapshot, payload.diff, { database: this.knex });
+    }
+    async diff(snapshot, options) {
+        if (this.accountability?.admin !== true)
+            throw new ForbiddenException();
+        validateSnapshot(snapshot, options?.force);
+        const currentSnapshot = options?.currentSnapshot ?? (await getSnapshot({ database: this.knex }));
+        const diff = getSnapshotDiff(currentSnapshot, snapshot);
+        if (diff.collections.length === 0 && diff.fields.length === 0 && diff.relations.length === 0) {
+            return null;
+        }
+        return diff;
+    }
+    getHashedSnapshot(snapshot) {
+        const snapshotHash = getVersionedHash(snapshot);
+        return {
+            ...snapshot,
+            hash: snapshotHash,
+        };
+    }
+}

package/dist/services/schema.test.d.ts

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

package/dist/services/server.d.ts

@@ -0,0 +1,13 @@
+import type { Accountability, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { AbstractServiceOptions } from '../types/index.js';
+import { SettingsService } from './settings.js';
+export declare class ServerService {
+    knex: Knex;
+    accountability: Accountability | null;
+    settingsService: SettingsService;
+    schema: SchemaOverview;
+    constructor(options: AbstractServiceOptions);
+    serverInfo(): Promise<Record<string, any>>;
+    health(): Promise<Record<string, any>>;
+}

package/dist/services/server.js

@@ -0,0 +1,339 @@
+import { toArray } from '@directus/utils';
+import { merge } from 'lodash-es';
+import { Readable } from 'node:stream';
+import os from 'os';
+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 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 { getOSInfo } from '../utils/get-os-info.js';
+import { version } from '../utils/package.js';
+import { SettingsService } from './settings.js';
+export class ServerService {
+    knex;
+    accountability;
+    settingsService;
+    schema;
+    constructor(options) {
+        this.knex = options.knex || getDatabase();
+        this.accountability = options.accountability || null;
+        this.schema = options.schema;
+        this.settingsService = new SettingsService({ knex: this.knex, schema: this.schema });
+    }
+    async serverInfo() {
+        const info = {};
+        const projectInfo = await this.settingsService.readSingleton({
+            fields: [
+                'project_name',
+                'project_descriptor',
+                'project_logo',
+                'project_color',
+                'default_language',
+                'public_foreground',
+                'public_background',
+                'public_note',
+                'custom_css',
+            ],
+        });
+        info['project'] = projectInfo;
+        if (this.accountability?.user) {
+            if (env['RATE_LIMITER_ENABLED']) {
+                info['rateLimit'] = {
+                    points: env['RATE_LIMITER_POINTS'],
+                    duration: env['RATE_LIMITER_DURATION'],
+                };
+            }
+            else {
+                info['rateLimit'] = false;
+            }
+            if (env['RATE_LIMITER_GLOBAL_ENABLED']) {
+                info['rateLimitGlobal'] = {
+                    points: env['RATE_LIMITER_GLOBAL_POINTS'],
+                    duration: env['RATE_LIMITER_GLOBAL_DURATION'],
+                };
+            }
+            else {
+                info['rateLimitGlobal'] = false;
+            }
+            info['flows'] = {
+                execAllowedModules: env['FLOWS_EXEC_ALLOWED_MODULES'] ? toArray(env['FLOWS_EXEC_ALLOWED_MODULES']) : [],
+            };
+        }
+        if (this.accountability?.admin === true) {
+            const { osType, osVersion } = getOSInfo();
+            info['directus'] = {
+                version,
+            };
+            info['node'] = {
+                version: process.versions.node,
+                uptime: Math.round(process.uptime()),
+            };
+            info['os'] = {
+                type: osType,
+                version: osVersion,
+                uptime: Math.round(os.uptime()),
+                totalmem: os.totalmem(),
+            };
+        }
+        return info;
+    }
+    async health() {
+        const { nanoid } = await import('nanoid');
+        const checkID = nanoid(5);
+        const data = {
+            status: 'ok',
+            releaseId: version,
+            serviceId: env['KEY'],
+            checks: merge(...(await Promise.all([
+                testDatabase(),
+                testCache(),
+                testRateLimiter(),
+                testRateLimiterGlobal(),
+                testStorage(),
+                testEmail(),
+            ]))),
+        };
+        if (SERVER_ONLINE === false) {
+            data.status = 'error';
+        }
+        for (const [service, healthData] of Object.entries(data.checks)) {
+            for (const healthCheck of healthData) {
+                if (healthCheck.status === 'warn' && data.status === 'ok') {
+                    logger.warn(`${service} in WARN state, the observed value ${healthCheck.observedValue} is above the threshold of ${healthCheck.threshold}${healthCheck.observedUnit}`);
+                    data.status = 'warn';
+                    continue;
+                }
+                if (healthCheck.status === 'error' && (data.status === 'ok' || data.status === 'warn')) {
+                    logger.error(healthCheck.output, '%s in ERROR state', service);
+                    data.status = 'error';
+                    break;
+                }
+            }
+            // No need to continue checking if parent status is already error
+            if (data.status === 'error')
+                break;
+        }
+        if (this.accountability?.admin !== true) {
+            return { status: data.status };
+        }
+        else {
+            return data;
+        }
+        async function testDatabase() {
+            const database = getDatabase();
+            const client = env['DB_CLIENT'];
+            const checks = {};
+            // Response time
+            // ----------------------------------------------------------------------------------------
+            checks[`${client}:responseTime`] = [
+                {
+                    status: 'ok',
+                    componentType: 'datastore',
+                    observedUnit: 'ms',
+                    observedValue: 0,
+                    threshold: env['DB_HEALTHCHECK_THRESHOLD'] ? +env['DB_HEALTHCHECK_THRESHOLD'] : 150,
+                },
+            ];
+            const startTime = performance.now();
+            if (await hasDatabaseConnection()) {
+                checks[`${client}:responseTime`][0].status = 'ok';
+            }
+            else {
+                checks[`${client}:responseTime`][0].status = 'error';
+                checks[`${client}:responseTime`][0].output = `Can't connect to the database.`;
+            }
+            const endTime = performance.now();
+            checks[`${client}:responseTime`][0].observedValue = +(endTime - startTime).toFixed(3);
+            if (checks[`${client}:responseTime`][0].observedValue > checks[`${client}:responseTime`][0].threshold &&
+                checks[`${client}:responseTime`][0].status !== 'error') {
+                checks[`${client}:responseTime`][0].status = 'warn';
+            }
+            checks[`${client}:connectionsAvailable`] = [
+                {
+                    status: 'ok',
+                    componentType: 'datastore',
+                    observedValue: database.client.pool.numFree(),
+                },
+            ];
+            checks[`${client}:connectionsUsed`] = [
+                {
+                    status: 'ok',
+                    componentType: 'datastore',
+                    observedValue: database.client.pool.numUsed(),
+                },
+            ];
+            return checks;
+        }
+        async function testCache() {
+            if (env['CACHE_ENABLED'] !== true) {
+                return {};
+            }
+            const { cache } = getCache();
+            const checks = {
+                'cache:responseTime': [
+                    {
+                        status: 'ok',
+                        componentType: 'cache',
+                        observedValue: 0,
+                        observedUnit: 'ms',
+                        threshold: env['CACHE_HEALTHCHECK_THRESHOLD'] ? +env['CACHE_HEALTHCHECK_THRESHOLD'] : 150,
+                    },
+                ],
+            };
+            const startTime = performance.now();
+            try {
+                await cache.set(`health-${checkID}`, true, 5);
+                await cache.delete(`health-${checkID}`);
+            }
+            catch (err) {
+                checks['cache:responseTime'][0].status = 'error';
+                checks['cache:responseTime'][0].output = err;
+            }
+            finally {
+                const endTime = performance.now();
+                checks['cache:responseTime'][0].observedValue = +(endTime - startTime).toFixed(3);
+                if (checks['cache:responseTime'][0].observedValue > checks['cache:responseTime'][0].threshold &&
+                    checks['cache:responseTime'][0].status !== 'error') {
+                    checks['cache:responseTime'][0].status = 'warn';
+                }
+            }
+            return checks;
+        }
+        async function testRateLimiter() {
+            if (env['RATE_LIMITER_ENABLED'] !== true) {
+                return {};
+            }
+            const checks = {
+                'rateLimiter:responseTime': [
+                    {
+                        status: 'ok',
+                        componentType: 'ratelimiter',
+                        observedValue: 0,
+                        observedUnit: 'ms',
+                        threshold: env['RATE_LIMITER_HEALTHCHECK_THRESHOLD'] ? +env['RATE_LIMITER_HEALTHCHECK_THRESHOLD'] : 150,
+                    },
+                ],
+            };
+            const startTime = performance.now();
+            try {
+                await rateLimiter.consume(`health-${checkID}`, 1);
+                await rateLimiter.delete(`health-${checkID}`);
+            }
+            catch (err) {
+                checks['rateLimiter:responseTime'][0].status = 'error';
+                checks['rateLimiter:responseTime'][0].output = err;
+            }
+            finally {
+                const endTime = performance.now();
+                checks['rateLimiter:responseTime'][0].observedValue = +(endTime - startTime).toFixed(3);
+                if (checks['rateLimiter:responseTime'][0].observedValue > checks['rateLimiter:responseTime'][0].threshold &&
+                    checks['rateLimiter:responseTime'][0].status !== 'error') {
+                    checks['rateLimiter:responseTime'][0].status = 'warn';
+                }
+            }
+            return checks;
+        }
+        async function testRateLimiterGlobal() {
+            if (env['RATE_LIMITER_GLOBAL_ENABLED'] !== true) {
+                return {};
+            }
+            const checks = {
+                'rateLimiterGlobal:responseTime': [
+                    {
+                        status: 'ok',
+                        componentType: 'ratelimiter',
+                        observedValue: 0,
+                        observedUnit: 'ms',
+                        threshold: env['RATE_LIMITER_GLOBAL_HEALTHCHECK_THRESHOLD']
+                            ? +env['RATE_LIMITER_GLOBAL_HEALTHCHECK_THRESHOLD']
+                            : 150,
+                    },
+                ],
+            };
+            const startTime = performance.now();
+            try {
+                await rateLimiterGlobal.consume(`health-${checkID}`, 1);
+                await rateLimiterGlobal.delete(`health-${checkID}`);
+            }
+            catch (err) {
+                checks['rateLimiterGlobal:responseTime'][0].status = 'error';
+                checks['rateLimiterGlobal:responseTime'][0].output = err;
+            }
+            finally {
+                const endTime = performance.now();
+                checks['rateLimiterGlobal:responseTime'][0].observedValue = +(endTime - startTime).toFixed(3);
+                if (checks['rateLimiterGlobal:responseTime'][0].observedValue >
+                    checks['rateLimiterGlobal:responseTime'][0].threshold &&
+                    checks['rateLimiterGlobal:responseTime'][0].status !== 'error') {
+                    checks['rateLimiterGlobal:responseTime'][0].status = 'warn';
+                }
+            }
+            return checks;
+        }
+        async function testStorage() {
+            const storage = await getStorage();
+            const checks = {};
+            for (const location of toArray(env['STORAGE_LOCATIONS'])) {
+                const disk = storage.location(location);
+                const envThresholdKey = `STORAGE_${location}_HEALTHCHECK_THRESHOLD`.toUpperCase();
+                checks[`storage:${location}:responseTime`] = [
+                    {
+                        status: 'ok',
+                        componentType: 'objectstore',
+                        observedValue: 0,
+                        observedUnit: 'ms',
+                        threshold: env[envThresholdKey] ? +env[envThresholdKey] : 750,
+                    },
+                ];
+                const startTime = performance.now();
+                try {
+                    await disk.write(`health-${checkID}`, Readable.from(['check']));
+                    const fileStream = await disk.read(`health-${checkID}`);
+                    fileStream.on('data', async () => {
+                        fileStream.destroy();
+                        await disk.delete(`health-${checkID}`);
+                    });
+                }
+                catch (err) {
+                    checks[`storage:${location}:responseTime`][0].status = 'error';
+                    checks[`storage:${location}:responseTime`][0].output = err;
+                }
+                finally {
+                    const endTime = performance.now();
+                    checks[`storage:${location}:responseTime`][0].observedValue = +(endTime - startTime).toFixed(3);
+                    if (checks[`storage:${location}:responseTime`][0].observedValue >
+                        checks[`storage:${location}:responseTime`][0].threshold &&
+                        checks[`storage:${location}:responseTime`][0].status !== 'error') {
+                        checks[`storage:${location}:responseTime`][0].status = 'warn';
+                    }
+                }
+            }
+            return checks;
+        }
+        async function testEmail() {
+            const checks = {
+                'email:connection': [
+                    {
+                        status: 'ok',
+                        componentType: 'email',
+                    },
+                ],
+            };
+            const mailer = getMailer();
+            try {
+                await mailer.verify();
+            }
+            catch (err) {
+                checks['email:connection'][0].status = 'error';
+                checks['email:connection'][0].output = err;
+            }
+            return checks;
+        }
+    }
+}

package/dist/services/settings.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractServiceOptions } from '../types/index.js';
+import { ItemsService } from './items.js';
+export declare class SettingsService extends ItemsService {
+    constructor(options: AbstractServiceOptions);
+}

package/dist/services/settings.js

@@ -0,0 +1,6 @@
+import { ItemsService } from './items.js';
+export class SettingsService extends ItemsService {
+    constructor(options) {
+        super('directus_settings', options);
+    }
+}

package/dist/services/shares.d.ts

@@ -0,0 +1,17 @@
+import type { AbstractServiceOptions, Item, LoginResult, MutationOptions, PrimaryKey } from '../types/index.js';
+import { AuthorizationService } from './authorization.js';
+import { ItemsService } from './items.js';
+export declare class SharesService extends ItemsService {
+    authorizationService: AuthorizationService;
+    constructor(options: AbstractServiceOptions);
+    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    login(payload: Record<string, any>): Promise<LoginResult>;
+    /**
+     * Send a link to the given share ID to the given email(s). Note: you can only send a link to a share
+     * if you have read access to that particular share
+     */
+    invite(payload: {
+        emails: string[];
+        share: PrimaryKey;
+    }): Promise<void>;
+}