@directus/api 30.0.0 → 32.0.0

package/dist/mcp/tools/schema.js

@@ -0,0 +1,317 @@
+import { z } from 'zod';
+import { CollectionsService } from '../../services/collections.js';
+import { FieldsService } from '../../services/fields.js';
+import { RelationsService } from '../../services/relations.js';
+import { defineTool } from '../define.js';
+import prompts from './prompts/index.js';
+export const SchemaValidateSchema = z.strictObject({
+    keys: z.array(z.string()).optional(),
+});
+export const SchemaInputSchema = z.object({
+    keys: z
+        .array(z.string())
+        .optional()
+        .describe('Collection names to get detailed schema for. If omitted, returns a lightweight list of all collections.'),
+});
+export const schema = defineTool({
+    name: 'schema',
+    description: prompts.schema,
+    annotations: {
+        title: 'Directus - Schema',
+    },
+    inputSchema: SchemaInputSchema,
+    validateSchema: SchemaValidateSchema,
+    async handler({ args, accountability, schema }) {
+        const serviceOptions = {
+            schema,
+            accountability,
+        };
+        const collectionsService = new CollectionsService(serviceOptions);
+        const collections = await collectionsService.readByQuery();
+        // If no keys provided, return lightweight collection list
+        if (!args.keys || args.keys.length === 0) {
+            const lightweightOverview = {
+                collections: [],
+                collection_folders: [],
+                notes: {},
+            };
+            collections.forEach((collection) => {
+                // Separate folders from real collections
+                if (!collection.schema) {
+                    lightweightOverview.collection_folders.push(collection.collection);
+                }
+                else {
+                    lightweightOverview.collections.push(collection.collection);
+                }
+                // Extract note if exists (for both collections and folders)
+                if (collection.meta?.note && !collection.meta.note.startsWith('$t')) {
+                    lightweightOverview.notes[collection.collection] = collection.meta.note;
+                }
+            });
+            return {
+                type: 'text',
+                data: lightweightOverview,
+            };
+        }
+        // If keys provided, return detailed schema for requested collections
+        const overview = {};
+        const fieldsService = new FieldsService(serviceOptions);
+        const fields = await fieldsService.readAll();
+        const relationsService = new RelationsService(serviceOptions);
+        const relations = await relationsService.readAll();
+        const snapshot = {
+            collections,
+            fields,
+            relations,
+        };
+        fields.forEach((field) => {
+            // Skip collections not requested
+            if (!args.keys?.includes(field.collection))
+                return;
+            // Skip UI-only fields
+            if (field.type === 'alias' && field.meta?.special?.includes('no-data'))
+                return;
+            if (!overview[field.collection]) {
+                overview[field.collection] = {};
+            }
+            const fieldOverview = {
+                type: field.type,
+            };
+            if (field.schema?.is_primary_key) {
+                fieldOverview.primary_key = field.schema?.is_primary_key;
+            }
+            if (field.meta?.required) {
+                fieldOverview.required = field.meta.required;
+            }
+            if (field.meta?.readonly) {
+                fieldOverview.readonly = field.meta.readonly;
+            }
+            if (field.meta?.note) {
+                fieldOverview.note = field.meta.note;
+            }
+            if (field.meta?.interface) {
+                fieldOverview.interface = {
+                    type: field.meta.interface,
+                };
+                if (field.meta.options?.['choices']) {
+                    fieldOverview.interface.choices = field.meta.options['choices'].map(
+                    // Only return the value of the choice to reduce size and potential for confusion.
+                    (choice) => choice.value);
+                }
+            }
+            // Process nested fields for JSON fields with options.fields (like repeaters)
+            if (field.type === 'json' && field.meta?.options?.['fields']) {
+                const nestedFields = field.meta.options['fields'];
+                fieldOverview.fields = processNestedFields({
+                    fields: nestedFields,
+                    maxDepth: 5,
+                    currentDepth: 0,
+                    snapshot,
+                });
+            }
+            // Handle collection-item-dropdown interface
+            if (field.type === 'json' && field.meta?.interface === 'collection-item-dropdown') {
+                fieldOverview.fields = processCollectionItemDropdown({
+                    field,
+                    snapshot,
+                });
+            }
+            // Handle relationships
+            if (field.meta?.special) {
+                const relationshipType = getRelationType(field.meta.special);
+                if (relationshipType) {
+                    fieldOverview.relation = buildRelationInfo(field, relationshipType, snapshot);
+                }
+            }
+            overview[field.collection][field.field] = fieldOverview;
+        });
+        return {
+            type: 'text',
+            data: overview,
+        };
+    },
+});
+// Helpers
+function processNestedFields(options) {
+    const { fields, maxDepth = 5, currentDepth = 0, snapshot } = options;
+    const result = {};
+    if (currentDepth >= maxDepth) {
+        return result;
+    }
+    if (!Array.isArray(fields)) {
+        return result;
+    }
+    for (const field of fields) {
+        const fieldKey = field.field || field.name;
+        if (!fieldKey)
+            continue;
+        const fieldOverview = {
+            type: field.type ?? 'any',
+        };
+        if (field.meta) {
+            const { required, readonly, note, interface: interfaceConfig, options } = field.meta;
+            if (required)
+                fieldOverview.required = required;
+            if (readonly)
+                fieldOverview.readonly = readonly;
+            if (note)
+                fieldOverview.note = note;
+            if (interfaceConfig) {
+                fieldOverview.interface = { type: interfaceConfig };
+                if (options?.choices) {
+                    fieldOverview.interface.choices = options.choices;
+                }
+            }
+        }
+        // Handle nested fields recursively
+        const nestedFields = field.meta?.options?.fields || field.options?.fields;
+        if (field.type === 'json' && nestedFields) {
+            fieldOverview.fields = processNestedFields({
+                fields: nestedFields,
+                maxDepth,
+                currentDepth: currentDepth + 1,
+                snapshot,
+            });
+        }
+        // Handle collection-item-dropdown interface
+        if (field.type === 'json' && field.meta?.interface === 'collection-item-dropdown') {
+            fieldOverview.fields = processCollectionItemDropdown({
+                field,
+                snapshot,
+            });
+        }
+        result[fieldKey] = fieldOverview;
+    }
+    return result;
+}
+function processCollectionItemDropdown(options) {
+    const { field, snapshot } = options;
+    const selectedCollection = field.meta?.options?.['selectedCollection'];
+    let keyType = 'string | number | uuid';
+    // Find the primary key type for the selected collection
+    if (selectedCollection && snapshot?.fields) {
+        const primaryKeyField = snapshot.fields.find((f) => f.collection === selectedCollection && f.schema?.is_primary_key);
+        if (primaryKeyField) {
+            keyType = primaryKeyField.type;
+        }
+    }
+    return {
+        collection: {
+            value: selectedCollection,
+            type: 'string',
+        },
+        key: {
+            type: keyType,
+        },
+    };
+}
+function getRelationType(special) {
+    if (special.includes('m2o') || special.includes('file'))
+        return 'm2o';
+    if (special.includes('o2m'))
+        return 'o2m';
+    if (special.includes('m2m') || special.includes('files'))
+        return 'm2m';
+    if (special.includes('m2a'))
+        return 'm2a';
+    return null;
+}
+function buildRelationInfo(field, type, snapshot) {
+    switch (type) {
+        case 'm2o':
+            return buildManyToOneRelation(field, snapshot);
+        case 'o2m':
+            return buildOneToManyRelation(field, snapshot);
+        case 'm2m':
+            return buildManyToManyRelation(field, snapshot);
+        case 'm2a':
+            return buildManyToAnyRelation(field, snapshot);
+        default:
+            return { type };
+    }
+}
+function buildManyToOneRelation(field, snapshot) {
+    // For M2O, the relation is directly on this field
+    const relation = snapshot.relations.find((r) => r.collection === field.collection && r.field === field.field);
+    // The target collection is either in related_collection or foreign_key_table
+    const targetCollection = relation?.related_collection || relation?.schema?.foreign_key_table || field.schema?.foreign_key_table;
+    return {
+        type: 'm2o',
+        collection: targetCollection,
+    };
+}
+function buildOneToManyRelation(field, snapshot) {
+    // For O2M, we need to find the relation that points BACK to this field
+    // The relation will have this field stored in meta.one_field
+    const reverseRelation = snapshot.relations.find((r) => r.meta?.one_collection === field.collection && r.meta?.one_field === field.field);
+    if (!reverseRelation) {
+        return { type: 'o2m' };
+    }
+    return {
+        type: 'o2m',
+        collection: reverseRelation.collection,
+        many_field: reverseRelation.field,
+    };
+}
+function buildManyToManyRelation(field, snapshot) {
+    // Find the junction table relation that references this field
+    // This relation will have our field as meta.one_field
+    const junctionRelation = snapshot.relations.find((r) => r.meta?.one_field === field.field &&
+        r.meta?.one_collection === field.collection &&
+        r.collection !== field.collection);
+    if (!junctionRelation) {
+        return { type: 'm2m' };
+    }
+    // Find the other side of the junction (pointing to the target collection)
+    // This is stored in meta.junction_field
+    const targetRelation = snapshot.relations.find((r) => r.collection === junctionRelation.collection && r.field === junctionRelation.meta?.junction_field);
+    const targetCollection = targetRelation?.related_collection || 'directus_files';
+    const result = {
+        type: 'm2m',
+        collection: targetCollection,
+        junction: {
+            collection: junctionRelation.collection,
+            many_field: junctionRelation.field,
+            junction_field: junctionRelation.meta?.junction_field,
+        },
+    };
+    if (junctionRelation.meta?.sort_field) {
+        result.junction.sort_field = junctionRelation.meta.sort_field;
+    }
+    return result;
+}
+function buildManyToAnyRelation(field, snapshot) {
+    // Find the junction table relation that references this field
+    // This relation will have our field as meta.one_field
+    const junctionRelation = snapshot.relations.find((r) => r.meta?.one_field === field.field && r.meta?.one_collection === field.collection);
+    if (!junctionRelation) {
+        return { type: 'm2a' };
+    }
+    // Find the polymorphic relation in the junction table
+    // This relation will have one_allowed_collections set
+    const polymorphicRelation = snapshot.relations.find((r) => r.collection === junctionRelation.collection &&
+        r.meta?.one_allowed_collections &&
+        r.meta.one_allowed_collections.length > 0);
+    if (!polymorphicRelation) {
+        return { type: 'm2a' };
+    }
+    // Find the relation back to our parent collection
+    const parentRelation = snapshot.relations.find((r) => r.collection === junctionRelation.collection &&
+        r.related_collection === field.collection &&
+        r.field !== polymorphicRelation.field);
+    const result = {
+        type: 'm2a',
+        one_allowed_collections: polymorphicRelation.meta?.one_allowed_collections,
+        junction: {
+            collection: junctionRelation.collection,
+            many_field: parentRelation?.field || `${field.collection}_id`,
+            junction_field: polymorphicRelation.field,
+            one_collection_field: polymorphicRelation.meta?.one_collection_field || 'collection',
+        },
+    };
+    const sortField = parentRelation?.meta?.sort_field || polymorphicRelation.meta?.sort_field;
+    if (sortField) {
+        result.junction.sort_field = sortField;
+    }
+    return result;
+}

