@directus/api 23.0.0 → 23.1.0

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

@@ -7,6 +7,12 @@ import { validateItemAccess } from './lib/validate-item-access.js';
  * control rules and checking if we got the expected result back
  */
 export async function validateAccess(options, context) {
+    // Skip further validation if the collection does not exist
+    if (options.collection in context.schema.collections === false) {
+        throw new ForbiddenError({
+            reason: `You don't have permission to "${options.action}" from collection "${options.collection}" or it does not exist.`,
+        });
+    }
     if (options.accountability.admin === true) {
         return;
     }
@@ -21,8 +27,15 @@ export async function validateAccess(options, context) {
         access = await validateCollectionAccess(options, context);
     }
     if (!access) {
+        if (options.fields?.length ?? 0 > 0) {
+            throw new ForbiddenError({
+                reason: `You don't have permissions to perform "${options.action}" for the field(s) ${options
+                    .fields.map((field) => `"${field}"`)
+                    .join(', ')} in collection "${options.collection}" or it does not exist.`,
+            });
+        }
         throw new ForbiddenError({
-            reason: `You don't have permission to "${options.action}" from collection "${options.collection}" or it does not exist.`,
+            reason: `You don't have permission to perform "${options.action}" for collection "${options.collection}" or it does not exist.`,
         });
     }
 }

package/dist/services/activity.d.ts

