@directus/api 23.1.2 → 23.2.0

package/dist/app.js

@@ -38,11 +38,14 @@ import serverRouter from './controllers/server.js';
 import settingsRouter from './controllers/settings.js';
 import sharesRouter from './controllers/shares.js';
 import translationsRouter from './controllers/translations.js';
-import { default as tusRouter, scheduleTusCleanup } from './controllers/tus.js';
+import tusRouter from './controllers/tus.js';
 import usersRouter from './controllers/users.js';
 import utilsRouter from './controllers/utils.js';
 import versionsRouter from './controllers/versions.js';
 import webhooksRouter from './controllers/webhooks.js';
+import retentionSchedule from './schedules/retention.js';
+import telemetrySchedule from './schedules/telemetry.js';
+import tusSchedule from './schedules/tus.js';
 import { isInstalled, validateDatabaseConnection, validateDatabaseExtensions, validateMigrations, } from './database/index.js';
 import emitter from './emitter.js';
 import { getExtensionManager } from './extensions/index.js';
@@ -57,7 +60,6 @@ import rateLimiterGlobal from './middleware/rate-limiter-global.js';
 import rateLimiter from './middleware/rate-limiter-ip.js';
 import sanitizeQuery from './middleware/sanitize-query.js';
 import schema from './middleware/schema.js';
-import { initTelemetry } from './telemetry/index.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { Url } from './utils/url.js';
 import { validateStorage } from './utils/validate-storage.js';
@@ -246,8 +248,9 @@ export default async function createApp() {
     app.use(notFoundHandler);
     app.use(errorHandler);
     await emitter.emitInit('routes.after', { app });
-    initTelemetry();
-    scheduleTusCleanup();
+    await retentionSchedule();
+    await telemetrySchedule();
+    await tusSchedule();
     await emitter.emitInit('app.after', { app });
     return app;
 }

package/dist/auth/drivers/openid.js