package/dist/mcp/tools/system.d.ts

@@ -0,0 +1,3 @@
+export declare const system: import("../types.js").ToolConfig<{
+    promptOverride?: string | null | undefined;
+}>;

package/dist/mcp/tools/system.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { defineTool } from '../define.js';
+import prompts from './prompts/index.js';
+const SystemPromptInputSchema = z.object({});
+const SystemPromptValidateSchema = z.object({
+    promptOverride: z.union([z.string(), z.null()]).optional(),
+});
+export const system = defineTool({
+    name: 'system-prompt',
+    description: prompts.systemPromptDescription,
+    annotations: {
+        title: 'Directus - System Prompt',
+    },
+    inputSchema: SystemPromptInputSchema,
+    validateSchema: SystemPromptValidateSchema,
+    async handler({ args }) {
+        return {
+            type: 'text',
+            data: args.promptOverride || prompts.systemPrompt,
+        };
+    },
+});

package/dist/mcp/tools/trigger-flow.d.ts

@@ -0,0 +1,8 @@
+export declare const triggerFlow: import("../types.js").ToolConfig<{
+    id: string | number;
+    collection: string;
+    keys?: (string | number)[] | undefined;
+    query?: Record<string, any> | undefined;
+    headers?: Record<string, any> | undefined;
+    data?: Record<string, any> | undefined;
+}>;

