@directus/api 9.25.0

package/dist/middleware/schema.js

@@ -0,0 +1,7 @@
+import asyncHandler from '../utils/async-handler.js';
+import { getSchema } from '../utils/get-schema.js';
+const schema = asyncHandler(async (req, _res, next) => {
+    req.schema = await getSchema();
+    return next();
+});
+export default schema;

package/dist/middleware/use-collection.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Set req.collection for use in other middleware. Used as an alternative on validate-collection for
+ * system collections
+ */
+import type { RequestHandler } from 'express';
+declare const useCollection: (collection: string) => RequestHandler;
+export default useCollection;

package/dist/middleware/use-collection.js

@@ -0,0 +1,6 @@
+import asyncHandler from '../utils/async-handler.js';
+const useCollection = (collection) => asyncHandler(async (req, _res, next) => {
+    req.collection = collection;
+    next();
+});
+export default useCollection;

package/dist/middleware/validate-batch.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="qs" />
+/// <reference types="express" />
+export declare const validateBatch: (scope: 'read' | 'update' | 'delete') => (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: import("express").Response<any, Record<string, any>>, next: import("express").NextFunction) => Promise<void>;

package/dist/middleware/validate-batch.js

@@ -0,0 +1,42 @@
+import { FailedValidationException } from '@directus/exceptions';
+import Joi from 'joi';
+import { InvalidPayloadException } from '../exceptions/index.js';
+import asyncHandler from '../utils/async-handler.js';
+import { sanitizeQuery } from '../utils/sanitize-query.js';
+export const validateBatch = (scope) => asyncHandler(async (req, _res, next) => {
+    if (req.method.toLowerCase() === 'get') {
+        req.body = {};
+        return next();
+    }
+    if (req.method.toLowerCase() !== 'search' && scope !== 'read' && req.singleton) {
+        return next();
+    }
+    if (!req.body)
+        throw new InvalidPayloadException('Payload in body is required');
+    if (['update', 'delete'].includes(scope) && Array.isArray(req.body)) {
+        return next();
+    }
+    // In reads, the query in the body should override the query params for searching
+    if (scope === 'read' && req.body.query) {
+        req.sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
+    }
+    // Every cRUD action has either keys or query
+    let batchSchema = Joi.object().keys({
+        keys: Joi.array().items(Joi.alternatives(Joi.string(), Joi.number())),
+        query: Joi.object().unknown(),
+    });
+    if (['update', 'delete'].includes(scope)) {
+        batchSchema = batchSchema.xor('query', 'keys');
+    }
+    // In updates, we add a required `data` that holds the update payload if an array isn't used
+    if (scope === 'update') {
+        batchSchema = batchSchema.keys({
+            data: Joi.object().unknown().required(),
+        });
+    }
+    const { error } = batchSchema.validate(req.body);
+    if (error) {
+        throw new FailedValidationException(error.details[0]);
+    }
+    return next();
+});

package/dist/middleware/validate-batch.test.d.ts

@@ -0,0 +1 @@
+import '../../src/types/express.d.ts';

package/dist/operations/condition/index.d.ts

