@directus/api 32.1.1 → 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/extensions/lib/sync-extensions.d.ts

@@ -1,3 +0,0 @@
-export declare const syncExtensions: (options?: {
-    force: boolean;
-}) => Promise<void>;

package/dist/extensions/lib/sync-extensions.js

@@ -1,70 +0,0 @@
-import { useEnv } from '@directus/env';
-import { exists } from 'fs-extra';
-import mid from 'node-machine-id';
-import { createWriteStream } from 'node:fs';
-import { mkdir, rm } from 'node:fs/promises';
-import { dirname, join, relative, resolve, sep } from 'node:path';
-import { pipeline } from 'node:stream/promises';
-import Queue from 'p-queue';
-import { useBus } from '../../bus/index.js';
-import { useLock } from '../../lock/index.js';
-import { useLogger } from '../../logger/index.js';
-import { getStorage } from '../../storage/index.js';
-import { getExtensionsPath } from './get-extensions-path.js';
-import { SyncStatus, getSyncStatus, setSyncStatus } from './sync-status.js';
-export const syncExtensions = async (options) => {
-    const lock = useLock();
-    const messenger = useBus();
-    const env = useEnv();
-    const logger = useLogger();
-    if (!options?.force) {
-        const isDone = (await getSyncStatus()) === SyncStatus.DONE;
-        if (isDone)
-            return;
-    }
-    const machineId = await mid.machineId();
-    const machineKey = `extensions-sync/${machineId}`;
-    const processId = await lock.increment(machineKey);
-    const currentProcessShouldHandleSync = processId === 1;
-    if (currentProcessShouldHandleSync === false) {
-        logger.trace('Extensions already being synced to this machine from another process.');
-        // Wait until the process that called the lock publishes a message that the syncing is complete
-        return new Promise((resolve) => {
-            messenger.subscribe(machineKey, () => resolve());
-        });
-    }
-    try {
-        const extensionsPath = getExtensionsPath();
-        const storageExtensionsPath = env['EXTENSIONS_PATH'];
-        if (await exists(extensionsPath)) {
-            // In case the FS still contains the cached extensions from a previous invocation. We have to
-            // clear them out to ensure the remote extensions folder remains the source of truth for all
-            // extensions that are loaded.
-            await rm(extensionsPath, { recursive: true, force: true });
-        }
-        // Ensure that the local extensions cache path exists
-        await mkdir(extensionsPath, { recursive: true });
-        await setSyncStatus(SyncStatus.SYNCING);
-        logger.trace('Syncing extensions from configured storage location...');
-        const storage = await getStorage();
-        const disk = storage.location(env['EXTENSIONS_LOCATION']);
-        // Make sure we don't overload the file handles
-        const queue = new Queue({ concurrency: 1000 });
-        for await (const filepath of disk.list(storageExtensionsPath)) {
-            const readStream = await disk.read(filepath);
-            // We want files to be stored in the root of `$TEMP_PATH/extensions`, so gotta remove the
-            // extensions path on disk from the start of the file path
-            const destPath = join(extensionsPath, relative(resolve(sep, storageExtensionsPath), resolve(sep, filepath)));
-            // Ensure that the directory path exists
-            await mkdir(dirname(destPath), { recursive: true });
-            const writeStream = createWriteStream(destPath);
-            queue.add(() => pipeline(readStream, writeStream));
-        }
-        await queue.onIdle();
-        await setSyncStatus(SyncStatus.DONE);
-        messenger.publish(machineKey, { ready: true });
-    }
-    finally {
-        await lock.delete(machineKey);
-    }
-};

package/dist/extensions/lib/sync-status.d.ts

@@ -1,10 +0,0 @@
-export declare enum SyncStatus {
-    UNKNOWN = "UNKNOWN",
-    SYNCING = "SYNCING",
-    DONE = "DONE"
-}
-/**
- * Retrieves the sync status from the `.status` file in the local extensions folder
- */
-export declare const getSyncStatus: () => Promise<string>;
-export declare const setSyncStatus: (status: SyncStatus) => Promise<void>;

package/dist/extensions/lib/sync-status.js

@@ -1,27 +0,0 @@
-import { exists } from 'fs-extra';
-import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { getExtensionsPath } from './get-extensions-path.js';
-export var SyncStatus;
-(function (SyncStatus) {
-    SyncStatus["UNKNOWN"] = "UNKNOWN";
-    SyncStatus["SYNCING"] = "SYNCING";
-    SyncStatus["DONE"] = "DONE";
-})(SyncStatus || (SyncStatus = {}));
-/**
- * Retrieves the sync status from the `.status` file in the local extensions folder
- */
-export const getSyncStatus = async () => {
-    const statusFilePath = join(getExtensionsPath(), '.status');
-    if (await exists(statusFilePath)) {
-        const status = await readFile(statusFilePath, 'utf8');
-        return status;
-    }
-    else {
-        return SyncStatus.UNKNOWN;
-    }
-};
-export const setSyncStatus = async (status) => {
-    const statusFilePath = join(getExtensionsPath(), '.status');
-    await writeFile(statusFilePath, status);
-};

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

