@directus/api 9.25.0

package/dist/services/tfa.js

@@ -0,0 +1,50 @@
+import { authenticator } from 'otplib';
+import getDatabase from '../database/index.js';
+import { InvalidPayloadException } from '../exceptions/index.js';
+import { ItemsService } from './items.js';
+export class TFAService {
+    knex;
+    itemsService;
+    constructor(options) {
+        this.knex = options.knex || getDatabase();
+        this.itemsService = new ItemsService('directus_users', options);
+    }
+    async verifyOTP(key, otp, secret) {
+        if (secret) {
+            return authenticator.check(otp, secret);
+        }
+        const user = await this.knex.select('tfa_secret').from('directus_users').where({ id: key }).first();
+        if (!user?.tfa_secret) {
+            throw new InvalidPayloadException(`User "${key}" doesn't have TFA enabled.`);
+        }
+        return authenticator.check(otp, user.tfa_secret);
+    }
+    async generateTFA(key) {
+        const user = await this.knex.select('email', 'tfa_secret').from('directus_users').where({ id: key }).first();
+        if (user?.tfa_secret !== null) {
+            throw new InvalidPayloadException('TFA Secret is already set for this user');
+        }
+        if (!user?.email) {
+            throw new InvalidPayloadException('User must have a valid email to enable TFA');
+        }
+        const secret = authenticator.generateSecret();
+        const project = await this.knex.select('project_name').from('directus_settings').limit(1).first();
+        return {
+            secret,
+            url: authenticator.keyuri(user.email, project?.project_name || 'Directus', secret),
+        };
+    }
+    async enableTFA(key, otp, secret) {
+        const user = await this.knex.select('tfa_secret').from('directus_users').where({ id: key }).first();
+        if (user?.tfa_secret !== null) {
+            throw new InvalidPayloadException('TFA Secret is already set for this user');
+        }
+        if (!authenticator.check(otp, secret)) {
+            throw new InvalidPayloadException(`"otp" is invalid`);
+        }
+        await this.itemsService.updateOne(key, { tfa_secret: secret });
+    }
+    async disableTFA(key) {
+        await this.itemsService.updateOne(key, { tfa_secret: null });
+    }
+}

package/dist/services/users.d.ts

