@directus/api 23.0.0 → 23.1.1

package/dist/app.js

@@ -14,6 +14,7 @@ import accessRouter from './controllers/access.js';
 import assetsRouter from './controllers/assets.js';
 import authRouter from './controllers/auth.js';
 import collectionsRouter from './controllers/collections.js';
+import commentsRouter from './controllers/comments.js';
 import dashboardsRouter from './controllers/dashboards.js';
 import extensionsRouter from './controllers/extensions.js';
 import fieldsRouter from './controllers/fields.js';
@@ -209,6 +210,7 @@ export default async function createApp() {
     app.use('/access', accessRouter);
     app.use('/assets', assetsRouter);
     app.use('/collections', collectionsRouter);
+    app.use('/comments', commentsRouter);
     app.use('/dashboards', dashboardsRouter);
     app.use('/extensions', extensionsRouter);
     app.use('/fields', fieldsRouter);

package/dist/controllers/activity.js

@@ -1,15 +1,13 @@
-import { Action } from '@directus/constants';
-import { isDirectusError } from '@directus/errors';
+import { ErrorCode, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import express from 'express';
 import Joi from 'joi';
-import { ErrorCode, ForbiddenError, InvalidPayloadError } from '@directus/errors';
 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';
-import { getIPFromReq } from '../utils/get-ip-from-req.js';
 const router = express.Router();
 router.use(useCollection('directus_activity'));
 const readHandler = asyncHandler(async (req, res, next) => {
@@ -22,6 +20,7 @@ const readHandler = asyncHandler(async (req, res, next) => {
         schema: req.schema,
     });
     let result;
+    let isComment;
     if (req.singleton) {
         result = await service.readSingleton(req.sanitizedQuery);
     }
@@ -29,9 +28,24 @@ const readHandler = asyncHandler(async (req, res, next) => {
         result = await service.readMany(req.body.keys, req.sanitizedQuery);
     }
     else {
-        result = await service.readByQuery(req.sanitizedQuery);
+        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);
+        }
     }
-    const meta = await metaService.getMetaForQuery('directus_activity', req.sanitizedQuery);
+    const meta = await metaService.getMetaForQuery(isComment ? 'directus_comments' : 'directus_activity', req.sanitizedQuery);
     res.locals['payload'] = {
         data: result,
         meta,
@@ -57,22 +71,16 @@ const createCommentSchema = Joi.object({
     item: [Joi.number().required(), Joi.string().required()],
 });
 router.post('/comment', asyncHandler(async (req, res, next) => {
-    const service = new ActivityService({
+    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,
-        action: Action.COMMENT,
-        user: req.accountability?.user,
-        ip: getIPFromReq(req),
-        user_agent: req.accountability?.userAgent,
-        origin: req.get('origin'),
-    });
+    const primaryKey = await service.createOne(req.body);
     try {
         const record = await service.readOne(primaryKey, req.sanitizedQuery);
         res.locals['payload'] = {
@@ -91,17 +99,18 @@ const updateCommentSchema = Joi.object({
     comment: Joi.string().required(),
 });
 router.patch('/comment/:pk', asyncHandler(async (req, res, next) => {
-    const service = new ActivityService({
+    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 service.updateOne(req.params['pk'], req.body);
+    const primaryKey = await commentsService.updateOne(req.params['pk'], req.body);
     try {
-        const record = await service.readOne(primaryKey, req.sanitizedQuery);
+        const record = await commentsService.readOne(primaryKey, req.sanitizedQuery);
         res.locals['payload'] = {
             data: record || null,
         };
@@ -115,18 +124,12 @@ router.patch('/comment/:pk', asyncHandler(async (req, res, next) => {
     return next();
 }), respond);
 router.delete('/comment/:pk', asyncHandler(async (req, _res, next) => {
-    const service = new ActivityService({
+    const commentsService = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
+        serviceOrigin: 'activity',
     });
-    const adminService = new ActivityService({
-        schema: req.schema,
-    });
-    const item = await adminService.readOne(req.params['pk'], { fields: ['action'] });
-    if (!item || item['action'] !== Action.COMMENT) {
-        throw new ForbiddenError();
-    }
-    await service.deleteOne(req.params['pk']);
+    await commentsService.deleteOne(req.params['pk']);
     return next();
 }), respond);
 export default router;

package/dist/controllers/assets.js

@@ -104,7 +104,7 @@ asyncHandler(async (req, res, next) => {
     return helmet.contentSecurityPolicy(merge({
         useDefaults: false,
         directives: {
-            defaultSrc: ['none'],
+            defaultSrc: [`'none'`],
         },
     }, getConfigFromEnv('ASSETS_CONTENT_SECURITY_POLICY')))(req, res, next);
 }), 

package/dist/controllers/comments.d.ts

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

package/dist/controllers/comments.js

@@ -0,0 +1,153 @@
+import { ErrorCode, isDirectusError } 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 { CommentsService } from '../services/comments.js';
+import { MetaService } from '../services/meta.js';
+import asyncHandler from '../utils/async-handler.js';
+import { sanitizeQuery } from '../utils/sanitize-query.js';
+const router = express.Router();
+router.use(useCollection('directus_comments'));
+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)) {
+        const keys = await service.createMany(req.body);
+        savedKeys.push(...keys);
+    }
+    else {
+        const key = await service.createOne(req.body);
+        savedKeys.push(key);
+    }
+    try {
+        if (Array.isArray(req.body)) {
+            const records = await service.readMany(savedKeys, req.sanitizedQuery);
+            res.locals['payload'] = { data: records };
+        }
+        else {
+            const record = await service.readOne(savedKeys[0], req.sanitizedQuery);
+            res.locals['payload'] = { data: record };
+        }
+    }
+    catch (error) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+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,
+        schema: req.schema,
+    });
+    let result;
+    if (req.body.keys) {
+        result = await service.readMany(req.body.keys, req.sanitizedQuery);
+    }
+    else {
+        result = await service.readByQuery(req.sanitizedQuery);
+    }
+    const meta = await metaService.getMetaForQuery('directus_comments', req.sanitizedQuery);
+    res.locals['payload'] = { data: result, 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 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 };
+    return next();
+}), respond);
+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)) {
+        keys = await service.updateBatch(req.body);
+    }
+    else if (req.body.keys) {
+        keys = await service.updateMany(req.body.keys, req.body.data);
+    }
+    else {
+        const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
+        keys = await service.updateByQuery(sanitizedQuery, req.body.data);
+    }
+    try {
+        const result = await service.readMany(keys, req.sanitizedQuery);
+        res.locals['payload'] = { data: result };
+    }
+    catch (error) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+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 {
+        const record = await service.readOne(primaryKey, req.sanitizedQuery);
+        res.locals['payload'] = { data: record };
+    }
+    catch (error) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+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);
+    }
+    else if (req.body.keys) {
+        await service.deleteMany(req.body.keys);
+    }
+    else {
+        const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
+        await service.deleteByQuery(sanitizedQuery);
+    }
+    return next();
+}), respond);
+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();
+}), respond);
+export default router;

