directus 9.24.0 → 9.25.0

package/dist/services/tfa.d.ts

@@ -1,12 +0,0 @@
-import type { Knex } from 'knex';
-import type { AbstractServiceOptions, PrimaryKey } from '../types';
-import { ItemsService } from './items';
-export declare class TFAService {
-    knex: Knex;
-    itemsService: ItemsService;
-    constructor(options: AbstractServiceOptions);
-    verifyOTP(key: PrimaryKey, otp: string, secret?: string): Promise<boolean>;
-    generateTFA(key: PrimaryKey): Promise<Record<string, string>>;
-    enableTFA(key: PrimaryKey, otp: string, secret: string): Promise<void>;
-    disableTFA(key: PrimaryKey): Promise<void>;
-}

package/dist/services/tfa.js

@@ -1,57 +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.TFAService = void 0;
-const otplib_1 = require("otplib");
-const database_1 = __importDefault(require("../database"));
-const exceptions_1 = require("../exceptions");
-const items_1 = require("./items");
-class TFAService {
-    knex;
-    itemsService;
-    constructor(options) {
-        this.knex = options.knex || (0, database_1.default)();
-        this.itemsService = new items_1.ItemsService('directus_users', options);
-    }
-    async verifyOTP(key, otp, secret) {
-        if (secret) {
-            return otplib_1.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 exceptions_1.InvalidPayloadException(`User "${key}" doesn't have TFA enabled.`);
-        }
-        return otplib_1.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 exceptions_1.InvalidPayloadException('TFA Secret is already set for this user');
-        }
-        if (!user?.email) {
-            throw new exceptions_1.InvalidPayloadException('User must have a valid email to enable TFA');
-        }
-        const secret = otplib_1.authenticator.generateSecret();
-        const project = await this.knex.select('project_name').from('directus_settings').limit(1).first();
-        return {
-            secret,
-            url: otplib_1.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 exceptions_1.InvalidPayloadException('TFA Secret is already set for this user');
-        }
-        if (!otplib_1.authenticator.check(otp, secret)) {
-            throw new exceptions_1.InvalidPayloadException(`"otp" is invalid`);
-        }
-        await this.itemsService.updateOne(key, { tfa_secret: secret });
-    }
-    async disableTFA(key) {
-        await this.itemsService.updateOne(key, { tfa_secret: null });
-    }
-}
-exports.TFAService = TFAService;

package/dist/services/users.d.ts