@@ -0,0 +1,63 @@
+import type { Query } from '@directus/types';
+import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
+import { ItemsService } from './items.js';
+export declare class UsersService extends ItemsService {
+    constructor(options: AbstractServiceOptions);
+    /**
+     * User email has to be unique case-insensitive. This is an additional check to make sure that
+     * the email is unique regardless of casing
+     */
+    private checkUniqueEmails;
+    /**
+     * Check if the provided password matches the strictness as configured in
+     * directus_settings.auth_password_policy
+     */
+    private checkPasswordPolicy;
+    private checkRemainingAdminExistence;
+    /**
+     * Make sure there's at least one active admin user when updating user status
+     */
+    private checkRemainingActiveAdmin;
+    /**
+     * Get basic information of user identified by email
+     */
+    private getUserByEmail;
+    /**
+     * Create url for inviting users
+     */
+    private inviteUrl;
+    /**
+     * Create a new user
+     */
+    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    /**
+     * Create multiple new users
+     */
+    createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    /**
+     * Update many users by query
+     */
+    updateByQuery(query: Query, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    /**
+     * Update a single user by primary key
+     */
+    updateOne(key: PrimaryKey, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    updateBatch(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    /**
+     * Update many users by primary key
+     */
+    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    /**
+     * Delete a single user by primary key
+     */
+    deleteOne(key: PrimaryKey, opts?: MutationOptions): Promise<PrimaryKey>;
+    /**
+     * Delete multiple users by primary key
+     */
+    deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    deleteByQuery(query: Query, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    inviteUser(email: string | string[], role: string, url: string | null, subject?: string | null): Promise<void>;
+    acceptInvite(token: string, password: string): Promise<void>;
+    requestPasswordReset(email: string, url: string | null, subject?: string | null): Promise<void>;
+    resetPassword(token: string, password: string): Promise<void>;
+}

package/dist/services/users.js

@@ -0,0 +1,399 @@
+import { FailedValidationException } from '@directus/exceptions';
+import { getSimpleHash, toArray } from '@directus/utils';
+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 { RecordNotUniqueException } from '../exceptions/database/record-not-unique.js';
+import { ForbiddenException, InvalidPayloadException, UnprocessableEntityException } from '../exceptions/index.js';
+import isUrlAllowed from '../utils/is-url-allowed.js';
+import { verifyJWT } from '../utils/jwt.js';
+import { stall } from '../utils/stall.js';
+import { Url } from '../utils/url.js';
+import { ItemsService } from './items.js';
+import { MailService } from './mail/index.js';
+import { SettingsService } from './settings.js';
+export class UsersService extends ItemsService {
+    constructor(options) {
+        super('directus_users', options);
+        this.knex = options.knex || getDatabase();
+        this.accountability = options.accountability || null;
+        this.schema = options.schema;
+    }
+    /**
+     * User email has to be unique case-insensitive. This is an additional check to make sure that
+     * the email is unique regardless of casing
+     */
+    async checkUniqueEmails(emails, excludeKey) {
+        emails = emails.map((email) => email.toLowerCase());
+        const duplicates = emails.filter((value, index, array) => array.indexOf(value) !== index);
+        if (duplicates.length) {
+            throw new RecordNotUniqueException('email', {
+                collection: 'directus_users',
+                field: 'email',
+                invalid: duplicates[0],
+            });
+        }
+        const query = this.knex
+            .select('email')
+            .from('directus_users')
+            .whereRaw(`LOWER(??) IN (${emails.map(() => '?')})`, ['email', ...emails]);
+        if (excludeKey) {
+            query.whereNot('id', excludeKey);
+        }
+        const results = await query;
+        if (results.length) {
+            throw new RecordNotUniqueException('email', {
+                collection: 'directus_users',
+                field: 'email',
+                invalid: results[0].email,
+            });
+        }
+    }
+    /**
+     * Check if the provided password matches the strictness as configured in
+     * directus_settings.auth_password_policy
+     */
+    async checkPasswordPolicy(passwords) {
+        const settingsService = new SettingsService({
+            schema: this.schema,
+            knex: this.knex,
+        });
+        const { auth_password_policy: policyRegExString } = await settingsService.readSingleton({
+            fields: ['auth_password_policy'],
+        });
+        if (!policyRegExString) {
+            return;
+        }
+        const wrapped = policyRegExString.startsWith('/') && policyRegExString.endsWith('/');
+        const regex = new RegExp(wrapped ? policyRegExString.slice(1, -1) : policyRegExString);
+        for (const password of passwords) {
+            if (!regex.test(password)) {
+                throw new FailedValidationException({
+                    message: `Provided password doesn't match password policy`,
+                    path: ['password'],
+                    type: 'custom.pattern.base',
+                    context: {
+                        value: password,
+                    },
+                });
+            }
+        }
+    }
+    async checkRemainingAdminExistence(excludeKeys) {
+        // Make sure there's at least one admin user left after this deletion is done
+        const otherAdminUsers = await this.knex
+            .count('*', { as: 'count' })
+            .from('directus_users')
+            .whereNotIn('directus_users.id', excludeKeys)
+            .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 role.`);
+        }
+    }
+    /**
+     * Make sure there's at least one active admin user when updating user status
+     */
+    async checkRemainingActiveAdmin(excludeKeys) {
+        const otherAdminUsers = await this.knex
+            .count('*', { as: 'count' })
+            .from('directus_users')
+            .whereNotIn('directus_users.id', excludeKeys)
+            .andWhere({ 'directus_roles.admin_access': true })
+            .andWhere({ 'directus_users.status': 'active' })
+            .leftJoin('directus_roles', 'directus_users.role', 'directus_roles.id')
+            .first();
+        const otherAdminUsersCount = +(otherAdminUsers?.count || 0);
+        if (otherAdminUsersCount === 0) {
+            throw new UnprocessableEntityException(`You can't change the active status of the last admin user.`);
+        }
+    }
+    /**
+     * Get basic information of user identified by email
+     */
+    async getUserByEmail(email) {
+        return await this.knex
+            .select('id', 'role', 'status', 'password')
+            .from('directus_users')
+            .whereRaw(`LOWER(??) = ?`, ['email', email.toLowerCase()])
+            .first();
+    }
+    /**
+     * Create url for inviting users
+     */
+    inviteUrl(email, url) {
+        const payload = { email, scope: 'invite' };
+        const token = jwt.sign(payload, env['SECRET'], { expiresIn: '7d', issuer: 'directus' });
+        const inviteURL = url ? new Url(url) : new Url(env['PUBLIC_URL']).addPath('admin', 'accept-invite');
+        inviteURL.setQuery('token', token);
+        return inviteURL.toString();
+    }
+    /**
+     * Create a new user
+     */
+    async createOne(data, opts) {
+        const result = await this.createMany([data], opts);
+        return result[0];
+    }
+    /**
+     * Create multiple new users
+     */
+    async createMany(data, opts) {
+        const emails = data['map']((payload) => payload['email']).filter((email) => email);
+        const passwords = data['map']((payload) => payload['password']).filter((password) => password);
+        try {
+            if (emails.length) {
+                await this.checkUniqueEmails(emails);
+            }
+            if (passwords.length) {
+                await this.checkPasswordPolicy(passwords);
+            }
+        }
+        catch (err) {
+            (opts || (opts = {})).preMutationException = err;
+        }
+        return await super.createMany(data, opts);
+    }
+    /**
+     * Update many users by query
+     */
+    async updateByQuery(query, data, opts) {
+        const keys = await this.getKeysByQuery(query);
+        return keys.length ? await this.updateMany(keys, data, opts) : [];
+    }
+    /**
+     * Update a single user by primary key
+     */
+    async updateOne(key, data, opts) {
+        await this.updateMany([key], data, opts);
+        return key;
+    }
+    async updateBatch(data, opts = {}) {
+        if (!opts.mutationTracker)
+            opts.mutationTracker = this.createMutationTracker();
+        const primaryKeyField = this.schema.collections[this.collection].primary;
+        const keys = [];
+        await this.knex.transaction(async (trx) => {
+            const service = new UsersService({
+                accountability: this.accountability,
+                knex: trx,
+                schema: this.schema,
+            });
+            for (const item of data) {
+                if (!item[primaryKeyField])
+                    throw new InvalidPayloadException(`User in update misses primary key.`);
+                keys.push(await service.updateOne(item[primaryKeyField], item, opts));
+            }
+        });
+        return keys;
+    }
+    /**
+     * Update many users by primary key
+     */
+    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();
+                if (!newRole?.admin_access) {
+                    await this.checkRemainingAdminExistence(keys);
+                }
+            }
+            if (data['status'] !== undefined && data['status'] !== 'active') {
+                await this.checkRemainingActiveAdmin(keys);
+            }
+            if (data['email']) {
+                if (keys.length > 1) {
+                    throw new RecordNotUniqueException('email', {
+                        collection: 'directus_users',
+                        field: 'email',
+                        invalid: data['email'],
+                    });
+                }
+                await this.checkUniqueEmails([data['email']], keys[0]);
+            }
+            if (data['password']) {
+                await this.checkPasswordPolicy([data['password']]);
+            }
+            if (data['tfa_secret'] !== undefined) {
+                throw new InvalidPayloadException(`You can't change the "tfa_secret" value manually.`);
+            }
+            if (data['provider'] !== undefined) {
+                if (this.accountability && this.accountability.admin !== true) {
+                    throw new InvalidPayloadException(`You can't change the "provider" value manually.`);
+                }
+                data['auth_data'] = null;
+            }
+            if (data['external_identifier'] !== undefined) {
+                if (this.accountability && this.accountability.admin !== true) {
+                    throw new InvalidPayloadException(`You can't change the "external_identifier" value manually.`);
+                }
+                data['auth_data'] = null;
+            }
+        }
+        catch (err) {
+            (opts || (opts = {})).preMutationException = err;
+        }
+        return await super.updateMany(keys, data, opts);
+    }
+    /**
+     * Delete a single user by primary key
+     */
+    async deleteOne(key, opts) {
+        await this.deleteMany([key], opts);
+        return key;
+    }
+    /**
+     * Delete multiple users by primary key
+     */
+    async deleteMany(keys, opts) {
+        try {
+            await this.checkRemainingAdminExistence(keys);
+        }
+        catch (err) {
+            (opts || (opts = {})).preMutationException = err;
+        }
+        await this.knex('directus_notifications').update({ sender: null }).whereIn('sender', keys);
+        await super.deleteMany(keys, opts);
+        return keys;
+    }
+    async deleteByQuery(query, opts) {
+        const primaryKeyField = this.schema.collections[this.collection].primary;
+        const readQuery = cloneDeep(query);
+        readQuery.fields = [primaryKeyField];
+        // Not authenticated:
+        const itemsService = new ItemsService(this.collection, {
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const itemsToDelete = await itemsService.readByQuery(readQuery);
+        const keys = itemsToDelete.map((item) => item[primaryKeyField]);
+        if (keys.length === 0)
+            return [];
+        return await this.deleteMany(keys, opts);
+    }
+    async inviteUser(email, role, url, subject) {
+        const opts = {};
+        try {
+            if (url && isUrlAllowed(url, env['USER_INVITE_URL_ALLOW_LIST']) === false) {
+                throw new InvalidPayloadException(`Url "${url}" can't be used to invite users.`);
+            }
+        }
+        catch (err) {
+            opts.preMutationException = err;
+        }
+        const emails = toArray(email);
+        const mailService = new MailService({
+            schema: this.schema,
+            accountability: this.accountability,
+        });
+        for (const email of emails) {
+            // Check if user is known
+            const user = await this.getUserByEmail(email);
+            // Create user first to verify uniqueness if unknown
+            if (isEmpty(user)) {
+                await this.createOne({ email, role, status: 'invited' }, opts);
+                // For known users update role if changed
+            }
+            else if (user.status === 'invited' && user.role !== role) {
+                await this.updateOne(user.id, { role }, opts);
+            }
+            // Send invite for new and already invited users
+            if (isEmpty(user) || user.status === 'invited') {
+                const subjectLine = subject ?? "You've been invited";
+                await mailService.send({
+                    to: email,
+                    subject: subjectLine,
+                    template: {
+                        name: 'user-invitation',
+                        data: {
+                            url: this.inviteUrl(email, url),
+                            email,
+                        },
+                    },
+                });
+            }
+        }
+    }
+    async acceptInvite(token, password) {
+        const { email, scope } = verifyJWT(token, env['SECRET']);
+        if (scope !== 'invite')
+            throw new ForbiddenException();
+        const user = await this.getUserByEmail(email);
+        if (user?.status !== 'invited') {
+            throw new InvalidPayloadException(`Email address ${email} hasn't been invited.`);
+        }
+        // Allow unauthenticated update
+        const service = new UsersService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        await service.updateOne(user.id, { password, status: 'active' });
+    }
+    async requestPasswordReset(email, url, subject) {
+        const STALL_TIME = 500;
+        const timeStart = performance.now();
+        const user = await this.getUserByEmail(email);
+        if (user?.status !== 'active') {
+            await stall(STALL_TIME, timeStart);
+            throw new ForbiddenException();
+        }
+        if (url && isUrlAllowed(url, env['PASSWORD_RESET_URL_ALLOW_LIST']) === false) {
+            throw new InvalidPayloadException(`Url "${url}" can't be used to reset passwords.`);
+        }
+        const mailService = new MailService({
+            schema: this.schema,
+            knex: this.knex,
+            accountability: this.accountability,
+        });
+        const payload = { 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,
+            subject: subjectLine,
+            template: {
+                name: 'password-reset',
+                data: {
+                    url: acceptURL,
+                    email,
+                },
+            },
+        });
+        await stall(STALL_TIME, timeStart);
+    }
+    async resetPassword(token, password) {
+        const { email, scope, hash } = jwt.verify(token, env['SECRET'], { issuer: 'directus' });
+        if (scope !== 'password-reset' || !hash)
+            throw new ForbiddenException();
+        const opts = {};
+        try {
+            await this.checkPasswordPolicy([password]);
+        }
+        catch (err) {
+            opts.preMutationException = err;
+        }
+        const user = await this.getUserByEmail(email);
+        if (user?.status !== 'active' || hash !== getSimpleHash('' + user.password)) {
+            throw new ForbiddenException();
+        }
+        // Allow unauthenticated update
+        const service = new UsersService({
+            knex: this.knex,
+            schema: this.schema,
+            accountability: {
+                ...(this.accountability ?? { role: null }),
+                admin: true, // We need to skip permissions checks for the update call below
+            },
+        });
+        await service.updateOne(user.id, { password, status: 'active' }, opts);
+    }
+}

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

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

package/dist/services/utils.d.ts

@@ -0,0 +1,13 @@
+import type { Accountability, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { AbstractServiceOptions, PrimaryKey } from '../types/index.js';
+export declare class UtilsService {
+    knex: Knex;
+    accountability: Accountability | null;
+    schema: SchemaOverview;
+    constructor(options: AbstractServiceOptions);
+    sort(collection: string, { item, to }: {
+        item: PrimaryKey;
+        to: PrimaryKey;
+    }): Promise<void>;
+}

package/dist/services/utils.js

@@ -0,0 +1,108 @@
+import getDatabase from '../database/index.js';
+import { systemCollectionRows } from '../database/system-data/collections/index.js';
+import emitter from '../emitter.js';
+import { ForbiddenException, InvalidPayloadException } from '../exceptions/index.js';
+export class UtilsService {
+    knex;
+    accountability;
+    schema;
+    constructor(options) {
+        this.knex = options.knex || getDatabase();
+        this.accountability = options.accountability || null;
+        this.schema = options.schema;
+    }
+    async sort(collection, { item, to }) {
+        const sortFieldResponse = (await this.knex.select('sort_field').from('directus_collections').where({ collection }).first()) ||
+            systemCollectionRows;
+        const sortField = sortFieldResponse?.sort_field;
+        if (!sortField) {
+            throw new InvalidPayloadException(`Collection "${collection}" doesn't have a sort field.`);
+        }
+        if (this.accountability?.admin !== true) {
+            const permissions = this.accountability?.permissions?.find((permission) => {
+                return permission.collection === collection && permission.action === 'update';
+            });
+            if (!permissions) {
+                throw new ForbiddenException();
+            }
+            const allowedFields = permissions.fields ?? [];
+            if (allowedFields[0] !== '*' && allowedFields.includes(sortField) === false) {
+                throw new ForbiddenException();
+            }
+        }
+        const primaryKeyField = this.schema.collections[collection].primary;
+        // Make sure all rows have a sort value
+        const countResponse = await this.knex.count('* as count').from(collection).whereNull(sortField).first();
+        if (countResponse?.count && +countResponse.count !== 0) {
+            const lastSortValueResponse = await this.knex.max(sortField).from(collection).first();
+            const rowsWithoutSortValue = await this.knex
+                .select(primaryKeyField, sortField)
+                .from(collection)
+                .whereNull(sortField);
+            let lastSortValue = lastSortValueResponse ? Object.values(lastSortValueResponse)[0] : 0;
+            for (const row of rowsWithoutSortValue) {
+                lastSortValue++;
+                await this.knex(collection)
+                    .update({ [sortField]: lastSortValue })
+                    .where({ [primaryKeyField]: row[primaryKeyField] });
+            }
+        }
+        // Check to see if there's any duplicate values in the sort counts. If that's the case, we'll have to
+        // reset the count values, otherwise the sort operation will cause unexpected results
+        const duplicates = await this.knex
+            .select(sortField)
+            .count(sortField, { as: 'count' })
+            .groupBy(sortField)
+            .from(collection)
+            .havingRaw('count(??) > 1', [sortField]);
+        if (duplicates?.length > 0) {
+            const ids = await this.knex.select(primaryKeyField).from(collection).orderBy(sortField);
+            // This might not scale that well, but I don't really know how to accurately set all rows
+            // to a sequential value that works cross-DB vendor otherwise
+            for (let i = 0; i < ids.length; i++) {
+                await this.knex(collection)
+                    .update({ [sortField]: i + 1 })
+                    .where(ids[i]);
+            }
+        }
+        const targetSortValueResponse = await this.knex
+            .select(sortField)
+            .from(collection)
+            .where({ [primaryKeyField]: to })
+            .first();
+        const targetSortValue = targetSortValueResponse[sortField];
+        const sourceSortValueResponse = await this.knex
+            .select(sortField)
+            .from(collection)
+            .where({ [primaryKeyField]: item })
+            .first();
+        const sourceSortValue = sourceSortValueResponse[sortField];
+        // Set the target item to the new sort value
+        await this.knex(collection)
+            .update({ [sortField]: targetSortValue })
+            .where({ [primaryKeyField]: item });
+        if (sourceSortValue < targetSortValue) {
+            await this.knex(collection)
+                .decrement(sortField, 1)
+                .where(sortField, '>', sourceSortValue)
+                .andWhere(sortField, '<=', targetSortValue)
+                .andWhereNot({ [primaryKeyField]: item });
+        }
+        else {
+            await this.knex(collection)
+                .increment(sortField, 1)
+                .where(sortField, '>=', targetSortValue)
+                .andWhere(sortField, '<=', sourceSortValue)
+                .andWhereNot({ [primaryKeyField]: item });
+        }
+        emitter.emitAction(['items.sort', `${collection}.items.sort`], {
+            collection,
+            item,
+            to,
+        }, {
+            database: this.knex,
+            schema: this.schema,
+            accountability: this.accountability,
+        });
+    }
+}

package/dist/services/webhooks.d.ts

@@ -0,0 +1,11 @@
+import { Messenger } from '../messenger.js';
+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;
+    constructor(options: AbstractServiceOptions);
+    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+}

package/dist/services/webhooks.js

@@ -0,0 +1,29 @@
+import { getMessenger } from '../messenger.js';
+import { ItemsService } from './items.js';
+export class WebhooksService extends ItemsService {
+    messenger;
+    constructor(options) {
+        super('directus_webhooks', options);
+        this.messenger = getMessenger();
+    }
+    async createOne(data, opts) {
+        const result = await super.createOne(data, opts);
+        this.messenger.publish('webhooks', { type: 'reload' });
+        return result;
+    }
+    async createMany(data, opts) {
+        const result = await super.createMany(data, opts);
+        this.messenger.publish('webhooks', { type: 'reload' });
+        return result;
+    }
+    async updateMany(keys, data, opts) {
+        const result = await super.updateMany(keys, data, opts);
+        this.messenger.publish('webhooks', { type: 'reload' });
+        return result;
+    }
+    async deleteMany(keys, opts) {
+        const result = await super.deleteMany(keys, opts);
+        this.messenger.publish('webhooks', { type: 'reload' });
+        return result;
+    }
+}

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

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