@@ -1,15 +0,0 @@
-import type { ToolConfig } from '../types.js';
-import { collections } from './collections.js';
-import { fields } from './fields.js';
-import { files } from './files.js';
-import { flows } from './flows.js';
-import { items } from './items.js';
-import { operations } from './operations.js';
-import { relations } from './relations.js';
-import { schema } from './schema.js';
-import { system } from './system.js';
-import { triggerFlow } from './trigger-flow.js';
-export declare const ALL_TOOLS: ToolConfig<any>[];
-export declare const getAllMcpTools: () => ToolConfig<any>[];
-export declare const findMcpTool: (name: string) => ToolConfig<any> | undefined;
-export { collections, fields, files, flows, items, operations, relations, schema, system, triggerFlow };

package/dist/mcp/tools/index.js

@@ -1,29 +0,0 @@
-import { assets } from './assets.js';
-import { collections } from './collections.js';
-import { fields } from './fields.js';
-import { files } from './files.js';
-import { flows } from './flows.js';
-import { folders } from './folders.js';
-import { items } from './items.js';
-import { operations } from './operations.js';
-import { relations } from './relations.js';
-import { schema } from './schema.js';
-import { system } from './system.js';
-import { triggerFlow } from './trigger-flow.js';
-export const ALL_TOOLS = [
-    system,
-    items,
-    files,
-    folders,
-    assets,
-    flows,
-    triggerFlow,
-    operations,
-    schema,
-    collections,
-    fields,
-    relations,
-];
-export const getAllMcpTools = () => ALL_TOOLS;
-export const findMcpTool = (name) => ALL_TOOLS.find((tool) => tool.name === name);
-export { collections, fields, files, flows, items, operations, relations, schema, system, triggerFlow };

package/dist/mcp/tools/prompts/index.d.ts

@@ -1,16 +0,0 @@
-declare const _default: {
-    assets: string;
-    collections: string;
-    fields: string;
-    files: string;
-    folders: string;
-    flows: string;
-    items: string;
-    operations: string;
-    relations: string;
-    schema: string;
-    systemPrompt: string;
-    systemPromptDescription: string;
-    triggerFlow: string;
-};
-export default _default;

package/dist/mcp/tools/prompts/index.js

@@ -1,19 +0,0 @@
-import fse from 'fs-extra';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-export default {
-    assets: fse.readFileSync(join(__dirname, 'assets.md'), 'utf8'),
-    collections: fse.readFileSync(join(__dirname, 'collections.md'), 'utf8'),
-    fields: fse.readFileSync(join(__dirname, 'fields.md'), 'utf8'),
-    files: fse.readFileSync(join(__dirname, 'files.md'), 'utf8'),
-    folders: fse.readFileSync(join(__dirname, 'folders.md'), 'utf8'),
-    flows: fse.readFileSync(join(__dirname, 'flows.md'), 'utf8'),
-    items: fse.readFileSync(join(__dirname, 'items.md'), 'utf8'),
-    operations: fse.readFileSync(join(__dirname, 'operations.md'), 'utf8'),
-    relations: fse.readFileSync(join(__dirname, 'relations.md'), 'utf8'),
-    schema: fse.readFileSync(join(__dirname, 'schema.md'), 'utf8'),
-    systemPrompt: fse.readFileSync(join(__dirname, 'system-prompt.md'), 'utf8'),
-    systemPromptDescription: fse.readFileSync(join(__dirname, 'system-prompt-description.md'), 'utf8'),
-    triggerFlow: fse.readFileSync(join(__dirname, 'trigger-flow.md'), 'utf8'),
-};

package/dist/permissions/modules/fetch-global-access/lib/fetch-global-access-for-roles.d.ts

@@ -1,5 +0,0 @@
-import type { Accountability } from '@directus/types';
-import type { Knex } from 'knex';
-import type { GlobalAccess } from '../types.js';
-export declare const fetchGlobalAccessForRoles: typeof _fetchGlobalAccessForRoles;
-export declare function _fetchGlobalAccessForRoles(accountability: Pick<Accountability, 'roles' | 'ip'>, knex: Knex): Promise<GlobalAccess>;

package/dist/permissions/modules/fetch-global-access/lib/fetch-global-access-for-roles.js

@@ -1,7 +0,0 @@
-import { withCache } from '../../../utils/with-cache.js';
-import { fetchGlobalAccessForQuery } from '../utils/fetch-global-access-for-query.js';
-export const fetchGlobalAccessForRoles = withCache('global-access-role', _fetchGlobalAccessForRoles, ({ roles, ip }) => ({ roles, ip }));
-export async function _fetchGlobalAccessForRoles(accountability, knex) {
-    const query = knex.where('role', 'in', accountability.roles);
-    return await fetchGlobalAccessForQuery(query, accountability);
-}