@@ -0,0 +1,6 @@
+import type { Filter } from '@directus/types';
+type Options = {
+    filter: Filter;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/condition/index.js

@@ -0,0 +1,13 @@
+import { defineOperationApi, validatePayload } from '@directus/utils';
+export default defineOperationApi({
+    id: 'condition',
+    handler: ({ filter }, { data }) => {
+        const errors = validatePayload(filter, data, { requireAll: true });
+        if (errors.length > 0) {
+            throw errors;
+        }
+        else {
+            return null;
+        }
+    },
+});

package/dist/operations/condition/index.test.d.ts

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

package/dist/operations/exec/index.d.ts

@@ -0,0 +1,5 @@
+type Options = {
+    code: string;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/exec/index.js

@@ -0,0 +1,38 @@
+import { defineOperationApi, toArray } from '@directus/utils';
+import { NodeVM, VMScript } from 'vm2';
+import { isBuiltin } from 'node:module';
+export default defineOperationApi({
+    id: 'exec',
+    handler: async ({ code }, { data, env }) => {
+        const allowedModules = env['FLOWS_EXEC_ALLOWED_MODULES'] ? toArray(env['FLOWS_EXEC_ALLOWED_MODULES']) : [];
+        const allowedModulesBuiltIn = [];
+        const allowedModulesExternal = [];
+        const allowedEnv = data['$env'] ?? {};
+        const opts = {
+            eval: false,
+            wasm: false,
+            env: allowedEnv,
+        };
+        for (const module of allowedModules) {
+            if (isBuiltin(module)) {
+                allowedModulesBuiltIn.push(module);
+            }
+            else {
+                allowedModulesExternal.push(module);
+            }
+        }
+        if (allowedModules.length > 0) {
+            opts.require = {
+                builtin: allowedModulesBuiltIn,
+                external: {
+                    modules: allowedModulesExternal,
+                    transitive: false,
+                },
+            };
+        }
+        const vm = new NodeVM(opts);
+        const script = new VMScript(code).compile();
+        const fn = await vm.run(script);
+        return await fn(data);
+    },
+});

package/dist/operations/exec/index.test.d.ts

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

package/dist/operations/item-create/index.d.ts

@@ -0,0 +1,8 @@
+type Options = {
+    collection: string;
+    payload?: Record<string, any> | string | null;
+    emitEvents: boolean;
+    permissions: string;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/item-create/index.js

@@ -0,0 +1,36 @@
+import { defineOperationApi, optionToObject, toArray } from '@directus/utils';
+import { ItemsService } from '../../services/items.js';
+import { getAccountabilityForRole } from '../../utils/get-accountability-for-role.js';
+export default defineOperationApi({
+    id: 'item-create',
+    handler: async ({ collection, payload, emitEvents, permissions }, { accountability, database, getSchema }) => {
+        const schema = await getSchema({ database });
+        let customAccountability;
+        if (!permissions || permissions === '$trigger') {
+            customAccountability = accountability;
+        }
+        else if (permissions === '$full') {
+            customAccountability = await getAccountabilityForRole('system', { database, schema, accountability });
+        }
+        else if (permissions === '$public') {
+            customAccountability = await getAccountabilityForRole(null, { database, schema, accountability });
+        }
+        else {
+            customAccountability = await getAccountabilityForRole(permissions, { database, schema, accountability });
+        }
+        const itemsService = new ItemsService(collection, {
+            schema: await getSchema({ database }),
+            accountability: customAccountability,
+            knex: database,
+        });
+        const payloadObject = optionToObject(payload) ?? null;
+        let result;
+        if (!payloadObject) {
+            result = null;
+        }
+        else {
+            result = await itemsService.createMany(toArray(payloadObject), { emitEvents: !!emitEvents });
+        }
+        return result;
+    },
+});

package/dist/operations/item-create/index.test.d.ts

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

package/dist/operations/item-delete/index.d.ts

@@ -0,0 +1,10 @@
+import type { PrimaryKey } from '@directus/types';
+type Options = {
+    collection: string;
+    key?: PrimaryKey | PrimaryKey[] | null;
+    query?: Record<string, any> | string | null;
+    emitEvents: boolean;
+    permissions: string;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/item-delete/index.js

@@ -0,0 +1,44 @@
+import { defineOperationApi, optionToObject, toArray } from '@directus/utils';
+import { ItemsService } from '../../services/items.js';
+import { getAccountabilityForRole } from '../../utils/get-accountability-for-role.js';
+import { sanitizeQuery } from '../../utils/sanitize-query.js';
+export default defineOperationApi({
+    id: 'item-delete',
+    handler: async ({ collection, key, query, emitEvents, permissions }, { accountability, database, getSchema }) => {
+        const schema = await getSchema({ database });
+        let customAccountability;
+        if (!permissions || permissions === '$trigger') {
+            customAccountability = accountability;
+        }
+        else if (permissions === '$full') {
+            customAccountability = await getAccountabilityForRole('system', { database, schema, accountability });
+        }
+        else if (permissions === '$public') {
+            customAccountability = await getAccountabilityForRole(null, { database, schema, accountability });
+        }
+        else {
+            customAccountability = await getAccountabilityForRole(permissions, { database, schema, accountability });
+        }
+        const itemsService = new ItemsService(collection, {
+            schema: await getSchema({ database }),
+            accountability: customAccountability,
+            knex: database,
+        });
+        const queryObject = query ? optionToObject(query) : {};
+        const sanitizedQueryObject = sanitizeQuery(queryObject, customAccountability);
+        let result;
+        if (!key || (Array.isArray(key) && key.length === 0)) {
+            result = await itemsService.deleteByQuery(sanitizedQueryObject, { emitEvents: !!emitEvents });
+        }
+        else {
+            const keys = toArray(key);
+            if (keys.length === 1) {
+                result = await itemsService.deleteOne(keys[0], { emitEvents: !!emitEvents });
+            }
+            else {
+                result = await itemsService.deleteMany(keys, { emitEvents: !!emitEvents });
+            }
+        }
+        return result;
+    },
+});

package/dist/operations/item-delete/index.test.d.ts

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

package/dist/operations/item-read/index.d.ts

@@ -0,0 +1,10 @@
+import type { PrimaryKey } from '@directus/types';
+type Options = {
+    collection: string;
+    key?: PrimaryKey | PrimaryKey[] | null;
+    query?: Record<string, any> | string | null;
+    emitEvents: boolean;
+    permissions: string;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/item-read/index.js

@@ -0,0 +1,44 @@
+import { defineOperationApi, optionToObject, toArray } from '@directus/utils';
+import { ItemsService } from '../../services/items.js';
+import { getAccountabilityForRole } from '../../utils/get-accountability-for-role.js';
+import { sanitizeQuery } from '../../utils/sanitize-query.js';
+export default defineOperationApi({
+    id: 'item-read',
+    handler: async ({ collection, key, query, emitEvents, permissions }, { accountability, database, getSchema }) => {
+        const schema = await getSchema({ database });
+        let customAccountability;
+        if (!permissions || permissions === '$trigger') {
+            customAccountability = accountability;
+        }
+        else if (permissions === '$full') {
+            customAccountability = await getAccountabilityForRole('system', { database, schema, accountability });
+        }
+        else if (permissions === '$public') {
+            customAccountability = await getAccountabilityForRole(null, { database, schema, accountability });
+        }
+        else {
+            customAccountability = await getAccountabilityForRole(permissions, { database, schema, accountability });
+        }
+        const itemsService = new ItemsService(collection, {
+            schema,
+            accountability: customAccountability,
+            knex: database,
+        });
+        const queryObject = query ? optionToObject(query) : {};
+        const sanitizedQueryObject = sanitizeQuery(queryObject, customAccountability);
+        let result;
+        if (!key || (Array.isArray(key) && key.length === 0)) {
+            result = await itemsService.readByQuery(sanitizedQueryObject, { emitEvents: !!emitEvents });
+        }
+        else {
+            const keys = toArray(key);
+            if (keys.length === 1) {
+                result = await itemsService.readOne(keys[0], sanitizedQueryObject, { emitEvents: !!emitEvents });
+            }
+            else {
+                result = await itemsService.readMany(keys, sanitizedQueryObject, { emitEvents: !!emitEvents });
+            }
+        }
+        return result;
+    },
+});

package/dist/operations/item-read/index.test.d.ts

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

package/dist/operations/item-update/index.d.ts

@@ -0,0 +1,11 @@
+import type { PrimaryKey } from '@directus/types';
+type Options = {
+    collection: string;
+    key?: PrimaryKey | PrimaryKey[] | null;
+    payload?: Record<string, any> | string | null;
+    query?: Record<string, any> | string | null;
+    emitEvents: boolean;
+    permissions: string;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/item-update/index.js

@@ -0,0 +1,48 @@
+import { defineOperationApi, optionToObject, toArray } from '@directus/utils';
+import { ItemsService } from '../../services/items.js';
+import { getAccountabilityForRole } from '../../utils/get-accountability-for-role.js';
+import { sanitizeQuery } from '../../utils/sanitize-query.js';
+export default defineOperationApi({
+    id: 'item-update',
+    handler: async ({ collection, key, payload, query, emitEvents, permissions }, { accountability, database, getSchema }) => {
+        const schema = await getSchema({ database });
+        let customAccountability;
+        if (!permissions || permissions === '$trigger') {
+            customAccountability = accountability;
+        }
+        else if (permissions === '$full') {
+            customAccountability = await getAccountabilityForRole('system', { database, schema, accountability });
+        }
+        else if (permissions === '$public') {
+            customAccountability = await getAccountabilityForRole(null, { database, schema, accountability });
+        }
+        else {
+            customAccountability = await getAccountabilityForRole(permissions, { database, schema, accountability });
+        }
+        const itemsService = new ItemsService(collection, {
+            schema: await getSchema({ database }),
+            accountability: customAccountability,
+            knex: database,
+        });
+        const payloadObject = optionToObject(payload) ?? null;
+        const queryObject = query ? optionToObject(query) : {};
+        const sanitizedQueryObject = sanitizeQuery(queryObject, customAccountability);
+        if (!payloadObject) {
+            return null;
+        }
+        let result;
+        if (!key || (Array.isArray(key) && key.length === 0)) {
+            result = await itemsService.updateByQuery(sanitizedQueryObject, payloadObject, { emitEvents: !!emitEvents });
+        }
+        else {
+            const keys = toArray(key);
+            if (keys.length === 1) {
+                result = await itemsService.updateOne(keys[0], payloadObject, { emitEvents: !!emitEvents });
+            }
+            else {
+                result = await itemsService.updateMany(keys, payloadObject, { emitEvents: !!emitEvents });
+            }
+        }
+        return result;
+    },
+});

package/dist/operations/item-update/index.test.d.ts

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

package/dist/operations/log/index.d.ts

@@ -0,0 +1,5 @@
+type Options = {
+    message: unknown;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/log/index.js

@@ -0,0 +1,8 @@
+import { defineOperationApi, optionToString } from '@directus/utils';
+import logger from '../../logger.js';
+export default defineOperationApi({
+    id: 'log',
+    handler: ({ message }) => {
+        logger.info(optionToString(message));
+    },
+});

package/dist/operations/log/index.test.d.ts

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

package/dist/operations/mail/index.d.ts

@@ -0,0 +1,8 @@
+type Options = {
+    body: string;
+    to: string;
+    type: 'wysiwyg' | 'markdown';
+    subject: string;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/mail/index.js

@@ -0,0 +1,17 @@
+import { defineOperationApi } from '@directus/utils';
+import { MailService } from '../../services/mail/index.js';
+import { md } from '../../utils/md.js';
+export default defineOperationApi({
+    id: 'mail',
+    handler: async ({ body, to, type, subject }, { accountability, database, getSchema }) => {
+        const mailService = new MailService({ schema: await getSchema({ database }), accountability, knex: database });
+        // If 'body' is of type object/undefined (happens when body consists solely of a placeholder)
+        // convert it to JSON string
+        const safeBody = typeof body !== 'string' ? JSON.stringify(body) : body;
+        await mailService.send({
+            html: type === 'wysiwyg' ? safeBody : md(safeBody),
+            to,
+            subject,
+        });
+    },
+});

package/dist/operations/notification/index.d.ts

@@ -0,0 +1,8 @@
+type Options = {
+    recipient: string;
+    subject: string;
+    message?: unknown | null;
+    permissions: string;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/notification/index.js

@@ -0,0 +1,38 @@
+import { defineOperationApi, optionToString, toArray } from '@directus/utils';
+import { NotificationsService } from '../../services/notifications.js';
+import { getAccountabilityForRole } from '../../utils/get-accountability-for-role.js';
+export default defineOperationApi({
+    id: 'notification',
+    handler: async ({ recipient, subject, message, permissions }, { accountability, database, getSchema }) => {
+        const schema = await getSchema({ database });
+        let customAccountability;
+        if (!permissions || permissions === '$trigger') {
+            customAccountability = accountability;
+        }
+        else if (permissions === '$full') {
+            customAccountability = null;
+        }
+        else if (permissions === '$public') {
+            customAccountability = await getAccountabilityForRole(null, { database, schema, accountability });
+        }
+        else {
+            customAccountability = await getAccountabilityForRole(permissions, { database, schema, accountability });
+        }
+        const notificationsService = new NotificationsService({
+            schema: await getSchema({ database }),
+            accountability: customAccountability,
+            knex: database,
+        });
+        const messageString = message ? optionToString(message) : null;
+        const payload = toArray(recipient).map((userId) => {
+            return {
+                recipient: userId,
+                sender: customAccountability?.user ?? null,
+                subject,
+                message: messageString,
+            };
+        });
+        const result = await notificationsService.createMany(payload);
+        return result;
+    },
+});

package/dist/operations/notification/index.test.d.ts

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

package/dist/operations/request/index.d.ts

@@ -0,0 +1,11 @@
+type Options = {
+    url: string;
+    method: string;
+    body: Record<string, any> | string | null;
+    headers?: {
+        header: string;
+        value: string;
+    }[] | null;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/request/index.js

@@ -0,0 +1,39 @@
+import { defineOperationApi, isValidJSON } from '@directus/utils';
+import encodeUrl from 'encodeurl';
+import { getAxios } from '../../request/index.js';
+import { isAxiosError } from 'axios';
+export default defineOperationApi({
+    id: 'request',
+    handler: async ({ url, method, body, headers }) => {
+        const customHeaders = headers?.reduce((acc, { header, value }) => {
+            acc[header] = value;
+            return acc;
+        }, {}) ?? {};
+        if (!customHeaders['Content-Type'] && (typeof body === 'object' || isValidJSON(body))) {
+            customHeaders['Content-Type'] = 'application/json';
+        }
+        const axios = await getAxios();
+        try {
+            const result = await axios({
+                url: encodeUrl(url),
+                method,
+                data: body,
+                headers: customHeaders,
+            });
+            return { status: result.status, statusText: result.statusText, headers: result.headers, data: result.data };
+        }
+        catch (error) {
+            if (isAxiosError(error)) {
+                throw JSON.stringify({
+                    status: error.response?.status,
+                    statusText: error.response?.statusText,
+                    headers: error.response?.headers,
+                    data: error.response?.data,
+                });
+            }
+            else {
+                throw error;
+            }
+        }
+    },
+});

package/dist/operations/request/index.test.d.ts

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

package/dist/operations/sleep/index.d.ts

@@ -0,0 +1,5 @@
+type Options = {
+    milliseconds: string | number;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/sleep/index.js

@@ -0,0 +1,7 @@
+import { defineOperationApi } from '@directus/utils';
+export default defineOperationApi({
+    id: 'sleep',
+    handler: async ({ milliseconds }) => {
+        await new Promise((resolve) => setTimeout(resolve, Number(milliseconds)));
+    },
+});

package/dist/operations/sleep/index.test.d.ts

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

package/dist/operations/transform/index.d.ts

@@ -0,0 +1,5 @@
+type Options = {
+    json: string | Record<string, any>;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/transform/index.js

@@ -0,0 +1,7 @@
+import { defineOperationApi, optionToObject } from '@directus/utils';
+export default defineOperationApi({
+    id: 'transform',
+    handler: ({ json }) => {
+        return optionToObject(json);
+    },
+});

package/dist/operations/transform/index.test.d.ts

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

package/dist/operations/trigger/index.d.ts

@@ -0,0 +1,8 @@
+type Options = {
+    flow: string;
+    payload?: Record<string, any> | Record<string, any>[] | string | null;
+    iterationMode?: 'serial' | 'batch' | 'parallel';
+    batchSize?: number;
+};
+declare const _default: import("@directus/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/trigger/index.js

@@ -0,0 +1,37 @@
+import { defineOperationApi, optionToObject } from '@directus/utils';
+import { omit } from 'lodash-es';
+import { getFlowManager } from '../../flows.js';
+export default defineOperationApi({
+    id: 'trigger',
+    handler: async ({ flow, payload, iterationMode, batchSize }, context) => {
+        const flowManager = getFlowManager();
+        const payloadObject = optionToObject(payload) ?? null;
+        if (Array.isArray(payloadObject)) {
+            if (iterationMode === 'serial') {
+                const result = [];
+                for (const payload of payloadObject) {
+                    result.push(await flowManager.runOperationFlow(flow, payload, omit(context, 'data')));
+                }
+                return result;
+            }
+            if (iterationMode === 'batch') {
+                const size = batchSize ?? 10;
+                const result = [];
+                for (let i = 0; i < payloadObject.length; i += size) {
+                    const batch = payloadObject.slice(i, i + size);
+                    const batchResults = await Promise.all(batch.map((payload) => {
+                        return flowManager.runOperationFlow(flow, payload, omit(context, 'data'));
+                    }));
+                    result.push(...batchResults);
+                }
+                return result;
+            }
+            if (iterationMode === 'parallel' || !iterationMode) {
+                return await Promise.all(payloadObject.map((payload) => {
+                    return flowManager.runOperationFlow(flow, payload, omit(context, 'data'));
+                }));
+            }
+        }
+        return await flowManager.runOperationFlow(flow, payloadObject, omit(context, 'data'));
+    },
+});

package/dist/operations/trigger/index.test.d.ts

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

package/dist/rate-limiter.d.ts

@@ -0,0 +1,4 @@
+import { IRateLimiterOptions, IRateLimiterStoreOptions, RateLimiterAbstract } from 'rate-limiter-flexible';
+type IRateLimiterOptionsOverrides = Partial<IRateLimiterOptions> | Partial<IRateLimiterStoreOptions>;
+export declare function createRateLimiter(configPrefix?: string, configOverrides?: IRateLimiterOptionsOverrides): RateLimiterAbstract;
+export {};