@directus/api 21.0.0-rc.0 → 22.0.0

package/dist/app.js

@@ -50,7 +50,7 @@ import { createExpressLogger, useLogger } from './logger/index.js';
 import authenticate from './middleware/authenticate.js';
 import cache from './middleware/cache.js';
 import cors from './middleware/cors.js';
-import errorHandler from './middleware/error-handler.js';
+import { errorHandler } from './middleware/error-handler.js';
 import extractToken from './middleware/extract-token.js';
 import rateLimiterGlobal from './middleware/rate-limiter-global.js';
 import rateLimiter from './middleware/rate-limiter-ip.js';

package/dist/cache.d.ts

@@ -3,7 +3,6 @@ import Keyv from 'keyv';
 export declare function getCache(): {
     cache: Keyv | null;
     systemCache: Keyv;
-    sharedSchemaCache: Keyv;
     localSchemaCache: Keyv;
     lockCache: Keyv;
 };

package/dist/cache.js

@@ -1,5 +1,4 @@
 import { useEnv } from '@directus/env';
-import { getSimpleHash } from '@directus/utils';
 import Keyv from 'keyv';
 import { useBus } from './bus/index.js';
 import { useLogger } from './logger/index.js';
@@ -16,16 +15,16 @@ const require = createRequire(import.meta.url);
 let cache = null;
 let systemCache = null;
 let localSchemaCache = null;
-let sharedSchemaCache = null;
 let lockCache = null;
 let messengerSubscribed = false;
 const messenger = useBus();