@@ -259,7 +259,7 @@ export function createOpenIDAuthRouter(providerName) {
             throw new InvalidPayloadError({ reason: `URL "${redirect}" can't be used to redirect after login` });
         }
         const token = jwt.sign({ verifier: codeVerifier, redirect, prompt }, getSecret(), {
-            expiresIn: '5m',
+            expiresIn: (env[`AUTH_${providerName.toUpperCase()}_LOGIN_TIMEOUT`] ?? '5m'),
             issuer: 'directus',
         });
         res.cookie(`openid.${providerName}`, token, {

package/dist/controllers/activity.js

@@ -1,11 +1,8 @@
-import { ErrorCode, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import express from 'express';
-import Joi from 'joi';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
 import { ActivityService } from '../services/activity.js';
-import { CommentsService } from '../services/comments.js';
 import { MetaService } from '../services/meta.js';
 import asyncHandler from '../utils/async-handler.js';
 const router = express.Router();
@@ -20,7 +17,6 @@ const readHandler = asyncHandler(async (req, res, next) => {
         schema: req.schema,
     });
     let result;
-    let isComment;
     if (req.singleton) {
         result = await service.readSingleton(req.sanitizedQuery);
     }
@@ -28,24 +24,9 @@ const readHandler = asyncHandler(async (req, res, next) => {
         result = await service.readMany(req.body.keys, req.sanitizedQuery);
     }
     else {
-        const sanitizedFilter = req.sanitizedQuery.filter;
-        if (sanitizedFilter &&
-            '_and' in sanitizedFilter &&
-            Array.isArray(sanitizedFilter['_and']) &&
-            sanitizedFilter['_and'].find((andItem) => 'action' in andItem && '_eq' in andItem['action'] && andItem['action']['_eq'] === 'comment')) {
-            const commentsService = new CommentsService({
-                accountability: req.accountability,
-                schema: req.schema,
-                serviceOrigin: 'activity',
-            });
-            result = await commentsService.readByQuery(req.sanitizedQuery);
-            isComment = true;
-        }
-        else {
-            result = await service.readByQuery(req.sanitizedQuery);
-        }
+        result = await service.readByQuery(req.sanitizedQuery);
     }
-    const meta = await metaService.getMetaForQuery(isComment ? 'directus_comments' : 'directus_activity', req.sanitizedQuery);
+    const meta = await metaService.getMetaForQuery('directus_activity', req.sanitizedQuery);
     res.locals['payload'] = {
         data: result,
         meta,
@@ -65,71 +46,4 @@ router.get('/:pk', asyncHandler(async (req, res, next) => {
     };
     return next();
 }), respond);
-const createCommentSchema = Joi.object({
-    comment: Joi.string().required(),
-    collection: Joi.string().required(),
-    item: [Joi.number().required(), Joi.string().required()],
-});
-router.post('/comment', asyncHandler(async (req, res, next) => {
-    const service = new CommentsService({
-        accountability: req.accountability,
-        schema: req.schema,
-        serviceOrigin: 'activity',
-    });
-    const { error } = createCommentSchema.validate(req.body);
-    if (error) {
-        throw new InvalidPayloadError({ reason: error.message });
-    }
-    const primaryKey = await service.createOne(req.body);
-    try {
-        const record = await service.readOne(primaryKey, req.sanitizedQuery);
-        res.locals['payload'] = {
-            data: record || null,
-        };
-    }
-    catch (error) {
-        if (isDirectusError(error, ErrorCode.Forbidden)) {
-            return next();
-        }
-        throw error;
-    }
-    return next();
-}), respond);
-const updateCommentSchema = Joi.object({
-    comment: Joi.string().required(),
-});
-router.patch('/comment/:pk', asyncHandler(async (req, res, next) => {
-    const commentsService = new CommentsService({
-        accountability: req.accountability,
-        schema: req.schema,
-        serviceOrigin: 'activity',
-    });
-    const { error } = updateCommentSchema.validate(req.body);
-    if (error) {
-        throw new InvalidPayloadError({ reason: error.message });
-    }
-    const primaryKey = await commentsService.updateOne(req.params['pk'], req.body);
-    try {
-        const record = await commentsService.readOne(primaryKey, req.sanitizedQuery);
-        res.locals['payload'] = {
-            data: record || null,
-        };
-    }
-    catch (error) {
-        if (isDirectusError(error, ErrorCode.Forbidden)) {
-            return next();
-        }
-        throw error;
-    }
-    return next();
-}), respond);
-router.delete('/comment/:pk', asyncHandler(async (req, _res, next) => {
-    const commentsService = new CommentsService({
-        accountability: req.accountability,
-        schema: req.schema,
-        serviceOrigin: 'activity',
-    });
-    await commentsService.deleteOne(req.params['pk']);
-    return next();
-}), respond);
 export default router;

package/dist/controllers/comments.js

@@ -13,7 +13,6 @@ router.post('/', asyncHandler(async (req, res, next) => {
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     const savedKeys = [];
     if (Array.isArray(req.body)) {
@@ -46,7 +45,6 @@ const readHandler = asyncHandler(async (req, res, next) => {
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     const metaService = new MetaService({
         accountability: req.accountability,
@@ -69,7 +67,6 @@ router.get('/:pk', asyncHandler(async (req, res, next) => {
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     const record = await service.readOne(req.params['pk'], req.sanitizedQuery);
     res.locals['payload'] = { data: record || null };
@@ -79,7 +76,6 @@ router.patch('/', validateBatch('update'), asyncHandler(async (req, res, next) =
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     let keys = [];
     if (Array.isArray(req.body)) {
@@ -108,7 +104,6 @@ router.patch('/:pk', asyncHandler(async (req, res, next) => {
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     const primaryKey = await service.updateOne(req.params['pk'], req.body);
     try {
@@ -127,7 +122,6 @@ router.delete('/', validateBatch('delete'), asyncHandler(async (req, _res, next)
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     if (Array.isArray(req.body)) {
         await service.deleteMany(req.body);
@@ -145,7 +139,6 @@ router.delete('/:pk', asyncHandler(async (req, _res, next) => {
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     await service.deleteOne(req.params['pk']);
     return next();

package/dist/controllers/items.js

@@ -75,7 +75,7 @@ const readHandler = asyncHandler(async (req, res, next) => {
     };
     return next();
 });
-router.search('/:collection', collectionExists, validateBatch('read'), readHandler, respond);
+router.search('/:collection', collectionExists, validateBatch('read'), readHandler, mergeContentVersions, respond);
 router.get('/:collection', collectionExists, readHandler, mergeContentVersions, respond);
 router.get('/:collection/:pk', collectionExists, asyncHandler(async (req, res, next) => {
     if (isSystemCollection(req.params['collection']))

package/dist/controllers/tus.d.ts

@@ -1,3 +1,2 @@
-export declare function scheduleTusCleanup(): void;
 declare const router: import("express-serve-static-core").Router;
 export default router;

package/dist/controllers/tus.js

@@ -1,11 +1,8 @@
 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 { createTusServer } from '../services/tus/index.js';
 import asyncHandler from '../utils/async-handler.js';
-import { getSchema } from '../utils/get-schema.js';
-import { scheduleSynchronizedJob, validateCron } from '../utils/schedule.js';
 const mapAction = (method) => {
     switch (method) {
         case 'POST':
@@ -40,19 +37,6 @@ const handler = asyncHandler(async (req, res) => {
     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, cleanupServer] = await createTusServer({
-                schema: await getSchema(),
-            });
-            await tusServer.cleanUpExpiredUploads();
-            cleanupServer();
-        });
-    }
-}
 const router = Router();
 router.post('/', checkFileAccess, handler);
 router.patch('/:id', checkFileAccess, handler);

package/dist/controllers/versions.js

@@ -154,14 +154,7 @@ router.get('/:pk/compare', asyncHandler(async (req, res, next) => {
     });
     const version = await service.readOne(req.params['pk']);
     const { outdated, mainHash } = await service.verifyHash(version['collection'], version['item'], version['hash']);
-    let current;
-    if (version['delta']) {
-        current = version['delta'];
-    }
-    else {
-        const saves = await service.getVersionSavesById(version['id']);
-        current = assign({}, ...saves);
-    }
+    const current = assign({}, version['delta']);
     const main = await service.getMainItem(version['collection'], version['item']);
     res.locals['payload'] = { data: { outdated, mainHash, current, main } };
     return next();

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

@@ -6,6 +6,6 @@ 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;
+    prepQueryParams(queryParams: Sql): Sql;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasRelationalSort: boolean): void;
 }

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

@@ -1,7 +1,7 @@
 import {} from 'knex';
 import { SchemaHelper } from '../types.js';
 import { useEnv } from '@directus/env';
-import { preprocessBindings } from '../utils/preprocess-bindings.js';
+import { prepQueryParams } from '../utils/prep-query-params.js';
 const env = useEnv();
 export class SchemaHelperCockroachDb extends SchemaHelper {
     async changeToType(table, column, type, options = {}) {
@@ -29,8 +29,8 @@ export class SchemaHelperCockroachDb extends SchemaHelper {
             return null;
         }
     }
-    preprocessBindings(queryParams) {
-        return preprocessBindings(queryParams, { format: (index) => `$${index + 1}` });
+    prepQueryParams(queryParams) {
+        return prepQueryParams(queryParams, { format: (index) => `$${index + 1}` });
     }
     addInnerSortFieldsToGroupBy(groupByFields, sortRecords, hasRelationalSort) {
         if (hasRelationalSort) {

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

@@ -5,6 +5,6 @@ export declare class SchemaHelperMSSQL extends SchemaHelper {
     applyOffset(rootQuery: Knex.QueryBuilder, offset: number): void;
     formatUUID(uuid: string): string;
     getDatabaseSize(): Promise<number | null>;
-    preprocessBindings(queryParams: Sql): Sql;
+    prepQueryParams(queryParams: Sql): Sql;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], _hasRelationalSort: boolean): void;
 }

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

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

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

@@ -9,6 +9,7 @@ export declare class SchemaHelperOracle extends SchemaHelper {
     preRelationChange(relation: Partial<Relation>): void;
     processFieldType(field: Field): Type;
     getDatabaseSize(): Promise<number | null>;
-    preprocessBindings(queryParams: Sql): Sql;
+    prepQueryParams(queryParams: Sql): Sql;
+    prepBindings(bindings: Knex.Value[]): any;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], _hasRelationalSort: boolean): void;
 }

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

@@ -1,5 +1,5 @@
 import { SchemaHelper } from '../types.js';
-import { preprocessBindings } from '../utils/preprocess-bindings.js';
+import { prepQueryParams } from '../utils/prep-query-params.js';
 export class SchemaHelperOracle extends SchemaHelper {
     async changeToType(table, column, type, options = {}) {
         await this.changeToTypeByCopy(table, column, type, options);
@@ -39,8 +39,13 @@ export class SchemaHelperOracle extends SchemaHelper {
             return null;
         }
     }
-    preprocessBindings(queryParams) {
-        return preprocessBindings(queryParams, { format: (index) => `:${index + 1}` });
+    prepQueryParams(queryParams) {
+        return prepQueryParams(queryParams, { format: (index) => `:${index + 1}` });
+    }
+    prepBindings(bindings) {
+        // Create an object with keys 1, 2, 3, ... and the bindings as values
+        // This will use the "named" binding syntax in the oracledb driver instead of the positional binding
+        return Object.fromEntries(bindings.map((binding, index) => [index + 1, binding]));
     }
     addInnerSortFieldsToGroupBy(groupByFields, sortRecords, _hasRelationalSort) {
         /*

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

@@ -2,6 +2,6 @@ import type { Knex } from 'knex';
 import { SchemaHelper, type SortRecord, type Sql } from '../types.js';
 export declare class SchemaHelperPostgres extends SchemaHelper {
     getDatabaseSize(): Promise<number | null>;
-    preprocessBindings(queryParams: Sql): Sql;
+    prepQueryParams(queryParams: Sql): Sql;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasRelationalSort: boolean): void;
 }

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

@@ -1,6 +1,6 @@
 import { useEnv } from '@directus/env';
 import { SchemaHelper } from '../types.js';
-import { preprocessBindings } from '../utils/preprocess-bindings.js';
+import { prepQueryParams } from '../utils/prep-query-params.js';
 const env = useEnv();
 export class SchemaHelperPostgres extends SchemaHelper {
     async getDatabaseSize() {
@@ -12,8 +12,8 @@ export class SchemaHelperPostgres extends SchemaHelper {
             return null;
         }
     }
-    preprocessBindings(queryParams) {
-        return preprocessBindings(queryParams, { format: (index) => `$${index + 1}` });
+    prepQueryParams(queryParams) {
+        return prepQueryParams(queryParams, { format: (index) => `$${index + 1}` });
     }
     addInnerSortFieldsToGroupBy(groupByFields, sortRecords, hasRelationalSort) {
         if (hasRelationalSort) {

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

@@ -35,6 +35,7 @@ export declare abstract class SchemaHelper extends DatabaseHelper {
      * @returns Size of the database in bytes
      */
     getDatabaseSize(): Promise<number | null>;
-    preprocessBindings(queryParams: Sql): Sql;
+    prepQueryParams(queryParams: Sql): Sql;
+    prepBindings(bindings: Knex.Value[]): any;
     addInnerSortFieldsToGroupBy(_groupByFields: (string | Knex.Raw)[], _sortRecords: SortRecord[], _hasRelationalSort: boolean): void;
 }

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

@@ -94,9 +94,12 @@ export class SchemaHelper extends DatabaseHelper {
     async getDatabaseSize() {
         return null;
     }
-    preprocessBindings(queryParams) {
+    prepQueryParams(queryParams) {
         return queryParams;
     }
+    prepBindings(bindings) {
+        return bindings;
+    }
     addInnerSortFieldsToGroupBy(_groupByFields, _sortRecords, _hasRelationalSort) {
         // no-op by default
     }

package/dist/database/helpers/schema/utils/{preprocess-bindings.d.ts → prep-query-params.d.ts}

@@ -1,12 +1,12 @@
 import type { Knex } from 'knex';
 import type { Sql } from '../types.js';
-export type PreprocessBindingsOptions = {
+export type PrepQueryParamsOptions = {
     format(index: number): string;
 };
 /**
  * Preprocess a SQL query, such that repeated binding values are bound to the same binding index.
  **/
-export declare function preprocessBindings(queryParams: (Partial<Sql> & Pick<Sql, 'sql'>) | string, options: PreprocessBindingsOptions): {
+export declare function prepQueryParams(queryParams: (Partial<Sql> & Pick<Sql, 'sql'>) | string, options: PrepQueryParamsOptions): {
     sql: string;
     bindings: Knex.Value[];
 };

package/dist/database/helpers/schema/utils/{preprocess-bindings.js → prep-query-params.js}

@@ -2,7 +2,7 @@ import { isString } from 'lodash-es';
 /**
  * Preprocess a SQL query, such that repeated binding values are bound to the same binding index.
  **/
-export function preprocessBindings(queryParams, options) {
+export function prepQueryParams(queryParams, options) {
     const query = { bindings: [], ...(isString(queryParams) ? { sql: queryParams } : queryParams) };
     // bindingIndices[i] is the index of the first occurrence of query.bindings[i]
     const bindingIndices = new Map();

package/dist/database/index.js

@@ -3,7 +3,7 @@ import { createInspector } from '@directus/schema';
 import { isObject } from '@directus/utils';
 import fse from 'fs-extra';
 import knex from 'knex';
-import { merge } from 'lodash-es';
+import { isArray, merge } from 'lodash-es';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import path from 'path';
@@ -139,7 +139,13 @@ export function getDatabase() {
             delta = performance.now() - time;
             times.delete(queryInfo.__knexUid);
         }
-        logger.trace(`[${delta ? delta.toFixed(3) : '?'}ms] ${queryInfo.sql} [${(queryInfo.bindings ?? []).join(', ')}]`);
+        // eslint-disable-next-line no-nested-ternary
+        const bindings = queryInfo.bindings
+            ? isArray(queryInfo.bindings)
+                ? queryInfo.bindings
+                : Object.values(queryInfo.bindings)
+            : [];
+        logger.trace(`[${delta ? delta.toFixed(3) : '?'}ms] ${queryInfo.sql} [${bindings.join(', ')}]`);
     })
         .on('query-error', (_, queryInfo) => {
         times.delete(queryInfo.__knexUid);

package/dist/database/migrations/20240909A-separate-comments.js

@@ -2,12 +2,7 @@ import { Action } from '@directus/constants';
 export async function up(knex) {
     await knex.schema.createTable('directus_comments', (table) => {
         table.uuid('id').primary().notNullable();
-        table
-            .string('collection', 64)
-            .notNullable()
-            .references('collection')
-            .inTable('directus_collections')
-            .onDelete('CASCADE');
+        table.string('collection', 64).notNullable();
         table.string('item').notNullable();
         table.text('comment').notNullable();
         table.timestamp('date_created').defaultTo(knex.fn.now());

package/dist/database/migrations/20240924A-migrate-legacy-comments.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20240924A-migrate-legacy-comments.js

@@ -0,0 +1,59 @@
+import { Action } from '@directus/constants';
+import { randomUUID } from 'node:crypto';
+export async function up(knex) {
+    // remove foreign key constraint for projects already migrated to retentions-p1
+    try {
+        await knex.schema.alterTable('directus_comments', (table) => {
+            table.dropForeign('collection');
+        });
+    }
+    catch {
+        // ignore
+    }
+    const rowsLimit = 50;
+    let hasMore = true;
+    while (hasMore) {
+        const legacyComments = await knex
+            .select('*')
+            .from('directus_activity')
+            .where('action', '=', Action.COMMENT)
+            .limit(rowsLimit);
+        if (legacyComments.length === 0) {
+            hasMore = false;
+            break;
+        }
+        await knex.transaction(async (trx) => {
+            for (const legacyComment of legacyComments) {
+                let primaryKey;
+                // Migrate legacy comment
+                if (legacyComment['action'] === Action.COMMENT) {
+                    primaryKey = randomUUID();
+                    await trx('directus_comments').insert({
+                        id: primaryKey,
+                        collection: legacyComment.collection,
+                        item: legacyComment.item,
+                        comment: legacyComment.comment,
+                        user_created: legacyComment.user,
+                        date_created: legacyComment.timestamp,
+                    });
+                    await trx('directus_activity')
+                        .update({
+                        action: Action.CREATE,
+                        collection: 'directus_comments',
+                        item: primaryKey,
+                        comment: null,
+                    })
+                        .where('id', '=', legacyComment.id);
+                }
+            }
+        });
+    }
+    await knex.schema.alterTable('directus_activity', (table) => {
+        table.dropColumn('comment');
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_activity', (table) => {
+        table.text('comment');
+    });
+}

package/dist/database/migrations/20240924B-populate-versioning-deltas.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(): Promise<void>;

package/dist/database/migrations/20240924B-populate-versioning-deltas.js

@@ -0,0 +1,32 @@
+import { parseJSON } from '@directus/utils';
+import { assign } from 'lodash-es';
+export async function up(knex) {
+    const rowsLimit = 50;
+    let hasMore = true;
+    while (hasMore) {
+        const missingDeltaVersions = await knex.select('id').from('directus_versions').whereNull('delta').limit(rowsLimit);
+        if (missingDeltaVersions.length === 0) {
+            hasMore = false;
+            break;
+        }
+        await knex.transaction(async (trx) => {
+            for (const missingDeltaVersion of missingDeltaVersions) {
+                const revisions = await trx
+                    .select('delta')
+                    .from('directus_revisions')
+                    .where('version', '=', missingDeltaVersion.id)
+                    .orderBy('id');
+                const deltas = revisions.map((revision) => parseJSON(revision.delta));
+                const consolidatedDelta = assign({}, ...deltas);
+                await trx('directus_versions')
+                    .update({
+                    delta: JSON.stringify(consolidatedDelta),
+                })
+                    .where('id', '=', missingDeltaVersion.id);
+            }
+        });
+    }
+}
+export async function down() {
+    // No down migration required
+}

package/dist/database/run-ast/utils/apply-parent-filters.js

@@ -33,6 +33,10 @@ export function applyParentFilters(schema, nestedCollectionNodes, parentItem) {
             const foreignField = nestedNode.relation.field;
             const foreignIds = uniq(parentItems.map((res) => res[nestedNode.parentKey])).filter((id) => !isNil(id));
             merge(nestedNode, { query: { filter: { [foreignField]: { _in: foreignIds } } } });
+            if (nestedNode.relation.meta?.junction_field) {
+                const junctionField = nestedNode.relation.meta.junction_field;
+                merge(nestedNode, { query: { filter: { [junctionField]: { _nnull: true } } } });
+            }
         }
         else if (nestedNode.type === 'a2o') {
             const keysPerCollection = {};

package/dist/database/run-ast/utils/with-preprocess-bindings.js

@@ -4,9 +4,10 @@ export function withPreprocessBindings(knex, dbQuery) {
     dbQuery.client = new Proxy(dbQuery.client, {
         get(target, prop, receiver) {
             if (prop === 'query') {
-                return (connection, queryParam) => {
-                    return Reflect.get(target, prop, receiver).bind(target)(connection, schemaHelper.preprocessBindings(queryParam));
-                };
+                return (connection, queryParams) => Reflect.get(target, prop, receiver).bind(dbQuery.client)(connection, schemaHelper.prepQueryParams(queryParams));
+            }
+            if (prop === 'prepBindings') {
+                return (bindings) => schemaHelper.prepBindings(Reflect.get(target, prop, receiver).bind(dbQuery.client)(bindings));
             }
             return Reflect.get(target, prop, receiver);
         },

package/dist/permissions/modules/validate-access/lib/validate-item-access.js

@@ -1,3 +1,4 @@
+import { toBoolean } from '@directus/utils';
 import { fetchPermittedAstRootFields } from '../../../../database/run-ast/modules/fetch-permitted-ast-root-fields.js';
 import { processAst } from '../../process-ast/process-ast.js';
 export async function validateItemAccess(options, context) {
@@ -31,7 +32,7 @@ export async function validateItemAccess(options, context) {
     if (items && items.length === options.primaryKeys.length) {
         const { fields } = options;
         if (fields) {
-            return items.every((item) => fields.every((field) => item[field] === 1));
+            return items.every((item) => fields.every((field) => toBoolean(item[field])));
         }
         return true;
     }