directus 9.23.4 → 9.25.0

package/dist/services/roles.d.ts

@@ -1,14 +0,0 @@
-import type { Query } from '@directus/shared/types';
-import type { AbstractServiceOptions, MutationOptions, PrimaryKey } from '../types';
-import { ItemsService } from './items';
-export declare class RolesService extends ItemsService {
-    constructor(options: AbstractServiceOptions);
-    private checkForOtherAdminRoles;
-    private checkForOtherAdminUsers;
-    updateOne(key: PrimaryKey, data: Record<string, any>, opts?: MutationOptions): Promise<PrimaryKey>;
-    updateBatch(data: Record<string, any>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
-    updateMany(keys: PrimaryKey[], data: Record<string, any>, opts?: MutationOptions): Promise<PrimaryKey[]>;
-    deleteOne(key: PrimaryKey): Promise<PrimaryKey>;
-    deleteMany(keys: PrimaryKey[]): Promise<PrimaryKey[]>;
-    deleteByQuery(query: Query, opts?: MutationOptions): Promise<PrimaryKey[]>;
-}

package/dist/services/roles.js

@@ -1,148 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RolesService = void 0;
-const exceptions_1 = require("../exceptions");
-const items_1 = require("./items");
-const permissions_1 = require("./permissions");
-const presets_1 = require("./presets");
-const users_1 = require("./users");
-class RolesService extends items_1.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 exceptions_1.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 exceptions_1.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 exceptions_1.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 items_1.ItemsService('directus_roles', {
-                knex: trx,
-                accountability: this.accountability,
-                schema: this.schema,
-            });
-            const permissionsService = new permissions_1.PermissionsService({
-                knex: trx,
-                accountability: this.accountability,
-                schema: this.schema,
-            });
-            const presetsService = new presets_1.PresetsService({
-                knex: trx,
-                accountability: this.accountability,
-                schema: this.schema,
-            });
-            const usersService = new users_1.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);
-            await presetsService.deleteByQuery({
-                filter: { role: { _in: keys } },
-            }, opts);
-            await usersService.updateByQuery({
-                filter: { role: { _in: keys } },
-            }, {
-                status: 'suspended',
-                role: null,
-            }, opts);
-            await itemsService.deleteMany(keys, opts);
-        });
-        return keys;
-    }
-    deleteByQuery(query, opts) {
-        return super.deleteByQuery(query, opts);
-    }
-}
-exports.RolesService = RolesService;

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

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

package/dist/services/schema.d.ts

@@ -1,15 +0,0 @@
-import type { Accountability } from '@directus/shared/types';
-import type { Knex } from 'knex';
-import type { AbstractServiceOptions, Snapshot, SnapshotDiff, SnapshotDiffWithHash, SnapshotWithHash } from '../types';
-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

@@ -1,56 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaService = void 0;
-const database_1 = __importDefault(require("../database"));
-const exceptions_1 = require("../exceptions");
-const apply_diff_1 = require("../utils/apply-diff");
-const get_snapshot_1 = require("../utils/get-snapshot");
-const get_snapshot_diff_1 = require("../utils/get-snapshot-diff");
-const get_versioned_hash_1 = require("../utils/get-versioned-hash");
-const validate_diff_1 = require("../utils/validate-diff");
-const validate_snapshot_1 = require("../utils/validate-snapshot");
-class SchemaService {
-    knex;
-    accountability;
-    constructor(options) {
-        this.knex = options.knex ?? (0, database_1.default)();
-        this.accountability = options.accountability ?? null;
-    }
-    async snapshot() {
-        if (this.accountability?.admin !== true)
-            throw new exceptions_1.ForbiddenException();
-        const currentSnapshot = await (0, get_snapshot_1.getSnapshot)({ database: this.knex });
-        return currentSnapshot;
-    }
-    async apply(payload) {
-        if (this.accountability?.admin !== true)
-            throw new exceptions_1.ForbiddenException();
-        const currentSnapshot = await this.snapshot();
-        const snapshotWithHash = this.getHashedSnapshot(currentSnapshot);
-        if (!(0, validate_diff_1.validateApplyDiff)(payload, snapshotWithHash))
-            return;
-        await (0, apply_diff_1.applyDiff)(currentSnapshot, payload.diff, { database: this.knex });
-    }
-    async diff(snapshot, options) {
-        if (this.accountability?.admin !== true)
-            throw new exceptions_1.ForbiddenException();
-        (0, validate_snapshot_1.validateSnapshot)(snapshot, options?.force);
-        const currentSnapshot = options?.currentSnapshot ?? (await (0, get_snapshot_1.getSnapshot)({ database: this.knex }));
-        const diff = (0, get_snapshot_diff_1.getSnapshotDiff)(currentSnapshot, snapshot);
-        if (diff.collections.length === 0 && diff.fields.length === 0 && diff.relations.length === 0) {
-            return null;
-        }
-        return diff;
-    }
-    getHashedSnapshot(snapshot) {
-        const snapshotHash = (0, get_versioned_hash_1.getVersionedHash)(snapshot);
-        return {
-            ...snapshot,
-            hash: snapshotHash,
-        };
-    }
-}
-exports.SchemaService = SchemaService;

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

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