@@ -1,55 +0,0 @@
-import type { Query } from '@directus/shared/types';
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types';
-import { ItemsService } from './items';
-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;
-    /**
-     * 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

@@ -1,380 +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.UsersService = void 0;
-const exceptions_1 = require("@directus/shared/exceptions");
-const utils_1 = require("@directus/shared/utils");
-const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
-const lodash_1 = require("lodash");
-const perf_hooks_1 = require("perf_hooks");
-const database_1 = __importDefault(require("../database"));
-const env_1 = __importDefault(require("../env"));
-const exceptions_2 = require("../exceptions");
-const record_not_unique_1 = require("../exceptions/database/record-not-unique");
-const is_url_allowed_1 = __importDefault(require("../utils/is-url-allowed"));
-const stall_1 = require("../utils/stall");
-const url_1 = require("../utils/url");
-const items_1 = require("./items");
-const mail_1 = require("./mail");
-const settings_1 = require("./settings");
-class UsersService extends items_1.ItemsService {
-    constructor(options) {
-        super('directus_users', options);
-        this.knex = options.knex || (0, database_1.default)();
-        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 record_not_unique_1.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 record_not_unique_1.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 settings_1.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 exceptions_1.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 exceptions_2.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 exceptions_2.UnprocessableEntityException(`You can't change the active status of the last admin user.`);
-        }
-    }
-    /**
-     * 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) {
-        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 exceptions_2.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 record_not_unique_1.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 exceptions_2.InvalidPayloadException(`You can't change the "tfa_secret" value manually.`);
-            }
-            if (data['provider'] !== undefined) {
-                if (this.accountability && this.accountability.admin !== true) {
-                    throw new exceptions_2.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 exceptions_2.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 = (0, lodash_1.cloneDeep)(query);
-        readQuery.fields = [primaryKeyField];
-        // Not authenticated:
-        const itemsService = new items_1.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 && (0, is_url_allowed_1.default)(url, env_1.default['USER_INVITE_URL_ALLOW_LIST']) === false) {
-                throw new exceptions_2.InvalidPayloadException(`Url "${url}" can't be used to invite users.`);
-            }
-        }
-        catch (err) {
-            opts.preMutationException = err;
-        }
-        const emails = (0, utils_1.toArray)(email);
-        const mailService = new mail_1.MailService({
-            schema: this.schema,
-            accountability: this.accountability,
-        });
-        for (const email of emails) {
-            const payload = { email, scope: 'invite' };
-            const token = jsonwebtoken_1.default.sign(payload, env_1.default['SECRET'], { expiresIn: '7d', issuer: 'directus' });
-            const subjectLine = subject ?? "You've been invited";
-            const inviteURL = url ? new url_1.Url(url) : new url_1.Url(env_1.default['PUBLIC_URL']).addPath('admin', 'accept-invite');
-            inviteURL.setQuery('token', token);
-            // Create user first to verify uniqueness
-            await this.createOne({ email, role, status: 'invited' }, opts);
-            await mailService.send({
-                to: email,
-                subject: subjectLine,
-                template: {
-                    name: 'user-invitation',
-                    data: {
-                        url: inviteURL.toString(),
-                        email,
-                    },
-                },
-            });
-        }
-    }
-    async acceptInvite(token, password) {
-        const { email, scope } = jsonwebtoken_1.default.verify(token, env_1.default['SECRET'], { issuer: 'directus' });
-        if (scope !== 'invite')
-            throw new exceptions_2.ForbiddenException();
-        const user = await this.knex.select('id', 'status').from('directus_users').where({ email }).first();
-        if (user?.status !== 'invited') {
-            throw new exceptions_2.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 = perf_hooks_1.performance.now();
-        const user = await this.knex
-            .select('status', 'password')
-            .from('directus_users')
-            .whereRaw('LOWER(??) = ?', ['email', email.toLowerCase()])
-            .first();
-        if (user?.status !== 'active') {
-            await (0, stall_1.stall)(STALL_TIME, timeStart);
-            throw new exceptions_2.ForbiddenException();
-        }
-        if (url && (0, is_url_allowed_1.default)(url, env_1.default['PASSWORD_RESET_URL_ALLOW_LIST']) === false) {
-            throw new exceptions_2.InvalidPayloadException(`Url "${url}" can't be used to reset passwords.`);
-        }
-        const mailService = new mail_1.MailService({
-            schema: this.schema,
-            knex: this.knex,
-            accountability: this.accountability,
-        });
-        const payload = { email, scope: 'password-reset', hash: (0, utils_1.getSimpleHash)('' + user.password) };
-        const token = jsonwebtoken_1.default.sign(payload, env_1.default['SECRET'], { expiresIn: '1d', issuer: 'directus' });
-        const acceptURL = url
-            ? new url_1.Url(url).setQuery('token', token).toString()
-            : new url_1.Url(env_1.default['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 (0, stall_1.stall)(STALL_TIME, timeStart);
-    }
-    async resetPassword(token, password) {
-        const { email, scope, hash } = jsonwebtoken_1.default.verify(token, env_1.default['SECRET'], { issuer: 'directus' });
-        if (scope !== 'password-reset' || !hash)
-            throw new exceptions_2.ForbiddenException();
-        const opts = {};
-        try {
-            await this.checkPasswordPolicy([password]);
-        }
-        catch (err) {
-            opts.preMutationException = err;
-        }
-        const user = await this.knex.select('id', 'status', 'password').from('directus_users').where({ email }).first();
-        if (user?.status !== 'active' || hash !== (0, utils_1.getSimpleHash)('' + user.password)) {
-            throw new exceptions_2.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);
-    }
-}
-exports.UsersService = UsersService;

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

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

package/dist/services/utils.d.ts

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

@@ -1,115 +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.UtilsService = void 0;
-const database_1 = __importDefault(require("../database"));
-const collections_1 = require("../database/system-data/collections");
-const emitter_1 = __importDefault(require("../emitter"));
-const exceptions_1 = require("../exceptions");
-class UtilsService {
-    knex;
-    accountability;
-    schema;
-    constructor(options) {
-        this.knex = options.knex || (0, database_1.default)();
-        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()) ||
-            collections_1.systemCollectionRows;
-        const sortField = sortFieldResponse?.sort_field;
-        if (!sortField) {
-            throw new exceptions_1.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 exceptions_1.ForbiddenException();
-            }
-            const allowedFields = permissions.fields ?? [];
-            if (allowedFields[0] !== '*' && allowedFields.includes(sortField) === false) {
-                throw new exceptions_1.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_1.default.emitAction(['items.sort', `${collection}.items.sort`], {
-            collection,
-            item,
-            to,
-        }, {
-            database: this.knex,
-            schema: this.schema,
-            accountability: this.accountability,
-        });
-    }
-}
-exports.UtilsService = UtilsService;

package/dist/services/webhooks.d.ts

@@ -1,11 +0,0 @@
-import { Messenger } from '../messenger';
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey, Webhook } from '../types';
-import { ItemsService } from './items';
-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[]>;
-}