package/dist/controllers/permissions.js

@@ -72,7 +72,7 @@ const readHandler = asyncHandler(async (req, res, next) => {
 router.get('/', validateBatch('read'), readHandler, respond);
 router.search('/', validateBatch('read'), readHandler, respond);
 router.get('/me', asyncHandler(async (req, res, next) => {
-    if (!req.accountability?.user && !req.accountability?.role)
+    if (!req.accountability?.user && !req.accountability?.role && !req.accountability?.share)
         throw new ForbiddenError();
     const result = await fetchAccountabilityCollectionAccess(req.accountability, {
         schema: req.schema,

package/dist/controllers/users.js

@@ -62,16 +62,12 @@ const readHandler = asyncHandler(async (req, res, next) => {
 router.get('/', validateBatch('read'), readHandler, respond);
 router.search('/', validateBatch('read'), readHandler, respond);
 router.get('/me', asyncHandler(async (req, res, next) => {
-    if (req.accountability?.share_scope) {
-        const user = {
-            share: req.accountability?.share,
-            role: {
-                id: req.accountability.role,
-                admin_access: false,
-                app_access: false,
+    if (req.accountability?.share) {
+        res.locals['payload'] = {
+            data: {
+                share: req.accountability?.share,
             },
         };
-        res.locals['payload'] = { data: user };
         return next();
     }
     if (!req.accountability?.user) {

package/dist/controllers/versions.js

@@ -154,8 +154,14 @@ 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']);
-    const saves = await service.getVersionSavesById(version['id']);
-    const current = assign({}, ...saves);
+    let current;
+    if (version['delta']) {
+        current = version['delta'];
+    }
+    else {
+        const saves = await service.getVersionSavesById(version['id']);
+        current = assign({}, ...saves);
+    }
     const main = await service.getMainItem(version['collection'], version['item']);
     res.locals['payload'] = { data: { outdated, mainHash, current, main } };
     return next();
@@ -167,9 +173,8 @@ router.post('/:pk/save', asyncHandler(async (req, res, next) => {
     });
     const version = await service.readOne(req.params['pk']);
     const mainItem = await service.getMainItem(version['collection'], version['item']);
-    await service.save(req.params['pk'], req.body);
-    const saves = await service.getVersionSavesById(req.params['pk']);
-    const result = assign(mainItem, ...saves);
+    const updatedVersion = await service.save(req.params['pk'], req.body);
+    const result = assign(mainItem, updatedVersion);
     res.locals['payload'] = { data: result || null };
     return next();
 }), respond);

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

@@ -7,5 +7,5 @@ export declare class SchemaHelperCockroachDb extends SchemaHelper {
     constraintName(existingName: string): string;
     getDatabaseSize(): Promise<number | null>;
     preprocessBindings(queryParams: Sql): Sql;
-    addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasMultiRelationalSort: boolean): void;
+    addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasRelationalSort: boolean): void;
 }

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

@@ -32,8 +32,8 @@ export class SchemaHelperCockroachDb extends SchemaHelper {
     preprocessBindings(queryParams) {
         return preprocessBindings(queryParams, { format: (index) => `$${index + 1}` });
     }
-    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, hasMultiRelationalSort) {
-        if (hasMultiRelationalSort) {
+    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, hasRelationalSort) {
+        if (hasRelationalSort) {
             /*
             Cockroach allows aliases to be used in the GROUP BY clause and only needs columns in the GROUP BY clause that
             are not functionally dependent on the primary key.

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

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

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

@@ -30,7 +30,7 @@ export class SchemaHelperMSSQL extends SchemaHelper {
     preprocessBindings(queryParams) {
         return preprocessBindings(queryParams, { format: (index) => `@p${index}` });
     }
-    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, _hasMultiRelationalSort) {
+    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, _hasRelationalSort) {
         /*
         MSSQL requires all selected columns that are not aggregated over are to be present in the GROUP BY clause
 

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

@@ -3,5 +3,5 @@ import { SchemaHelper, type SortRecord } from '../types.js';
 export declare class SchemaHelperMySQL extends SchemaHelper {
     applyMultiRelationalSort(knex: Knex, dbQuery: Knex.QueryBuilder, table: string, primaryKey: string, orderByString: string, orderByFields: Knex.Raw[]): Knex.QueryBuilder;
     getDatabaseSize(): Promise<number | null>;
-    addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasMultiRelationalSort: boolean): void;
+    addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasRelationalSort: boolean): void;
 }

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

@@ -28,8 +28,8 @@ export class SchemaHelperMySQL extends SchemaHelper {
             return null;
         }
     }
-    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, hasMultiRelationalSort) {
-        if (hasMultiRelationalSort) {
+    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, hasRelationalSort) {
+        if (hasRelationalSort) {
             /*
             ** MySQL **
 

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

@@ -10,5 +10,5 @@ export declare class SchemaHelperOracle extends SchemaHelper {
     processFieldType(field: Field): Type;
     getDatabaseSize(): Promise<number | null>;
     preprocessBindings(queryParams: Sql): Sql;
-    addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], _hasMultiRelationalSort: boolean): void;
+    addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], _hasRelationalSort: boolean): void;
 }

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

@@ -42,7 +42,7 @@ export class SchemaHelperOracle extends SchemaHelper {
     preprocessBindings(queryParams) {
         return preprocessBindings(queryParams, { format: (index) => `:${index + 1}` });
     }
-    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, _hasMultiRelationalSort) {
+    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, _hasRelationalSort) {
         /*
         Oracle requires all selected columns that are not aggregated over to be present in the GROUP BY clause
         aliases can not be used before version 23c.

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

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

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

@@ -15,12 +15,12 @@ export class SchemaHelperPostgres extends SchemaHelper {
     preprocessBindings(queryParams) {
         return preprocessBindings(queryParams, { format: (index) => `$${index + 1}` });
     }
-    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, hasMultiRelationalSort) {
-        if (hasMultiRelationalSort) {
+    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, hasRelationalSort) {
+        if (hasRelationalSort) {
             /*
             Postgres only requires selected columns that are not functionally dependent on the primary key to be
             included in the GROUP BY clause. Since the results are already grouped by the primary key, we don't need to
-            always include the sort columns in the GROUP BY but only if there is a multi relational sort involved, eg.
+            always include the sort columns in the GROUP BY but only if there is a relational sort involved, eg.
             a sort column that comes from a related M2O relation.
 
             > When GROUP BY is present, or any aggregate functions are present, it is not valid for the SELECT list

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

@@ -36,5 +36,5 @@ export declare abstract class SchemaHelper extends DatabaseHelper {
      */
     getDatabaseSize(): Promise<number | null>;
     preprocessBindings(queryParams: Sql): Sql;
-    addInnerSortFieldsToGroupBy(_groupByFields: (string | Knex.Raw)[], _sortRecords: SortRecord[], _hasMultiRelationalSort: boolean): void;
+    addInnerSortFieldsToGroupBy(_groupByFields: (string | Knex.Raw)[], _sortRecords: SortRecord[], _hasRelationalSort: boolean): void;
 }

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

@@ -97,7 +97,7 @@ export class SchemaHelper extends DatabaseHelper {
     preprocessBindings(queryParams) {
         return queryParams;
     }
-    addInnerSortFieldsToGroupBy(_groupByFields, _sortRecords, _hasMultiRelationalSort) {
+    addInnerSortFieldsToGroupBy(_groupByFields, _sortRecords, _hasRelationalSort) {
         // no-op by default
     }
 }

package/dist/database/index.js

@@ -140,6 +140,9 @@ export function getDatabase() {
             times.delete(queryInfo.__knexUid);
         }
         logger.trace(`[${delta ? delta.toFixed(3) : '?'}ms] ${queryInfo.sql} [${(queryInfo.bindings ?? []).join(', ')}]`);
+    })
+        .on('query-error', (_, queryInfo) => {
+        times.delete(queryInfo.__knexUid);
     });
     return database;
 }

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

@@ -1,6 +1,3 @@
 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>;

package/dist/database/migrations/20240806A-permissions-policies.js

@@ -1,5 +1,5 @@
 import { processChunk, toBoolean } from '@directus/utils';
-import { flatten, intersection, isEqual, merge, omit, uniq } from 'lodash-es';
+import { omit } from 'lodash-es';
 import { randomUUID } from 'node:crypto';
 import { useLogger } from '../../logger/index.js';
 import { fetchPermissions } from '../../permissions/lib/fetch-permissions.js';
@@ -7,98 +7,7 @@ import { fetchPolicies } from '../../permissions/lib/fetch-policies.js';
 import { fetchRolesTree } from '../../permissions/lib/fetch-roles-tree.js';
 import { getSchema } from '../../utils/get-schema.js';
 import { getSchemaInspector } from '../index.js';
-// Adapted from https://github.com/directus/directus/blob/141b8adbf4dd8e06530a7929f34e3fc68a522053/api/src/utils/merge-permissions.ts#L4
-export function mergePermissions(strategy, ...permissions) {
-    const allPermissions = flatten(permissions);
-    const mergedPermissions = allPermissions
-        .reduce((acc, val) => {
-        const key = `${val.collection}__${val.action}`;
-        const current = acc.get(key);
-        acc.set(key, current ? mergePermission(strategy, current, val) : val);
-        return acc;
-    }, new Map())
-        .values();
-    return Array.from(mergedPermissions);
-}
-export function mergePermission(strategy, currentPerm, newPerm) {
-    const logicalKey = `_${strategy}`;
-    let { permissions, validation, fields, presets } = currentPerm;
-    if (newPerm.permissions) {
-        if (currentPerm.permissions && Object.keys(currentPerm.permissions)[0] === logicalKey) {
-            permissions = {
-                [logicalKey]: [
-                    ...currentPerm.permissions[logicalKey],
-                    newPerm.permissions,
-                ],
-            };
-        }
-        else if (currentPerm.permissions) {
-            // Empty {} supersedes other permissions in _OR merge
-            if (strategy === 'or' && (isEqual(currentPerm.permissions, {}) || isEqual(newPerm.permissions, {}))) {
-                permissions = {};
-            }
-            else {
-                permissions = {
-                    [logicalKey]: [currentPerm.permissions, newPerm.permissions],
-                };
-            }
-        }
-        else {
-            permissions = {
-                [logicalKey]: [newPerm.permissions],
-            };
-        }
-    }
-    if (newPerm.validation) {
-        if (currentPerm.validation && Object.keys(currentPerm.validation)[0] === logicalKey) {
-            validation = {
-                [logicalKey]: [
-                    ...currentPerm.validation[logicalKey],
-                    newPerm.validation,
-                ],
-            };
-        }
-        else if (currentPerm.validation) {
-            // Empty {} supersedes other validations in _OR merge
-            if (strategy === 'or' && (isEqual(currentPerm.validation, {}) || isEqual(newPerm.validation, {}))) {
-                validation = {};
-            }
-            else {
-                validation = {
-                    [logicalKey]: [currentPerm.validation, newPerm.validation],
-                };
-            }
-        }
-        else {
-            validation = {
-                [logicalKey]: [newPerm.validation],
-            };
-        }
-    }
-    if (newPerm.fields) {
-        if (Array.isArray(currentPerm.fields) && strategy === 'or') {
-            fields = uniq([...currentPerm.fields, ...newPerm.fields]);
-        }
-        else if (Array.isArray(currentPerm.fields) && strategy === 'and') {
-            fields = intersection(currentPerm.fields, newPerm.fields);
-        }
-        else {
-            fields = newPerm.fields;
-        }
-        if (fields.includes('*'))
-            fields = ['*'];
-    }
-    if (newPerm.presets) {
-        presets = merge({}, presets, newPerm.presets);
-    }
-    return omit({
-        ...currentPerm,
-        permissions,
-        validation,
-        fields,
-        presets,
-    }, ['id', 'system']);
-}
+import { mergePermissions } from '../../permissions/utils/merge-permissions.js';
 async function fetchRoleAccess(roles, context) {
     const roleAccess = {
         admin_access: false,
@@ -286,7 +195,12 @@ export async function down(knex) {
             const policies = await fetchPolicies({ roles: roleTree, user: null, ip: null }, context);
             //  fetch all of the policies permissions
             const rawPermissions = await fetchPermissions({
-                accountability: { role: null, roles: roleTree, user: null, app: roleAccess?.app_access || false },
+                accountability: {
+                    role: null,
+                    roles: roleTree,
+                    user: null,
+                    app: roleAccess?.app_access || false,
+                },
                 policies,
                 bypassDynamicVariableProcessing: true,
             }, context);

package/dist/database/migrations/20240909A-separate-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>;