package/dist/mcp/tools/trigger-flow.js

@@ -0,0 +1,48 @@
+import { InvalidPayloadError } from '@directus/errors';
+import { z } from 'zod';
+import { getFlowManager } from '../../flows.js';
+import { FlowsService } from '../../services/flows.js';
+import { defineTool } from '../define.js';
+import { TriggerFlowInputSchema, TriggerFlowValidateSchema } from '../schema.js';
+import prompts from './prompts/index.js';
+export const triggerFlow = defineTool({
+    name: 'trigger-flow',
+    description: prompts.triggerFlow,
+    annotations: {
+        title: 'Directus - Trigger Flow',
+    },
+    inputSchema: TriggerFlowInputSchema,
+    validateSchema: TriggerFlowValidateSchema,
+    async handler({ args, schema, accountability }) {
+        const flowsService = new FlowsService({ schema, accountability });
+        const flow = await flowsService.readOne(args.id, {
+            filter: { status: { _eq: 'active' }, trigger: { _eq: 'manual' } },
+            fields: ['options'],
+        });
+        /**
+         * Collection and Required selection are validated by the server.
+         * Required fields is an additional validation we do.
+         */
+        const requiredFields = (flow.options?.['fields'] ?? [])
+            .filter((field) => field.meta?.required)
+            .map((field) => field.field);
+        for (const fieldName of requiredFields) {
+            if (!args.data || !(fieldName in args.data)) {
+                throw new InvalidPayloadError({ reason: `Required field "${fieldName}" is missing` });
+            }
+        }
+        const flowManager = getFlowManager();
+        const { result } = await flowManager.runWebhookFlow(`POST-${args.id}`, {
+            path: `/trigger/${args.id}`,
+            query: args.query ?? {},
+            method: 'POST',
+            body: {
+                collection: args.collection,
+                keys: args.keys,
+                ...(args.data ?? {}),
+            },
+            headers: args.headers ?? {},
+        }, { accountability, schema });
+        return { type: 'text', data: result };
+    },
+});