@@ -1,11 +1,5 @@
-import type { Item, PrimaryKey } from '@directus/types';
-import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
+import type { AbstractServiceOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
-import { NotificationsService } from './notifications.js';
-import { UsersService } from './users.js';
 export declare class ActivityService extends ItemsService {
-    notificationsService: NotificationsService;
-    usersService: UsersService;
     constructor(options: AbstractServiceOptions);
-    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
 }

package/dist/services/activity.js

@@ -1,109 +1,6 @@
-import { Action } from '@directus/constants';
-import { useEnv } from '@directus/env';
-import { ErrorCode, isDirectusError } from '@directus/errors';
-import { uniq } from 'lodash-es';
-import { useLogger } from '../logger/index.js';
-import { fetchRolesTree } from '../permissions/lib/fetch-roles-tree.js';
-import { fetchGlobalAccess } from '../permissions/modules/fetch-global-access/fetch-global-access.js';
-import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
-import { createDefaultAccountability } from '../permissions/utils/create-default-accountability.js';
-import { isValidUuid } from '../utils/is-valid-uuid.js';
-import { Url } from '../utils/url.js';
-import { userName } from '../utils/user-name.js';
 import { ItemsService } from './items.js';
-import { NotificationsService } from './notifications.js';
-import { UsersService } from './users.js';
-const env = useEnv();
-const logger = useLogger();
 export class ActivityService extends ItemsService {
-    notificationsService;
-    usersService;
     constructor(options) {
         super('directus_activity', options);
-        this.notificationsService = new NotificationsService({ schema: this.schema });
-        this.usersService = new UsersService({ schema: this.schema });
-    }
-    async createOne(data, opts) {
-        if (data['action'] === Action.COMMENT && typeof data['comment'] === 'string') {
-            const usersRegExp = new RegExp(/@[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/gi);
-            const mentions = uniq(data['comment'].match(usersRegExp) ?? []);
-            const sender = await this.usersService.readOne(this.accountability.user, {
-                fields: ['id', 'first_name', 'last_name', 'email'],
-            });
-            for (const mention of mentions) {
-                const userID = mention.substring(1);
-                const user = await this.usersService.readOne(userID, {
-                    fields: ['id', 'first_name', 'last_name', 'email', 'role'],
-                });
-                const roles = await fetchRolesTree(user['role'], this.knex);
-                const globalAccess = await fetchGlobalAccess({ user: user['id'], roles, ip: null }, this.knex);
-                const accountability = createDefaultAccountability({
-                    user: userID,
-                    role: user['role']?.id ?? null,
-                    roles,
-                    ...globalAccess,
-                });
-                const usersService = new UsersService({ schema: this.schema, accountability });
-                try {
-                    if (this.accountability) {
-                        await validateAccess({
-                            accountability: this.accountability,
-                            action: 'read',
-                            collection: data['collection'],
-                            primaryKeys: [data['item']],
-                        }, {
-                            knex: this.knex,
-                            schema: this.schema,
-                        });
-                    }
-                    const templateData = await usersService.readByQuery({
-                        fields: ['id', 'first_name', 'last_name', 'email'],
-                        filter: { id: { _in: mentions.map((mention) => mention.substring(1)) } },
-                    });
-                    const userPreviews = templateData.reduce((acc, user) => {
-                        acc[user['id']] = `<em>${userName(user)}</em>`;
-                        return acc;
-                    }, {});
-                    let comment = data['comment'];
-                    for (const mention of mentions) {
-                        const uuid = mention.substring(1);
-                        // We only match on UUIDs in the first place. This is just an extra sanity check.
-                        if (isValidUuid(uuid) === false)
-                            continue;
-                        comment = comment.replace(new RegExp(mention, 'gm'), userPreviews[uuid] ?? '@Unknown User');
-                    }
-                    comment = `> ${comment.replace(/\n+/gm, '\n> ')}`;
-                    const href = new Url(env['PUBLIC_URL'])
-                        .addPath('admin', 'content', data['collection'], data['item'])
-                        .toString();
-                    const message = `
-Hello ${userName(user)},
-
-${userName(sender)} has mentioned you in a comment:
-
-${comment}
-
-<a href="${href}">Click here to view.</a>
-`;
-                    await this.notificationsService.createOne({
-                        recipient: userID,
-                        sender: sender['id'],
-                        subject: `You were mentioned in ${data['collection']}`,
-                        message,
-                        collection: data['collection'],
-                        item: data['item'],
-                    });
-                }
-                catch (err) {
-                    if (isDirectusError(err, ErrorCode.Forbidden)) {
-                        logger.warn(`User ${userID} doesn't have proper permissions to receive notification for this item.`);
-                    }
-                    else {
-                        throw err;
-                    }
-                }
-            }
-        }
-        return super.createOne(data, opts);
     }
 }

package/dist/services/assets.js

@@ -98,7 +98,7 @@ export class AssetsService {
             }
             if (exists) {
                 return {
-                    stream: await storage.location(file.storage).read(assetFilename, range),
+                    stream: await storage.location(file.storage).read(assetFilename, { range }),
                     file,
                     stat: await storage.location(file.storage).stat(assetFilename),
                 };
@@ -121,7 +121,8 @@ export class AssetsService {
                     reason: 'Server too busy',
                 });
             }
-            const readStream = await storage.location(file.storage).read(file.filename_disk, range);
+            const version = file.modified_on !== undefined ? String(new Date(file.modified_on).getTime() / 1000) : undefined;
+            const readStream = await storage.location(file.storage).read(file.filename_disk, { range, version });
             const transformer = getSharpInstance();
             transformer.timeout({
                 seconds: clamp(Math.round(getMilliseconds(env['ASSETS_TRANSFORM_TIMEOUT'], 0) / 1000), 1, 3600),
@@ -151,13 +152,13 @@ export class AssetsService {
                 }
             }
             return {
-                stream: await storage.location(file.storage).read(assetFilename, range),
+                stream: await storage.location(file.storage).read(assetFilename, { range }),
                 stat: await storage.location(file.storage).stat(assetFilename),
                 file,
             };
         }
         else {
-            const readStream = await storage.location(file.storage).read(file.filename_disk, range);
+            const readStream = await storage.location(file.storage).read(file.filename_disk, { range });
             const stat = await storage.location(file.storage).stat(file.filename_disk);
             return { stream: readStream, file, stat };
         }

package/dist/services/collections.js

@@ -155,10 +155,11 @@ export class CollectionsService {
             if (opts?.autoPurgeSystemCache !== false) {
                 await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
             }
+            // Refresh the schema for subsequent reads
+            this.schema = await getSchema();
             if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
-                const updatedSchema = await getSchema();
                 for (const nestedActionEvent of nestedActionEvents) {
-                    nestedActionEvent.context.schema = updatedSchema;
+                    nestedActionEvent.context.schema = this.schema;
                     emitter.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
                 }
             }
@@ -196,10 +197,11 @@ export class CollectionsService {
             if (opts?.autoPurgeSystemCache !== false) {
                 await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
             }
+            // Refresh the schema for subsequent reads
+            this.schema = await getSchema();
             if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
-                const updatedSchema = await getSchema();
                 for (const nestedActionEvent of nestedActionEvents) {
-                    nestedActionEvent.context.schema = updatedSchema;
+                    nestedActionEvent.context.schema = this.schema;
                     emitter.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
                 }
             }

package/dist/services/comments.d.ts

@@ -0,0 +1,31 @@
+import type { Comment, Item, PrimaryKey, Query } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
+import { ActivityService } from './activity.js';
+import { ItemsService, type QueryOptions } from './items.js';
+import { NotificationsService } from './notifications.js';
+import { UsersService } from './users.js';
+type serviceOrigin = 'activity' | 'comments';
+export declare class CommentsService extends ItemsService {
+    activityService: ActivityService;
+    notificationsService: NotificationsService;
+    usersService: UsersService;
+    serviceOrigin: serviceOrigin;
+    constructor(options: AbstractServiceOptions & {
+        serviceOrigin: serviceOrigin;
+    });
+    readOne(key: PrimaryKey, query?: Query, opts?: QueryOptions): Promise<Item>;
+    readByQuery(query: Query, opts?: QueryOptions): Promise<Item[]>;
+    readMany(keys: PrimaryKey[], query?: Query, opts?: QueryOptions): Promise<Item[]>;
+    createOne(data: Partial<Comment>, opts?: MutationOptions): Promise<PrimaryKey>;
+    updateByQuery(query: Query, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateOne(key: PrimaryKey, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    deleteByQuery(query: Query, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    deleteOne(key: PrimaryKey, opts?: MutationOptions): Promise<PrimaryKey>;
+    private processPrimaryKeys;
+    migrateLegacyComment(activityPk: PrimaryKey): Promise<PrimaryKey>;
+    generateQuery(type: serviceOrigin, originalQuery: Query): Query;
+    private sortLegacyResults;
+}
+export {};

package/dist/services/comments.js

@@ -0,0 +1,374 @@
+import { Action } from '@directus/constants';
+import { useEnv } from '@directus/env';
+import { ErrorCode, ForbiddenError, InvalidPayloadError, isDirectusError } from '@directus/errors';
+import { cloneDeep, mergeWith, uniq } from 'lodash-es';
+import { randomUUID } from 'node:crypto';
+import { useLogger } from '../logger/index.js';
+import { fetchRolesTree } from '../permissions/lib/fetch-roles-tree.js';
+import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
+import { isValidUuid } from '../utils/is-valid-uuid.js';
+import { transaction } from '../utils/transaction.js';
+import { Url } from '../utils/url.js';
+import { userName } from '../utils/user-name.js';
+import { ActivityService } from './activity.js';
+import { ItemsService } from './items.js';
+import { NotificationsService } from './notifications.js';
+import { UsersService } from './users.js';
+const env = useEnv();
+const logger = useLogger();
+// TODO: Remove legacy comments logic
+export class CommentsService extends ItemsService {
+    activityService;
+    notificationsService;
+    usersService;
+    serviceOrigin;
+    constructor(options) {
+        super('directus_comments', options);
+        this.activityService = new ActivityService(options);
+        this.notificationsService = new NotificationsService({ schema: this.schema });
+        this.usersService = new UsersService({ schema: this.schema });
+        this.serviceOrigin = options.serviceOrigin ?? 'comments';
+    }
+    readOne(key, query, opts) {
+        const isLegacyComment = isNaN(Number(key));
+        let result;
+        if (isLegacyComment) {
+            const activityQuery = this.serviceOrigin === 'activity' ? query : this.generateQuery('activity', query || {});
+            result = this.activityService.readOne(key, activityQuery, opts);
+        }
+        else {
+            const commentsQuery = this.serviceOrigin === 'comments' ? query : this.generateQuery('comments', query || {});
+            result = super.readOne(key, commentsQuery, opts);
+        }
+        return result;
+    }
+    async readByQuery(query, opts) {
+        const activityQuery = this.serviceOrigin === 'activity' ? query : this.generateQuery('activity', query);
+        const commentsQuery = this.serviceOrigin === 'comments' ? query : this.generateQuery('comments', query);
+        const activityResult = await this.activityService.readByQuery(activityQuery, opts);
+        const commentsResult = await super.readByQuery(commentsQuery, opts);
+        if (query.aggregate) {
+            // Merging the first result only as the app does not utilise group
+            return [
+                mergeWith({}, activityResult[0], commentsResult[0], (a, b) => {
+                    const numA = Number(a);
+                    const numB = Number(b);
+                    if (!isNaN(numA) && !isNaN(numB)) {
+                        return numA + numB;
+                    }
+                    return;
+                }),
+            ];
+        }
+        else if (query.sort) {
+            return this.sortLegacyResults([...activityResult, ...commentsResult], query.sort);
+        }
+        else {
+            return [...activityResult, ...commentsResult];
+        }
+    }
+    async readMany(keys, query, opts) {
+        const commentsKeys = [];
+        const activityKeys = [];
+        for (const key of keys) {
+            if (isNaN(Number(key))) {
+                commentsKeys.push(key);
+            }
+            else {
+                activityKeys.push(key);
+            }
+        }
+        const activityQuery = this.serviceOrigin === 'activity' ? query : this.generateQuery('activity', query || {});
+        const commentsQuery = this.serviceOrigin === 'comments' ? query : this.generateQuery('comments', query || {});
+        const activityResult = await this.activityService.readMany(activityKeys, activityQuery, opts);
+        const commentsResult = await super.readMany(commentsKeys, commentsQuery, opts);
+        if (query?.sort) {
+            return this.sortLegacyResults([...activityResult, ...commentsResult], query.sort);
+        }
+        else {
+            return [...activityResult, ...commentsResult];
+        }
+    }
+    async createOne(data, opts) {
+        if (!data['comment']) {
+            throw new InvalidPayloadError({ reason: `"comment" is required` });
+        }
+        if (!data['collection']) {
+            throw new InvalidPayloadError({ reason: `"collection" is required` });
+        }
+        if (!data['item']) {
+            throw new InvalidPayloadError({ reason: `"item" is required` });
+        }
+        if (this.accountability) {
+            await validateAccess({
+                accountability: this.accountability,
+                action: 'read',
+                collection: data['collection'],
+                primaryKeys: [data['item']],
+            }, {
+                schema: this.schema,
+                knex: this.knex,
+            });
+        }
+        const usersRegExp = new RegExp(/@[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/gi);
+        const mentions = uniq(data['comment'].match(usersRegExp) ?? []);
+        const sender = await this.usersService.readOne(this.accountability.user, {
+            fields: ['id', 'first_name', 'last_name', 'email'],
+        });
+        for (const mention of mentions) {
+            const userID = mention.substring(1);
+            const user = await this.usersService.readOne(userID, {
+                fields: ['id', 'first_name', 'last_name', 'email', 'role.id', 'role.admin_access', 'role.app_access'],
+            });
+            const accountability = {
+                user: userID,
+                role: user['role']?.id ?? null,
+                admin: user['role']?.admin_access ?? null,
+                app: user['role']?.app_access ?? null,
+                roles: await fetchRolesTree(user['role']?.id, this.knex),
+                ip: null,
+            };
+            const usersService = new UsersService({ schema: this.schema, accountability });
+            try {
+                await validateAccess({
+                    accountability,
+                    action: 'read',
+                    collection: data['collection'],
+                    primaryKeys: [data['item']],
+                }, {
+                    schema: this.schema,
+                    knex: this.knex,
+                });
+                const templateData = await usersService.readByQuery({
+                    fields: ['id', 'first_name', 'last_name', 'email'],
+                    filter: { id: { _in: mentions.map((mention) => mention.substring(1)) } },
+                });
+                const userPreviews = templateData.reduce((acc, user) => {
+                    acc[user['id']] = `<em>${userName(user)}</em>`;
+                    return acc;
+                }, {});
+                let comment = data['comment'];
+                for (const mention of mentions) {
+                    const uuid = mention.substring(1);
+                    // We only match on UUIDs in the first place. This is just an extra sanity check.
+                    if (isValidUuid(uuid) === false)
+                        continue;
+                    comment = comment.replace(new RegExp(mention, 'gm'), userPreviews[uuid] ?? '@Unknown User');
+                }
+                comment = `> ${comment.replace(/\n+/gm, '\n> ')}`;
+                const href = new Url(env['PUBLIC_URL'])
+                    .addPath('admin', 'content', data['collection'], data['item'])
+                    .toString();
+                const message = `
+Hello ${userName(user)},
+
+${userName(sender)} has mentioned you in a comment:
+
+${comment}
+
+<a href="${href}">Click here to view.</a>
+`;
+                await this.notificationsService.createOne({
+                    recipient: userID,
+                    sender: sender['id'],
+                    subject: `You were mentioned in ${data['collection']}`,
+                    message,
+                    collection: data['collection'],
+                    item: data['item'],
+                });
+            }
+            catch (err) {
+                if (isDirectusError(err, ErrorCode.Forbidden)) {
+                    logger.warn(`User ${userID} doesn't have proper permissions to receive notification for this item.`);
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        return super.createOne(data, opts);
+    }
+    async updateByQuery(query, data, opts) {
+        const keys = await this.getKeysByQuery(query);
+        const migratedKeys = await this.processPrimaryKeys(keys);
+        return super.updateMany(migratedKeys, data, opts);
+    }
+    async updateMany(keys, data, opts) {
+        const migratedKeys = await this.processPrimaryKeys(keys);
+        return super.updateMany(migratedKeys, data, opts);
+    }
+    async updateOne(key, data, opts) {
+        const migratedKey = await this.migrateLegacyComment(key);
+        return super.updateOne(migratedKey, data, opts);
+    }
+    async deleteByQuery(query, opts) {
+        const keys = await this.getKeysByQuery(query);
+        const migratedKeys = await this.processPrimaryKeys(keys);
+        return super.deleteMany(migratedKeys, opts);
+    }
+    async deleteMany(keys, opts) {
+        const migratedKeys = await this.processPrimaryKeys(keys);
+        return super.deleteMany(migratedKeys, opts);
+    }
+    async deleteOne(key, opts) {
+        const migratedKey = await this.migrateLegacyComment(key);
+        return super.deleteOne(migratedKey, opts);
+    }
+    async processPrimaryKeys(keys) {
+        const migratedKeys = [];
+        for (const key of keys) {
+            if (isNaN(Number(key))) {
+                migratedKeys.push(key);
+                continue;
+            }
+            migratedKeys.push(await this.migrateLegacyComment(key));
+        }
+        return migratedKeys;
+    }
+    async migrateLegacyComment(activityPk) {
+        // Skip migration if not a legacy comment
+        if (isNaN(Number(activityPk))) {
+            return activityPk;
+        }
+        return transaction(this.knex, async (trx) => {
+            let primaryKey;
+            const legacyComment = await trx('directus_activity').select('*').where('id', '=', activityPk).first();
+            // 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', '=', activityPk);
+            }
+            // Migrated comment
+            else if (legacyComment.collection === 'directus_comment' && legacyComment.action === Action.CREATE) {
+                primaryKey = legacyComment.item;
+            }
+            if (!primaryKey) {
+                throw new ForbiddenError();
+            }
+            return primaryKey;
+        });
+    }
+    generateQuery(type, originalQuery) {
+        const query = cloneDeep(originalQuery);
+        const defaultActivityCommentFilter = { action: { _eq: Action.COMMENT } };
+        const commentsToActivityFieldMap = {
+            id: 'id',
+            comment: 'comment',
+            item: 'item',
+            collection: 'collection',
+            user_created: 'user',
+            date_created: 'timestamp',
+        };
+        const activityToCommentsFieldMap = {
+            id: 'id',
+            comment: 'comment',
+            item: 'item',
+            collection: 'collection',
+            user: 'user_created',
+            timestamp: 'date_created',
+        };
+        const targetFieldMap = type === 'activity' ? commentsToActivityFieldMap : activityToCommentsFieldMap;
+        for (const key of Object.keys(originalQuery)) {
+            switch (key) {
+                case 'fields':
+                    if (!originalQuery.fields)
+                        break;
+                    query.fields = [];
+                    for (const field of originalQuery.fields) {
+                        if (field === '*') {
+                            query.fields = ['*'];
+                            break;
+                        }
+                        const parts = field.split('.');
+                        const firstPart = parts[0];
+                        if (firstPart && targetFieldMap[firstPart]) {
+                            query.fields.push(field);
+                            if (firstPart !== targetFieldMap[firstPart]) {
+                                (query.alias = query.alias || {})[firstPart] = targetFieldMap[firstPart];
+                            }
+                        }
+                    }
+                    break;
+                case 'filter':
+                    if (!originalQuery.filter)
+                        break;
+                    if (type === 'activity') {
+                        query.filter = { _and: [defaultActivityCommentFilter, originalQuery.filter] };
+                    }
+                    if (type === 'comments' && this.serviceOrigin === 'activity') {
+                        if ('_and' in originalQuery.filter && Array.isArray(originalQuery.filter['_and'])) {
+                            query.filter = {
+                                _and: originalQuery.filter['_and'].filter((andItem) => !('action' in andItem && '_eq' in andItem['action'] && andItem['action']['_eq'] === 'comment')),
+                            };
+                        }
+                        else {
+                            query.filter = originalQuery.filter;
+                        }
+                    }
+                    break;
+                case 'aggregate':
+                    if (originalQuery.aggregate) {
+                        query.aggregate = originalQuery.aggregate;
+                    }
+                    break;
+                case 'sort':
+                    if (!originalQuery.sort)
+                        break;
+                    query.sort = [];
+                    for (const sort of originalQuery.sort) {
+                        const isDescending = sort.startsWith('-');
+                        const field = isDescending ? sort.slice(1) : sort;
+                        if (field && targetFieldMap[field]) {
+                            query.sort.push(`${isDescending ? '-' : ''}${targetFieldMap[field]}`);
+                        }
+                    }
+                    break;
+            }
+        }
+        if (type === 'activity' && !query.filter) {
+            query.filter = defaultActivityCommentFilter;
+        }
+        return query;
+    }
+    sortLegacyResults(results, sort) {
+        if (!sort)
+            return results;
+        let sortKeys = sort;
+        // Fix legacy app sort query which uses id
+        if (sortKeys.length === 1 && sortKeys[0]?.endsWith('id') && results[0]?.['timestamp']) {
+            sortKeys = [`${sortKeys[0].startsWith('-') ? '-' : ''}timestamp`];
+        }
+        return results.sort((a, b) => {
+            for (const key of sortKeys) {
+                const isDescending = key.startsWith('-');
+                const actualKey = isDescending ? key.substring(1) : key;
+                let aValue = a[actualKey];
+                let bValue = b[actualKey];
+                if (actualKey === 'date_created' || actualKey === 'timestamp') {
+                    aValue = new Date(aValue);
+                    bValue = new Date(bValue);
+                }
+                if (aValue < bValue)
+                    return isDescending ? 1 : -1;
+                if (aValue > bValue)
+                    return isDescending ? -1 : 1;
+            }
+            return 0;
+        });
+    }
+}