-if (redisConfigAvailable() && env['CACHE_STORE'] === 'memory' && env['CACHE_AUTO_PURGE'] && !messengerSubscribed) {
+if (redisConfigAvailable() && !messengerSubscribed) {
     messengerSubscribed = true;
     messenger.subscribe('schemaChanged', async (opts) => {
-        if (cache && opts?.['autoPurgeCache'] !== false) {
+        if (env['CACHE_STORE'] === 'memory' && env['CACHE_AUTO_PURGE'] && cache && opts?.['autoPurgeCache'] !== false) {
             await cache.clear();
         }
+        await localSchemaCache?.clear();
     });
 }
 export function getCache() {
@@ -38,10 +37,6 @@ export function getCache() {
         systemCache = getKeyvInstance(env['CACHE_STORE'], getMilliseconds(env['CACHE_SYSTEM_TTL']), '_system');
         systemCache.on('error', (err) => logger.warn(err, `[system-cache] ${err}`));
     }
-    if (sharedSchemaCache === null) {
-        sharedSchemaCache = getKeyvInstance(env['CACHE_STORE'], getMilliseconds(env['CACHE_SYSTEM_TTL']), '_schema_shared');
-        sharedSchemaCache.on('error', (err) => logger.warn(err, `[shared-schema-cache] ${err}`));
-    }
     if (localSchemaCache === null) {
         localSchemaCache = getKeyvInstance('memory', getMilliseconds(env['CACHE_SYSTEM_TTL']), '_schema');
         localSchemaCache.on('error', (err) => logger.warn(err, `[schema-cache] ${err}`));
@@ -50,7 +45,7 @@ export function getCache() {
         lockCache = getKeyvInstance(env['CACHE_STORE'], undefined, '_lock');
         lockCache.on('error', (err) => logger.warn(err, `[lock-cache] ${err}`));
     }
-    return { cache, systemCache, sharedSchemaCache, localSchemaCache, lockCache };
+    return { cache, systemCache, localSchemaCache, lockCache };
 }
 export async function flushCaches(forced) {
     const { cache } = getCache();
@@ -58,14 +53,13 @@ export async function flushCaches(forced) {
     await cache?.clear();
 }
 export async function clearSystemCache(opts) {
-    const { systemCache, localSchemaCache, lockCache, sharedSchemaCache } = getCache();
+    const { systemCache, localSchemaCache, lockCache } = getCache();
     // Flush system cache when forced or when system cache lock not set
     if (opts?.forced || !(await lockCache.get('system-cache-lock'))) {
         await lockCache.set('system-cache-lock', true, 10000);
         await systemCache.clear();
         await lockCache.delete('system-cache-lock');
     }
-    await sharedSchemaCache.clear();
     await localSchemaCache.clear();
     // Since a lot of cached permission function rely on the schema it needs to be cleared as well
     await clearPermissionCache();
@@ -82,20 +76,11 @@ export async function getSystemCache(key) {
     return await getCacheValue(systemCache, key);
 }
 export async function setSchemaCache(schema) {
-    const { localSchemaCache, sharedSchemaCache } = getCache();
-    const schemaHash = getSimpleHash(JSON.stringify(schema));
-    await sharedSchemaCache.set('hash', schemaHash);
+    const { localSchemaCache } = getCache();
     await localSchemaCache.set('schema', schema);
-    await localSchemaCache.set('hash', schemaHash);
 }
 export async function getSchemaCache() {
-    const { localSchemaCache, sharedSchemaCache } = getCache();
-    const sharedSchemaHash = await sharedSchemaCache.get('hash');
-    if (!sharedSchemaHash)
-        return;
-    const localSchemaHash = await localSchemaCache.get('hash');
-    if (!localSchemaHash || localSchemaHash !== sharedSchemaHash)
-        return;
+    const { localSchemaCache } = getCache();
     return await localSchemaCache.get('schema');
 }
 export async function setCacheValue(cache, key, value, ttl) {

package/dist/controllers/tus.js

@@ -1,11 +1,11 @@
 import { Router } from 'express';
+import { RESUMABLE_UPLOADS } from '../constants.js';
 import getDatabase from '../database/index.js';
 import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
-import { getSchema } from '../utils/get-schema.js';
-import { scheduleSynchronizedJob, validateCron } from '../utils/schedule.js';
 import { createTusServer } from '../services/tus/index.js';
 import asyncHandler from '../utils/async-handler.js';
-import { RESUMABLE_UPLOADS } from '../constants.js';
+import { getSchema } from '../utils/get-schema.js';
+import { scheduleSynchronizedJob, validateCron } from '../utils/schedule.js';
 const mapAction = (method) => {
     switch (method) {
         case 'POST':
@@ -33,21 +33,23 @@ const checkFileAccess = asyncHandler(async (req, _res, next) => {
     return next();
 });
 const handler = asyncHandler(async (req, res) => {
-    const tusServer = await createTusServer({
+    const [tusServer, cleanupServer] = await createTusServer({
         schema: req.schema,
         accountability: req.accountability,
     });
     await tusServer.handle(req, res);
+    cleanupServer();
 });
 export function scheduleTusCleanup() {
     if (!RESUMABLE_UPLOADS.ENABLED)
         return;
     if (validateCron(RESUMABLE_UPLOADS.SCHEDULE)) {
         scheduleSynchronizedJob('tus-cleanup', RESUMABLE_UPLOADS.SCHEDULE, async () => {
-            const tusServer = await createTusServer({
+            const [tusServer, cleanupServer] = await createTusServer({
                 schema: await getSchema(),
             });
             await tusServer.cleanUpExpiredUploads();
+            cleanupServer();
         });
     }
 }

package/dist/database/get-ast-from-query/lib/parse-fields.d.ts

@@ -12,4 +12,4 @@ export interface ParseFieldsContext {
     schema: SchemaOverview;
     knex: Knex;
 }
-export declare function parseFields(options: ParseFieldsOptions, context: ParseFieldsContext): Promise<(NestedCollectionNode | FieldNode | FunctionFieldNode)[]>;
+export declare function parseFields(options: ParseFieldsOptions, context: ParseFieldsContext): Promise<[] | (NestedCollectionNode | FieldNode | FunctionFieldNode)[]>;

package/dist/database/get-ast-from-query/lib/parse-fields.js

@@ -88,6 +88,16 @@ export async function parseFields(options, context) {
                     }
                 }
             }
+            if (name.includes(':')) {
+                const [key, scope] = name.split(':');
+                if (key in relationalStructure === false) {
+                    relationalStructure[key] = { [scope]: [] };
+                }
+                else if (scope in relationalStructure[key] === false) {
+                    relationalStructure[key][scope] = [];
+                }
+                continue;
+            }
             children.push({ type: 'field', name, fieldKey, whenCase: [] });
         }
     }

package/dist/database/helpers/schema/dialects/cockroachdb.d.ts

@@ -1,8 +1,9 @@
 import type { KNEX_TYPES } from '@directus/constants';
-import type { Options } from '../types.js';
+import type { Options, Sql } from '../types.js';
 import { SchemaHelper } from '../types.js';
 export declare class SchemaHelperCockroachDb extends SchemaHelper {
     changeToType(table: string, column: string, type: (typeof KNEX_TYPES)[number], options?: Options): Promise<void>;
     constraintName(existingName: string): string;
     getDatabaseSize(): Promise<number | null>;
+    preprocessBindings(queryParams: Sql): Sql;
 }

package/dist/database/helpers/schema/dialects/cockroachdb.js

@@ -1,5 +1,6 @@
 import { SchemaHelper } from '../types.js';
 import { useEnv } from '@directus/env';
+import { preprocessBindings } from '../utils/preprocess-bindings.js';
 const env = useEnv();
 export class SchemaHelperCockroachDb extends SchemaHelper {
     async changeToType(table, column, type, options = {}) {
@@ -27,4 +28,7 @@ export class SchemaHelperCockroachDb extends SchemaHelper {
             return null;
         }
     }
+    preprocessBindings(queryParams) {
+        return preprocessBindings(queryParams, { format: (index) => `$${index + 1}` });
+    }
 }

package/dist/database/helpers/schema/dialects/mssql.d.ts

@@ -1,8 +1,9 @@
 import type { Knex } from 'knex';
-import { SchemaHelper } from '../types.js';
+import { SchemaHelper, type Sql } from '../types.js';
 export declare class SchemaHelperMSSQL extends SchemaHelper {
     applyLimit(rootQuery: Knex.QueryBuilder, limit: number): void;
     applyOffset(rootQuery: Knex.QueryBuilder, offset: number): void;
     formatUUID(uuid: string): string;
     getDatabaseSize(): Promise<number | null>;
+    preprocessBindings(queryParams: Sql): Sql;
 }

package/dist/database/helpers/schema/dialects/mssql.js

@@ -1,4 +1,5 @@
 import { SchemaHelper } from '../types.js';
+import { preprocessBindings } from '../utils/preprocess-bindings.js';
 export class SchemaHelperMSSQL extends SchemaHelper {
     applyLimit(rootQuery, limit) {
         // The ORDER BY clause is invalid in views, inline functions, derived tables, subqueries,
@@ -26,4 +27,7 @@ export class SchemaHelperMSSQL extends SchemaHelper {
             return null;
         }
     }
+    preprocessBindings(queryParams) {
+        return preprocessBindings(queryParams, { format: (index) => `@p${index}` });
+    }
 }

package/dist/database/helpers/schema/dialects/oracle.d.ts

@@ -1,6 +1,6 @@
 import type { KNEX_TYPES } from '@directus/constants';
 import type { Field, Relation, Type } from '@directus/types';
-import type { Options } from '../types.js';
+import type { Options, Sql } from '../types.js';
 import { SchemaHelper } from '../types.js';
 export declare class SchemaHelperOracle extends SchemaHelper {
     changeToType(table: string, column: string, type: (typeof KNEX_TYPES)[number], options?: Options): Promise<void>;
@@ -8,4 +8,5 @@ export declare class SchemaHelperOracle extends SchemaHelper {
     preRelationChange(relation: Partial<Relation>): void;
     processFieldType(field: Field): Type;
     getDatabaseSize(): Promise<number | null>;
+    preprocessBindings(queryParams: Sql): Sql;
 }

package/dist/database/helpers/schema/dialects/oracle.js

@@ -1,4 +1,5 @@
 import { SchemaHelper } from '../types.js';
+import { preprocessBindings } from '../utils/preprocess-bindings.js';
 export class SchemaHelperOracle extends SchemaHelper {
     async changeToType(table, column, type, options = {}) {
         await this.changeToTypeByCopy(table, column, type, options);
@@ -38,4 +39,7 @@ export class SchemaHelperOracle extends SchemaHelper {
             return null;
         }
     }
+    preprocessBindings(queryParams) {
+        return preprocessBindings(queryParams, { format: (index) => `:${index + 1}` });
+    }
 }

package/dist/database/helpers/schema/dialects/postgres.d.ts

@@ -1,4 +1,5 @@
-import { SchemaHelper } from '../types.js';
+import { SchemaHelper, type Sql } from '../types.js';
 export declare class SchemaHelperPostgres extends SchemaHelper {
     getDatabaseSize(): Promise<number | null>;
+    preprocessBindings(queryParams: Sql): Sql;
 }

package/dist/database/helpers/schema/dialects/postgres.js

@@ -1,5 +1,6 @@
 import { useEnv } from '@directus/env';
 import { SchemaHelper } from '../types.js';
+import { preprocessBindings } from '../utils/preprocess-bindings.js';
 const env = useEnv();
 export class SchemaHelperPostgres extends SchemaHelper {
     async getDatabaseSize() {
@@ -11,4 +12,7 @@ export class SchemaHelperPostgres extends SchemaHelper {
             return null;
         }
     }
+    preprocessBindings(queryParams) {
+        return preprocessBindings(queryParams, { format: (index) => `$${index + 1}` });
+    }
 }

package/dist/database/helpers/schema/types.d.ts

@@ -8,6 +8,10 @@ export type Options = {
     default?: any;
     length?: number;
 };
+export type Sql = {
+    sql: string;
+    bindings: readonly Knex.Value[];
+};
 export declare abstract class SchemaHelper extends DatabaseHelper {
     isOneOfClients(clients: DatabaseClient[]): boolean;
     changeNullable(table: string, column: string, nullable: boolean): Promise<void>;
@@ -27,4 +31,5 @@ export declare abstract class SchemaHelper extends DatabaseHelper {
      * @returns Size of the database in bytes
      */
     getDatabaseSize(): Promise<number | null>;
+    preprocessBindings(queryParams: Sql): Sql;
 }

package/dist/database/helpers/schema/types.js

@@ -94,4 +94,7 @@ export class SchemaHelper extends DatabaseHelper {
     async getDatabaseSize() {
         return null;
     }
+    preprocessBindings(queryParams) {
+        return queryParams;
+    }
 }

package/dist/database/helpers/schema/utils/preprocess-bindings.d.ts

@@ -0,0 +1,8 @@
+import type { Sql } from '../types.js';
+export type PreprocessBindingsOptions = {
+    format(index: number): string;
+};
+export declare function preprocessBindings(queryParams: (Partial<Sql> & Pick<Sql, 'sql'>) | string, options: PreprocessBindingsOptions): {
+    sql: string;
+    bindings: import("knex").Knex.Value[];
+};

package/dist/database/helpers/schema/utils/preprocess-bindings.js

@@ -0,0 +1,30 @@
+import { isString } from 'lodash-es';
+export function preprocessBindings(queryParams, options) {
+    const query = { bindings: [], ...(isString(queryParams) ? { sql: queryParams } : queryParams) };
+    const bindingIndices = new Array(query.bindings.length);
+    for (let i = 0; i < query.bindings.length; i++) {
+        const binding = query.bindings[i];
+        const prevIndex = query.bindings.findIndex((b, j) => j < i && b === binding);
+        if (prevIndex !== -1) {
+            bindingIndices[i] = prevIndex;
+        }
+        else {
+            bindingIndices[i] = i;
+        }
+    }
+    let matchIndex = 0;
+    let currentBindingIndex = 0;
+    const sql = query.sql.replace(/(\\*)(\?)/g, function (_, escapes) {
+        if (escapes.length % 2) {
+            // Return an escaped question mark, so it stays escaped
+            return `${'\\'.repeat(escapes.length)}?`;
+        }
+        else {
+            const bindingIndex = bindingIndices[matchIndex] === matchIndex ? currentBindingIndex++ : bindingIndices[matchIndex];
+            matchIndex++;
+            return options.format(bindingIndex);
+        }
+    });
+    const bindings = query.bindings.filter((_, i) => bindingIndices[i] === i);
+    return { ...query, sql, bindings };
+}

package/dist/database/index.js

@@ -1,5 +1,6 @@
 import { useEnv } from '@directus/env';
 import { createInspector } from '@directus/schema';
+import { isObject } from '@directus/utils';
 import fse from 'fs-extra';
 import knex from 'knex';
 import { merge } from 'lodash-es';
@@ -106,6 +107,9 @@ export function getDatabase() {
         };
     }
     if (client === 'mysql') {
+        // Remove the conflicting `filename` option, defined by default in the Docker Image
+        if (isObject(knexConfig.connection))
+            delete knexConfig.connection['filename'];
         Object.assign(knexConfig, { client: 'mysql2' });
         poolConfig.afterCreate = async (conn, callback) => {
             logger.trace('Retrieving database version');
@@ -123,15 +127,19 @@ export function getDatabase() {
     }
     database = knex.default(knexConfig);
     validateDatabaseCharset(database);
-    const times = {};
+    const times = new Map();
     database
-        .on('query', (queryInfo) => {
-        times[queryInfo.__knexUid] = performance.now();
+        .on('query', ({ __knexUid }) => {
+        times.set(__knexUid, performance.now());
     })
         .on('query-response', (_response, queryInfo) => {
-        const delta = performance.now() - times[queryInfo.__knexUid];
-        logger.trace(`[${delta.toFixed(3)}ms] ${queryInfo.sql} [${queryInfo.bindings.join(', ')}]`);
-        delete times[queryInfo.__knexUid];
+        const time = times.get(queryInfo.__knexUid);
+        let delta;
+        if (time) {
+            delta = performance.now() - time;
+            times.delete(queryInfo.__knexUid);
+        }
+        logger.trace(`[${delta ? delta.toFixed(3) : '?'}ms] ${queryInfo.sql} [${(queryInfo.bindings ?? []).join(', ')}]`);
     });
     return database;
 }

package/dist/database/migrations/20240305A-change-useragent-type.js

@@ -7,7 +7,7 @@ export async function up(knex) {
     ]);
 }
 export async function down(knex) {
-    const helper = await getHelpers(knex).schema;
+    const helper = getHelpers(knex).schema;
     const opts = {
         nullable: false,
         length: 255,

package/dist/database/migrations/20240716A-update-files-date-fields.js

@@ -0,0 +1,33 @@
+import { getHelpers } from '../helpers/index.js';
+export async function up(knex) {
+    const helper = getHelpers(knex).schema;
+    const isMysql = helper.isOneOfClients(['mysql']);
+    if (isMysql) {
+        // Knex creates invalid statement on MySQL, see https://github.com/knex/knex/issues/1888
+        await knex.schema.raw('ALTER TABLE `directus_files` CHANGE `uploaded_on` `created_on` TIMESTAMP NOT NULL DEFAULT current_timestamp();');
+    }
+    else {
+        await knex.schema.alterTable('directus_files', (table) => {
+            table.renameColumn('uploaded_on', 'created_on');
+        });
+    }
+    await knex.schema.alterTable('directus_files', (table) => {
+        table.timestamp('uploaded_on');
+    });
+    await knex('directus_files').update('uploaded_on', knex.ref('created_on'));
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_files', (table) => {
+        table.dropColumn('uploaded_on');
+    });
+    const helper = getHelpers(knex).schema;
+    const isMysql = helper.isOneOfClients(['mysql']);
+    if (isMysql) {
+        await knex.schema.raw('ALTER TABLE `directus_files` CHANGE `created_on` `uploaded_on` TIMESTAMP NOT NULL DEFAULT current_timestamp();');
+    }
+    else {
+        await knex.schema.alterTable('directus_files', (table) => {
+            table.renameColumn('created_on', 'uploaded_on');
+        });
+    }
+}

package/dist/database/migrations/20240806A-permissions-policies.d.ts

@@ -0,0 +1,6 @@
+import type { Knex } from 'knex';
+import type { Permission } from '@directus/types';
+export declare function mergePermissions(strategy: 'and' | 'or', ...permissions: Permission[][]): any[];
+export declare function mergePermission(strategy: 'and' | 'or', currentPerm: Permission, newPerm: Permission): Omit<Permission, 'id' | 'system'>;
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;