package/dist/mcp/transport.d.ts

@@ -0,0 +1,13 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { JSONRPCMessage, MessageExtraInfo } from '@modelcontextprotocol/sdk/types.js';
+import type { Response } from 'express';
+export declare class DirectusTransport implements Transport {
+    res: Response;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage, extra?: MessageExtraInfo) => void;
+    onclose?: () => void;
+    constructor(res: Response);
+    start(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/mcp/transport.js

@@ -0,0 +1,18 @@
+export class DirectusTransport {
+    res;
+    onerror;
+    onmessage;
+    onclose;
+    constructor(res) {
+        this.res = res;
+    }
+    async start() {
+        return;
+    }
+    async send(message) {
+        this.res.json(message);
+    }
+    async close() {
+        return;
+    }
+}

package/dist/mcp/types.d.ts

@@ -0,0 +1,56 @@
+import type { Accountability, Query, SchemaOverview } from '@directus/types';
+import type { ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';
+import type { ZodType } from 'zod';
+export type ToolResultBase = {
+    type?: 'text' | 'image' | 'audio';
+    url?: string | undefined;
+};
+export type TextToolResult = ToolResultBase & {
+    type: 'text';
+    data: unknown;
+};
+export type AssetToolResult = ToolResultBase & {
+    type: 'image' | 'audio';
+    data: string;
+    mimeType: string;
+};
+export type ToolResult = TextToolResult | AssetToolResult;
+export type ToolHandler<T> = {
+    (options: {
+        args: T;
+        sanitizedQuery: Query;
+        schema: SchemaOverview;
+        accountability: Accountability | undefined;
+    }): Promise<ToolResult | undefined>;
+};
+export type ToolEndpoint<T> = {
+    (options: {
+        input: T;
+        data: unknown;
+    }): string[] | undefined;
+};
+export interface ToolConfig<T> {
+    name: string;
+    description: string;
+    endpoint?: ToolEndpoint<T>;
+    admin?: boolean;
+    inputSchema: ZodType<any>;
+    validateSchema?: ZodType<T>;
+    annotations?: ToolAnnotations;
+    handler: ToolHandler<T>;
+}
+export interface Prompt {
+    name: string;
+    system_prompt?: string | null;
+    description?: string;
+    messages: {
+        role: 'user' | 'assistant';
+        text: string;
+    }[];
+}
+export interface MCPOptions {
+    promptsCollection?: string;
+    allowDeletes?: boolean;
+    systemPromptEnabled?: boolean;
+    systemPrompt?: string | null;
+}

package/dist/mcp/types.js

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

package/dist/metrics/lib/create-metrics.js

@@ -18,6 +18,7 @@ export function createMetrics() {
     const env = useEnv();
     const logger = useLogger();
     const services = env['METRICS_SERVICES'] ?? [];
+    const metricNamePrefix = env['METRICS_NAME_PREFIX'] ?? 'directus_';
     const aggregates = new Map();
     /**
      * Listen for PM2 metric data sync messages and add them to the aggregate
@@ -92,10 +93,10 @@ export function createMetrics() {
             return null;
         }
         const client = env['DB_CLIENT'];
-        let metric = register.getSingleMetric(`directus_db_${client}_connection_errors`);
+        let metric = register.getSingleMetric(`${metricNamePrefix}db_${client}_connection_errors`);
         if (!metric) {
             metric = new Counter({
-                name: `directus_db_${client}_connection_errors`,
+                name: `${metricNamePrefix}db_${client}_connection_errors`,
                 help: `${client} Database connection error count`,
             });
         }
@@ -106,10 +107,10 @@ export function createMetrics() {
             return null;
         }
         const client = env['DB_CLIENT'];
-        let metric = register.getSingleMetric(`directus_db_${client}_response_time_ms`);
+        let metric = register.getSingleMetric(`${metricNamePrefix}db_${client}_response_time_ms`);
         if (!metric) {
             metric = new Histogram({
-                name: `directus_db_${client}_response_time_ms`,
+                name: `${metricNamePrefix}db_${client}_response_time_ms`,
                 help: `${client} Database connection response time`,
                 buckets: [1, 10, 20, 40, 60, 80, 100, 200, 500, 750, 1000],
             });
@@ -123,10 +124,10 @@ export function createMetrics() {
         if (env['CACHE_STORE'] === 'redis' && redisConfigAvailable() !== true) {
             return null;
         }
-        let metric = register.getSingleMetric(`directus_cache_${env['CACHE_STORE']}_connection_errors`);
+        let metric = register.getSingleMetric(`${metricNamePrefix}cache_${env['CACHE_STORE']}_connection_errors`);
         if (!metric) {
             metric = new Counter({
-                name: `directus_cache_${env['CACHE_STORE']}_connection_errors`,
+                name: `${metricNamePrefix}cache_${env['CACHE_STORE']}_connection_errors`,
                 help: 'Cache connection error count',
             });
         }
@@ -136,10 +137,10 @@ export function createMetrics() {
         if (services.includes('redis') === false || redisConfigAvailable() !== true) {
             return null;
         }
-        let metric = register.getSingleMetric('directus_redis_connection_errors');
+        let metric = register.getSingleMetric(`${metricNamePrefix}redis_connection_errors`);
         if (!metric) {
             metric = new Counter({
-                name: `directus_redis_connection_errors`,
+                name: `${metricNamePrefix}redis_connection_errors`,
                 help: 'Redis connection error count',
             });
         }
@@ -149,10 +150,10 @@ export function createMetrics() {
         if (services.includes('storage') === false) {
             return null;
         }
-        let metric = register.getSingleMetric(`directus_storage_${location}_connection_errors`);
+        let metric = register.getSingleMetric(`${metricNamePrefix}storage_${location}_connection_errors`);
         if (!metric) {
             metric = new Counter({
-                name: `directus_storage_${location}_connection_errors`,
+                name: `${metricNamePrefix}storage_${location}_connection_errors`,
                 help: `${location} storage connection error count`,
             });
         }
@@ -182,8 +183,8 @@ export function createMetrics() {
             return;
         }
         try {
-            await cache.set(`metrics-${checkId}`, '1', 5);
-            await cache.delete(`metrics-${checkId}`);
+            await cache.set(`directus-metric-${checkId}`, '1', 5);
+            await cache.delete(`directus-metric-${checkId}`);
         }
         catch {
             metric.inc();
@@ -196,8 +197,8 @@ export function createMetrics() {
         }
         const redis = useRedis();
         try {
-            await redis.set(`metrics-${checkId}`, '1');
-            await redis.del(`metrics-${checkId}`);
+            await redis.set(`directus-metric-${checkId}`, '1');
+            await redis.del(`directus-metric-${checkId}`);
         }
         catch {
             metric.inc();
@@ -215,17 +216,7 @@ export function createMetrics() {
                 continue;
             }
             try {
-                await disk.write(`metric-${checkId}`, Readable.from(['check']));
-                const fileStream = await disk.read(`metric-${checkId}`);
-                fileStream.on('data', async () => {
-                    try {
-                        fileStream.destroy();
-                        await disk.delete(`metric-${checkId}`);
-                    }
-                    catch (error) {
-                        logger.error(error);
-                    }
-                });
+                await disk.write('directus-metric-file', Readable.from([checkId]));
             }
             catch {
                 metric.inc();

package/dist/middleware/collection-exists.js

@@ -1,14 +1,14 @@
 /**
  * Check if requested collection exists, and save it to req.collection
  */
-import { ForbiddenError } from '@directus/errors';
 import { systemCollectionRows } from '@directus/system-data';
 import asyncHandler from '../utils/async-handler.js';
+import { createCollectionForbiddenError } from '../permissions/modules/process-ast/utils/validate-path/create-error.js';
 const collectionExists = asyncHandler(async (req, _res, next) => {
     if (!req.params['collection'])
         return next();
     if (req.params['collection'] in req.schema.collections === false) {
-        throw new ForbiddenError();
+        throw createCollectionForbiddenError('', req.params['collection']);
     }
     req.collection = req.params['collection'];
     const systemCollectionRow = systemCollectionRows.find((collection) => {

package/dist/operations/mail/index.js

@@ -2,10 +2,12 @@ import { defineOperationApi } from '@directus/extensions';
 import { MailService } from '../../services/mail/index.js';
 import { md } from '../../utils/md.js';
 import { useLogger } from '../../logger/index.js';
+import { useFlowsEmailRateLimiter } from './rate-limiter.js';
 const logger = useLogger();
 export default defineOperationApi({
     id: 'mail',
-    handler: async ({ body, template, data, to, type, subject, cc, bcc, replyTo }, { accountability, database, getSchema }) => {
+    handler: async ({ body, template, data, to, type, subject, cc, bcc, replyTo }, { accountability, database, getSchema, flow }) => {
+        await useFlowsEmailRateLimiter(flow.id);
         const mailService = new MailService({ schema: await getSchema({ database }), accountability, knex: database });
         const mailObject = { to, subject, cc, bcc, replyTo };
         const safeBody = typeof body !== 'string' ? JSON.stringify(body) : body;

package/dist/operations/mail/rate-limiter.d.ts

@@ -0,0 +1 @@
+export declare function useFlowsEmailRateLimiter(flow_id: string): Promise<void>;

package/dist/operations/mail/rate-limiter.js

@@ -0,0 +1,29 @@
+import { useEnv } from '@directus/env';
+import { RateLimiterMemory, RateLimiterRedis, RateLimiterRes } from 'rate-limiter-flexible';
+import { createRateLimiter } from '../../rate-limiter.js';
+import { toBoolean } from '@directus/utils';
+import { EmailLimitExceededError } from '@directus/errors';
+let emailRateLimiter;
+const env = useEnv();
+if (toBoolean(env['RATE_LIMITER_EMAIL_FLOWS_ENABLED']) === true) {
+    emailRateLimiter = createRateLimiter('RATE_LIMITER_EMAIL_FLOWS');
+}
+export async function useFlowsEmailRateLimiter(flow_id) {
+    if (!emailRateLimiter)
+        return;
+    try {
+        await emailRateLimiter.consume(flow_id, 1);
+    }
+    catch (err) {
+        if (err instanceof RateLimiterRes) {
+            throw new EmailLimitExceededError({
+                points: 'RATE_LIMITER_EMAIL_FLOWS_POINTS' in env ? Number(env['RATE_LIMITER_EMAIL_FLOWS_POINTS']) : undefined,
+                duration: 'RATE_LIMITER_EMAIL_FLOWS_DURATION' in env ? Number(env['RATE_LIMITER_EMAIL_FLOWS_DURATION']) : undefined,
+                message: 'RATE_LIMITER_EMAIL_FLOWS_ERROR_MESSAGE' in env
+                    ? String(env['RATE_LIMITER_EMAIL_FLOWS_ERROR_MESSAGE'])
+                    : undefined,
+            });
+        }
+        throw err;
+    }
+}