package/dist/services/server.d.ts

@@ -1,13 +0,0 @@
-import type { Knex } from 'knex';
-import type { Accountability, SchemaOverview } from '@directus/shared/types';
-import type { AbstractServiceOptions } from '../types';
-import { SettingsService } from './settings';
-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

@@ -1,366 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerService = void 0;
-const lodash_1 = require("lodash");
-const os_1 = __importDefault(require("os"));
-const perf_hooks_1 = require("perf_hooks");
-const utils_1 = require("@directus/shared/utils");
-const node_stream_1 = require("node:stream");
-// @ts-ignore
-const package_json_1 = require("../../package.json");
-const cache_1 = require("../cache");
-const database_1 = __importStar(require("../database"));
-const env_1 = __importDefault(require("../env"));
-const logger_1 = __importDefault(require("../logger"));
-const mailer_1 = __importDefault(require("../mailer"));
-const rate_limiter_global_1 = require("../middleware/rate-limiter-global");
-const rate_limiter_ip_1 = require("../middleware/rate-limiter-ip");
-const storage_1 = require("../storage");
-const get_os_info_1 = require("../utils/get-os-info");
-const settings_1 = require("./settings");
-class ServerService {
-    knex;
-    accountability;
-    settingsService;
-    schema;
-    constructor(options) {
-        this.knex = options.knex || (0, database_1.default)();
-        this.accountability = options.accountability || null;
-        this.schema = options.schema;
-        this.settingsService = new settings_1.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_1.default['RATE_LIMITER_ENABLED']) {
-                info['rateLimit'] = {
-                    points: env_1.default['RATE_LIMITER_POINTS'],
-                    duration: env_1.default['RATE_LIMITER_DURATION'],
-                };
-            }
-            else {
-                info['rateLimit'] = false;
-            }
-            if (env_1.default['RATE_LIMITER_GLOBAL_ENABLED']) {
-                info['rateLimitGlobal'] = {
-                    points: env_1.default['RATE_LIMITER_GLOBAL_POINTS'],
-                    duration: env_1.default['RATE_LIMITER_GLOBAL_DURATION'],
-                };
-            }
-            else {
-                info['rateLimitGlobal'] = false;
-            }
-            info['flows'] = {
-                execAllowedModules: env_1.default['FLOWS_EXEC_ALLOWED_MODULES'] ? (0, utils_1.toArray)(env_1.default['FLOWS_EXEC_ALLOWED_MODULES']) : [],
-            };
-        }
-        if (this.accountability?.admin === true) {
-            const { osType, osVersion } = (0, get_os_info_1.getOSInfo)();
-            info['directus'] = {
-                version: package_json_1.version,
-            };
-            info['node'] = {
-                version: process.versions.node,
-                uptime: Math.round(process.uptime()),
-            };
-            info['os'] = {
-                type: osType,
-                version: osVersion,
-                uptime: Math.round(os_1.default.uptime()),
-                totalmem: os_1.default.totalmem(),
-            };
-        }
-        return info;
-    }
-    async health() {
-        const { nanoid } = await import('nanoid');
-        const checkID = nanoid(5);
-        const data = {
-            status: 'ok',
-            releaseId: package_json_1.version,
-            serviceId: env_1.default['KEY'],
-            checks: (0, lodash_1.merge)(...(await Promise.all([
-                testDatabase(),
-                testCache(),
-                testRateLimiter(),
-                testRateLimiterGlobal(),
-                testStorage(),
-                testEmail(),
-            ]))),
-        };
-        for (const [service, healthData] of Object.entries(data.checks)) {
-            for (const healthCheck of healthData) {
-                if (healthCheck.status === 'warn' && data.status === 'ok') {
-                    logger_1.default.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_1.default.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 = (0, database_1.default)();
-            const client = env_1.default['DB_CLIENT'];
-            const checks = {};
-            // Response time
-            // ----------------------------------------------------------------------------------------
-            checks[`${client}:responseTime`] = [
-                {
-                    status: 'ok',
-                    componentType: 'datastore',
-                    observedUnit: 'ms',
-                    observedValue: 0,
-                    threshold: env_1.default['DB_HEALTHCHECK_THRESHOLD'] ? +env_1.default['DB_HEALTHCHECK_THRESHOLD'] : 150,
-                },
-            ];
-            const startTime = perf_hooks_1.performance.now();
-            if (await (0, database_1.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 = perf_hooks_1.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_1.default['CACHE_ENABLED'] !== true) {
-                return {};
-            }
-            const { cache } = (0, cache_1.getCache)();
-            const checks = {
-                'cache:responseTime': [
-                    {
-                        status: 'ok',
-                        componentType: 'cache',
-                        observedValue: 0,
-                        observedUnit: 'ms',
-                        threshold: env_1.default['CACHE_HEALTHCHECK_THRESHOLD'] ? +env_1.default['CACHE_HEALTHCHECK_THRESHOLD'] : 150,
-                    },
-                ],
-            };
-            const startTime = perf_hooks_1.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 = perf_hooks_1.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_1.default['RATE_LIMITER_ENABLED'] !== true) {
-                return {};
-            }
-            const checks = {
-                'rateLimiter:responseTime': [
-                    {
-                        status: 'ok',
-                        componentType: 'ratelimiter',
-                        observedValue: 0,
-                        observedUnit: 'ms',
-                        threshold: env_1.default['RATE_LIMITER_HEALTHCHECK_THRESHOLD'] ? +env_1.default['RATE_LIMITER_HEALTHCHECK_THRESHOLD'] : 150,
-                    },
-                ],
-            };
-            const startTime = perf_hooks_1.performance.now();
-            try {
-                await rate_limiter_ip_1.rateLimiter.consume(`health-${checkID}`, 1);
-                await rate_limiter_ip_1.rateLimiter.delete(`health-${checkID}`);
-            }
-            catch (err) {
-                checks['rateLimiter:responseTime'][0].status = 'error';
-                checks['rateLimiter:responseTime'][0].output = err;
-            }
-            finally {
-                const endTime = perf_hooks_1.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_1.default['RATE_LIMITER_GLOBAL_ENABLED'] !== true) {
-                return {};
-            }
-            const checks = {
-                'rateLimiterGlobal:responseTime': [
-                    {
-                        status: 'ok',
-                        componentType: 'ratelimiter',
-                        observedValue: 0,
-                        observedUnit: 'ms',
-                        threshold: env_1.default['RATE_LIMITER_GLOBAL_HEALTHCHECK_THRESHOLD']
-                            ? +env_1.default['RATE_LIMITER_GLOBAL_HEALTHCHECK_THRESHOLD']
-                            : 150,
-                    },
-                ],
-            };
-            const startTime = perf_hooks_1.performance.now();
-            try {
-                await rate_limiter_global_1.rateLimiterGlobal.consume(`health-${checkID}`, 1);
-                await rate_limiter_global_1.rateLimiterGlobal.delete(`health-${checkID}`);
-            }
-            catch (err) {
-                checks['rateLimiterGlobal:responseTime'][0].status = 'error';
-                checks['rateLimiterGlobal:responseTime'][0].output = err;
-            }
-            finally {
-                const endTime = perf_hooks_1.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 (0, storage_1.getStorage)();
-            const checks = {};
-            for (const location of (0, utils_1.toArray)(env_1.default['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_1.default[envThresholdKey] ? +env_1.default[envThresholdKey] : 750,
-                    },
-                ];
-                const startTime = perf_hooks_1.performance.now();
-                try {
-                    await disk.write(`health-${checkID}`, node_stream_1.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 = perf_hooks_1.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 = (0, mailer_1.default)();
-            try {
-                await mailer.verify();
-            }
-            catch (err) {
-                checks['email:connection'][0].status = 'error';
-                checks['email:connection'][0].output = err;
-            }
-            return checks;
-        }
-    }
-}
-exports.ServerService = ServerService;

package/dist/services/settings.d.ts

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

package/dist/services/settings.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SettingsService = void 0;
-const items_1 = require("./items");
-class SettingsService extends items_1.ItemsService {
-    constructor(options) {
-        super('directus_settings', options);
-    }
-}
-exports.SettingsService = SettingsService;

package/dist/services/shares.d.ts

@@ -1,17 +0,0 @@
-import type { AbstractServiceOptions, Item, LoginResult, MutationOptions, PrimaryKey } from '../types';
-import { AuthorizationService } from './authorization';
-import { ItemsService } from './items';
-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>;
-}