package/dist/permissions/modules/fetch-global-access/lib/fetch-global-access-for-user.d.ts

@@ -1,5 +0,0 @@
-import type { Accountability } from '@directus/types';
-import type { Knex } from 'knex';
-import type { GlobalAccess } from '../types.js';
-export declare const fetchGlobalAccessForUser: typeof _fetchGlobalAccessForUser;
-export declare function _fetchGlobalAccessForUser(accountability: Pick<Accountability, 'user' | 'ip'>, knex: Knex): Promise<GlobalAccess>;

package/dist/permissions/modules/fetch-global-access/lib/fetch-global-access-for-user.js

@@ -1,10 +0,0 @@
-import { withCache } from '../../../utils/with-cache.js';
-import { fetchGlobalAccessForQuery } from '../utils/fetch-global-access-for-query.js';
-export const fetchGlobalAccessForUser = withCache('global-access-user', _fetchGlobalAccessForUser, ({ user, ip }) => ({
-    user,
-    ip,
-}));
-export async function _fetchGlobalAccessForUser(accountability, knex) {
-    const query = knex.where('user', '=', accountability.user);
-    return await fetchGlobalAccessForQuery(query, accountability);
-}

package/dist/permissions/modules/fetch-global-access/types.d.ts

@@ -1,4 +0,0 @@
-export interface GlobalAccess {
-    app: boolean;
-    admin: boolean;
-}

package/dist/permissions/modules/fetch-global-access/utils/fetch-global-access-for-query.d.ts

@@ -1,4 +0,0 @@
-import type { Accountability } from '@directus/types';
-import type { Knex } from 'knex';
-import type { GlobalAccess } from '../types.js';
-export declare function fetchGlobalAccessForQuery(query: Knex.QueryBuilder<any, any[]>, accountability: Pick<Accountability, 'ip'>): Promise<GlobalAccess>;

package/dist/permissions/modules/fetch-global-access/utils/fetch-global-access-for-query.js

@@ -1,27 +0,0 @@
-import { toBoolean, toArray } from '@directus/utils';
-import { ipInNetworks } from '../../../../utils/ip-in-networks.js';
-export async function fetchGlobalAccessForQuery(query, accountability) {
-    const globalAccess = {
-        app: false,
-        admin: false,
-    };
-    const accessRows = await query
-        .select('directus_policies.admin_access', 'directus_policies.app_access', 'directus_policies.ip_access')
-        .from('directus_access')
-        // @NOTE: `where` clause comes from the caller
-        .leftJoin('directus_policies', 'directus_policies.id', 'directus_access.policy');
-    // Additively merge access permissions
-    for (const { admin_access, app_access, ip_access } of accessRows) {
-        if (accountability.ip && ip_access) {
-            // Skip row if IP is not in the allowed networks
-            const networks = toArray(ip_access);
-            if (!ipInNetworks(accountability.ip, networks))
-                continue;
-        }
-        globalAccess.admin ||= toBoolean(admin_access);
-        globalAccess.app ||= globalAccess.admin || toBoolean(app_access);
-        if (globalAccess.admin)
-            break;
-    }
-    return globalAccess;
-}

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/get-date-formatted.d.ts

@@ -1 +0,0 @@
-export declare function getDateFormatted(): string;

package/dist/utils/get-date-formatted.js

@@ -1,10 +0,0 @@
-export function getDateFormatted() {
-    const date = new Date();
-    let month = String(date.getMonth() + 1);
-    if (month.length === 1)
-        month = '0' + month;
-    let day = String(date.getDate());
-    if (day.length === 1)
-        day = '0' + day;
-    return `${date.getFullYear()}${month}${day}-${date.getHours()}${date.getMinutes()}${date.getSeconds()}`;
-}

package/dist/utils/ip-in-networks.d.ts

@@ -1,6 +0,0 @@
-/**
- * Checks if an IP address is contained in a list of networks
- * @param networks List of IP addresses (192.168.0.1), CIDR notations (192.168.0.0/24) or IP ranges (192-168.0.0-192.168.2.0)
- * @throws Will throw if list contains invalid network definitions
- */
-export declare function ipInNetworks(ip: string, networks: string[]): boolean;

package/dist/utils/ip-in-networks.js

@@ -1,13 +0,0 @@
-import { matches } from 'ip-matching';
-/**
- * Checks if an IP address is contained in a list of networks
- * @param networks List of IP addresses (192.168.0.1), CIDR notations (192.168.0.0/24) or IP ranges (192-168.0.0-192.168.2.0)
- * @throws Will throw if list contains invalid network definitions
- */
-export function ipInNetworks(ip, networks) {
-    for (const allowedIp of networks) {
-        if (matches(ip, allowedIp))
-            return true;
-    }
-    return false;
-}

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;