@directus/api 32.2.0 → 33.0.0

package/dist/controllers/webhooks.js

@@ -1,74 +0,0 @@
-import { ErrorCode, createError } from '@directus/errors';
-import express from 'express';
-import { respond } from '../middleware/respond.js';
-import useCollection from '../middleware/use-collection.js';
-import { validateBatch } from '../middleware/validate-batch.js';
-import { MetaService } from '../services/meta.js';
-import { WebhooksService } from '../services/webhooks.js';
-import asyncHandler from '../utils/async-handler.js';
-import { sanitizeQuery } from '../utils/sanitize-query.js';
-const router = express.Router();
-router.use(useCollection('directus_webhooks'));
-router.post('/', asyncHandler(async (_req, _res, _next) => {
-    // Disallow creation of new Webhooks as part of the deprecation, see https://github.com/directus/directus/issues/15553
-    throw new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
-}), respond);
-const readHandler = asyncHandler(async (req, res, next) => {
-    const service = new WebhooksService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const metaService = new MetaService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const records = await service.readByQuery(req.sanitizedQuery);
-    const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
-    res.locals['payload'] = { data: records || null, meta };
-    return next();
-});
-router.get('/', validateBatch('read'), readHandler, respond);
-router.search('/', validateBatch('read'), readHandler, respond);
-router.get('/:pk', asyncHandler(async (req, res, next) => {
-    const service = new WebhooksService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const record = await service.readOne(req.params['pk'], req.sanitizedQuery);
-    res.locals['payload'] = { data: record || null };
-    return next();
-}), respond);
-router.patch('/', validateBatch('update'), asyncHandler(async (_req, _res, _next) => {
-    // Disallow patching of Webhooks as part of the deprecation, see https://github.com/directus/directus/issues/15553
-    throw new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
-}), respond);
-router.patch('/:pk', asyncHandler(async (_req, _res, _next) => {
-    // Disallow patching of Webhooks as part of the deprecation, see https://github.com/directus/directus/issues/15553
-    throw new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
-}), respond);
-router.delete('/', asyncHandler(async (req, _res, next) => {
-    const service = new WebhooksService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    if (Array.isArray(req.body)) {
-        await service.deleteMany(req.body);
-    }
-    else if (req.body.keys) {
-        await service.deleteMany(req.body.keys);
-    }
-    else {
-        const sanitizedQuery = await sanitizeQuery(req.body.query, req.schema, req.accountability);
-        await service.deleteByQuery(sanitizedQuery);
-    }
-    return next();
-}), respond);
-router.delete('/:pk', asyncHandler(async (req, _res, next) => {
-    const service = new WebhooksService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    await service.deleteOne(req.params['pk']);
-    return next();
-}), respond);
-export default router;

package/dist/services/webhooks.d.ts

@@ -1,14 +0,0 @@
-import { type DirectusError } from '@directus/errors';
-import type { Bus } from '@directus/memory';
-import type { AbstractServiceOptions, MutationOptions, PrimaryKey, Webhook } from '@directus/types';
-import { ItemsService } from './items.js';
-export declare class WebhooksService extends ItemsService<Webhook> {
-    messenger: Bus;
-    errorDeprecation: DirectusError;
-    constructor(options: AbstractServiceOptions);
-    createOne(): Promise<PrimaryKey>;
-    createMany(): Promise<PrimaryKey[]>;
-    updateBatch(): Promise<PrimaryKey[]>;
-    updateMany(): Promise<PrimaryKey[]>;
-    deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
-}

package/dist/services/webhooks.js

@@ -1,32 +0,0 @@
-import { ErrorCode, createError } from '@directus/errors';
-import { useBus } from '../bus/index.js';
-import { useLogger } from '../logger/index.js';
-import { ItemsService } from './items.js';
-const logger = useLogger();
-export class WebhooksService extends ItemsService {
-    messenger;
-    errorDeprecation;
-    constructor(options) {
-        super('directus_webhooks', options);
-        this.messenger = useBus();
-        this.errorDeprecation = new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
-        logger.warn('Webhooks are deprecated and the WebhooksService will be removed in an upcoming release. Creating/Updating Webhooks is disabled, use Flows instead');
-    }
-    async createOne() {
-        throw this.errorDeprecation;
-    }
-    async createMany() {
-        throw this.errorDeprecation;
-    }
-    async updateBatch() {
-        throw this.errorDeprecation;
-    }
-    async updateMany() {
-        throw this.errorDeprecation;
-    }
-    async deleteMany(keys, opts) {
-        const result = await super.deleteMany(keys, opts);
-        this.messenger.publish('webhooks', { type: 'reload' });
-        return result;
-    }
-}

package/dist/utils/is-login-redirect-allowed.d.ts

@@ -1,4 +0,0 @@
-/**
- * Checks if the defined redirect after successful SSO login is in the allow list
- */
-export declare function isLoginRedirectAllowed(redirect: unknown, provider: string): boolean;