@directus/api 10.1.0 → 11.0.0

package/dist/services/items.js

@@ -9,6 +9,7 @@ import env from '../env.js';
 import { translateDatabaseError } from '../exceptions/database/translate.js';
 import { ForbiddenException, InvalidPayloadException } from '../exceptions/index.js';
 import getASTFromQuery from '../utils/get-ast-from-query.js';
+import { shouldClearCache } from '../utils/should-clear-cache.js';
 import { validateKeys } from '../utils/validate-keys.js';
 import { AuthorizationService } from './authorization.js';
 import { PayloadService } from './payload.js';
@@ -180,7 +181,7 @@ export class ItemsService {
                     // Make sure to set the parent field of the child-revision rows
                     const childrenRevisions = [...revisionsM2O, ...revisionsA2O, ...revisionsO2M];
                     if (childrenRevisions.length > 0) {
-                        await revisionsService.updateMany(childrenRevisions, { parent: revision }, { bypassLimits: true });
+                        await revisionsService.updateMany(childrenRevisions, { parent: revision });
                     }
                     if (opts.onRevisionCreate) {
                         opts.onRevisionCreate(revision);
@@ -220,7 +221,7 @@ export class ItemsService {
                 }
             }
         }
-        if (this.cache && env['CACHE_AUTO_PURGE'] && opts.autoPurgeCache !== false) {
+        if (shouldClearCache(this.cache, opts, this.collection)) {
             await this.cache.clear();
         }
         return primaryKey;
@@ -260,7 +261,7 @@ export class ItemsService {
                 }
             }
         }
-        if (this.cache && env['CACHE_AUTO_PURGE'] && opts.autoPurgeCache !== false) {
+        if (shouldClearCache(this.cache, opts, this.collection)) {
             await this.cache.clear();
         }
         return primaryKeys;
@@ -401,7 +402,7 @@ export class ItemsService {
             });
         }
         finally {
-            if (this.cache && env['CACHE_AUTO_PURGE'] && opts.autoPurgeCache !== false) {
+            if (shouldClearCache(this.cache, opts, this.collection)) {
                 await this.cache.clear();
             }
         }
@@ -514,7 +515,7 @@ export class ItemsService {
                         data: snapshots && Array.isArray(snapshots) ? JSON.stringify(snapshots[index]) : JSON.stringify(snapshots),
                         delta: await payloadService.prepareDelta(payloadWithTypeCasting),
                     })))).filter((revision) => revision.delta);
-                    const revisionIDs = await revisionsService.createMany(revisions, { bypassLimits: true });
+                    const revisionIDs = await revisionsService.createMany(revisions);
                     for (let i = 0; i < revisionIDs.length; i++) {
                         const revisionID = revisionIDs[i];
                         if (opts.onRevisionCreate) {
@@ -526,14 +527,14 @@ export class ItemsService {
                             // with all other revisions on the current level as regular "flat" updates, and
                             // nested revisions as children of this first "root" item.
                             if (childrenRevisions.length > 0) {
-                                await revisionsService.updateMany(childrenRevisions, { parent: revisionID }, { bypassLimits: true });
+                                await revisionsService.updateMany(childrenRevisions, { parent: revisionID });
                             }
                         }
                     }
                 }
             }
         });
-        if (this.cache && env['CACHE_AUTO_PURGE'] && opts.autoPurgeCache !== false) {
+        if (shouldClearCache(this.cache, opts, this.collection)) {
             await this.cache.clear();
         }
         if (opts.emitEvents !== false) {
@@ -610,7 +611,7 @@ export class ItemsService {
             }
             return primaryKeys;
         });
-        if (this.cache && env['CACHE_AUTO_PURGE'] && opts.autoPurgeCache !== false) {
+        if (shouldClearCache(this.cache, opts, this.collection)) {
             await this.cache.clear();
         }
         return primaryKeys;
@@ -683,7 +684,7 @@ export class ItemsService {
                 })), { bypassLimits: true });
             }
         });
-        if (this.cache && env['CACHE_AUTO_PURGE'] && opts?.autoPurgeCache !== false) {
+        if (shouldClearCache(this.cache, opts, this.collection)) {
             await this.cache.clear();
         }
         if (opts.emitEvents !== false) {

package/dist/services/revisions.d.ts

@@ -1,6 +1,11 @@
-import type { AbstractServiceOptions, PrimaryKey } from '../types/index.js';
+import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
 import { ItemsService } from './items.js';
 export declare class RevisionsService extends ItemsService {
     constructor(options: AbstractServiceOptions);
     revert(pk: PrimaryKey): Promise<void>;
+    private setDefaultOptions;
+    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateOne(key: PrimaryKey, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
 }

package/dist/services/revisions.js

@@ -17,4 +17,28 @@ export class RevisionsService extends ItemsService {
         });
         await service.updateOne(revision['item'], revision['data']);
     }
+    setDefaultOptions(opts) {
+        if (!opts) {
+            return { autoPurgeCache: false, bypassLimits: true };
+        }
+        if (!('autoPurgeCache' in opts)) {
+            opts.autoPurgeCache = false;
+        }
+        if (!('bypassLimits' in opts)) {
+            opts.bypassLimits = true;
+        }
+        return opts;
+    }
+    async createOne(data, opts) {
+        return super.createOne(data, this.setDefaultOptions(opts));
+    }
+    async createMany(data, opts) {
+        return super.createMany(data, this.setDefaultOptions(opts));
+    }
+    async updateOne(key, data, opts) {
+        return super.updateOne(key, data, this.setDefaultOptions(opts));
+    }
+    async updateMany(keys, data, opts) {
+        return super.updateMany(keys, data, this.setDefaultOptions(opts));
+    }
 }

package/dist/services/server.js

@@ -1,7 +1,6 @@
 import { toArray } from '@directus/utils';
 import { merge } from 'lodash-es';
 import { Readable } from 'node:stream';
-import os from 'os';
 import { performance } from 'perf_hooks';
 import { getCache } from '../cache.js';
 import getDatabase, { hasDatabaseConnection } from '../database/index.js';
@@ -12,7 +11,6 @@ import { rateLimiterGlobal } from '../middleware/rate-limiter-global.js';
 import { rateLimiter } from '../middleware/rate-limiter-ip.js';
 import { SERVER_ONLINE } from '../server.js';
 import { getStorage } from '../storage/index.js';
-import { getOSInfo } from '../utils/get-os-info.js';
 import { version } from '../utils/package.js';
 import { SettingsService } from './settings.js';
 export class ServerService {
@@ -64,21 +62,9 @@ export class ServerService {
             info['flows'] = {
                 execAllowedModules: env['FLOWS_EXEC_ALLOWED_MODULES'] ? toArray(env['FLOWS_EXEC_ALLOWED_MODULES']) : [],
             };
-        }
-        if (this.accountability?.admin === true) {
-            const { osType, osVersion } = getOSInfo();
-            info['directus'] = {
-                version,
-            };
-            info['node'] = {
-                version: process.versions.node,
-                uptime: Math.round(process.uptime()),
-            };
-            info['os'] = {
-                type: osType,
-                version: osVersion,
-                uptime: Math.round(os.uptime()),
-                totalmem: os.totalmem(),
+            info['queryLimit'] = {
+                default: env['QUERY_LIMIT_DEFAULT'],
+                max: Number.isFinite(env['QUERY_LIMIT_MAX']) ? env['QUERY_LIMIT_MAX'] : -1,
             };
         }
         return info;

package/dist/services/specifications.d.ts

@@ -1,6 +1,6 @@
-import type { Knex } from 'knex';
-import type { OpenAPIObject } from 'openapi3-ts';
 import type { Accountability, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { OpenAPIObject } from 'openapi3-ts/oas30';
 import type { AbstractServiceOptions } from '../types/index.js';
 import { CollectionsService } from './collections.js';
 import { FieldsService } from './fields.js';

package/dist/services/specifications.js

@@ -1,15 +1,15 @@
+import formatTitle from '@directus/format-title';
 import { spec } from '@directus/specs';
 import { cloneDeep, mergeWith } from 'lodash-es';
-import { version } from '../utils/package.js';
 import { OAS_REQUIRED_SCHEMAS } from '../constants.js';
 import getDatabase from '../database/index.js';
 import env from '../env.js';
 import { getRelationType } from '../utils/get-relation-type.js';
+import { version } from '../utils/package.js';
 import { CollectionsService } from './collections.js';
 import { FieldsService } from './fields.js';
 import { GraphQLService } from './graphql/index.js';
 import { RelationsService } from './relations.js';
-import formatTitle from '@directus/format-title';
 export class SpecificationService {
     accountability;
     knex;
@@ -148,7 +148,8 @@ class OASSpecsService {
                 const listBase = cloneDeep(spec.paths['/items/{collection}']);
                 const detailBase = cloneDeep(spec.paths['/items/{collection}/{id}']);
                 const collection = tag['x-collection'];
-                for (const method of ['post', 'get', 'patch', 'delete']) {
+                const methods = ['post', 'get', 'patch', 'delete'];
+                for (const method of methods) {
                     const hasPermission = this.accountability?.admin === true ||
                         !!permissions.find((permission) => permission.collection === collection && permission.action === this.getActionForMethod(method));
                     if (hasPermission) {
@@ -156,7 +157,7 @@ class OASSpecsService {
                             paths[`/items/${collection}`] = {};
                         if (!paths[`/items/${collection}/{id}`])
                             paths[`/items/${collection}/{id}`] = {};
-                        if (listBase[method]) {
+                        if (listBase?.[method]) {
                             paths[`/items/${collection}`][method] = mergeWith(cloneDeep(listBase[method]), {
                                 description: listBase[method].description.replace('item', collection + ' item'),
                                 tags: [tag.name],
@@ -208,7 +209,7 @@ class OASSpecsService {
                                 return undefined;
                             });
                         }
-                        if (detailBase[method]) {
+                        if (detailBase?.[method]) {
                             paths[`/items/${collection}/{id}`][method] = mergeWith(cloneDeep(detailBase[method]), {
                                 description: detailBase[method].description.replace('item', collection + ' item'),
                                 tags: [tag.name],

package/dist/services/translations.d.ts

@@ -0,0 +1,10 @@
+import type { Item, PrimaryKey } from '@directus/types';
+import { ItemsService } from './items.js';
+import type { AbstractServiceOptions } from '../types/services.js';
+import type { MutationOptions } from '../types/items.js';
+export declare class TranslationsService extends ItemsService {
+    constructor(options: AbstractServiceOptions);
+    private translationKeyExists;
+    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+}

package/dist/services/translations.js

@@ -0,0 +1,36 @@
+import getDatabase from '../database/index.js';
+import { ItemsService } from './items.js';
+import { InvalidPayloadException } from '../index.js';
+export class TranslationsService extends ItemsService {
+    constructor(options) {
+        super('directus_translations', options);
+        this.knex = options.knex || getDatabase();
+        this.accountability = options.accountability || null;
+        this.schema = options.schema;
+    }
+    async translationKeyExists(key, language) {
+        const result = await this.knex.select('id').from(this.collection).where({ key, language });
+        return result.length > 0;
+    }
+    async createOne(data, opts) {
+        if (await this.translationKeyExists(data['key'], data['language'])) {
+            throw new InvalidPayloadException('Duplicate key and language combination.');
+        }
+        return await super.createOne(data, opts);
+    }
+    async updateMany(keys, data, opts) {
+        if (keys.length > 0 && 'key' in data && 'language' in data) {
+            throw new InvalidPayloadException('Duplicate key and language combination.');
+        }
+        else if ('key' in data || 'language' in data) {
+            const items = await this.readMany(keys);
+            for (const item of items) {
+                const updatedData = { ...item, ...data };
+                if (await this.translationKeyExists(updatedData['key'], updatedData['language'])) {
+                    throw new InvalidPayloadException('Duplicate key and language combination.');
+                }
+            }
+        }
+        return await super.updateMany(keys, data, opts);
+    }
+}

package/dist/synchronization.d.ts

@@ -0,0 +1,7 @@
+export declare class SynchronizedClock {
+    private key;
+    private synchronizationManager;
+    constructor(id: string);
+    set(timestamp: number): Promise<boolean>;
+    reset(): Promise<void>;
+}

package/dist/synchronization.js

@@ -0,0 +1,120 @@
+import { Redis } from 'ioredis';
+import env from './env.js';
+import { getConfigFromEnv } from './utils/get-config-from-env.js';
+let synchronizationManager;
+function getSynchronizationManager() {
+    if (synchronizationManager)
+        return synchronizationManager;
+    if (env['SYNCHRONIZATION_STORE'] === 'redis') {
+        synchronizationManager = new SynchronizationManagerRedis();
+    }
+    else {
+        synchronizationManager = new SynchronizationManagerMemory();
+    }
+    return synchronizationManager;
+}
+class SynchronizationManagerMemory {
+    store;
+    constructor() {
+        this.store = {};
+    }
+    async set(key, value) {
+        this.setSync(key, value);
+    }
+    async get(key) {
+        return this.getSync(key);
+    }
+    async delete(key) {
+        this.deleteSync(key);
+    }
+    async exists(key) {
+        return this.existsSync(key);
+    }
+    async setGreaterThan(key, value) {
+        if (this.existsSync(key)) {
+            const oldValue = Number(this.getSync(key));
+            if (value <= oldValue) {
+                return false;
+            }
+        }
+        this.setSync(key, value);
+        return true;
+    }
+    setSync(key, value) {
+        this.store[key] = String(value);
+    }
+    getSync(key) {
+        return this.store[key] ?? null;
+    }
+    deleteSync(key) {
+        delete this.store[key];
+    }
+    existsSync(key) {
+        return key in this.store;
+    }
+}
+const SET_GREATER_THAN_SCRIPT = `
+  local key = KEYS[1]
+  local value = tonumber(ARGV[1])
+
+  if redis.call("EXISTS", key) == 1 then
+    local oldValue = tonumber(redis.call('GET', key))
+
+    if value <= oldValue then
+      return false
+    end
+  end
+
+  redis.call('SET', key, value)
+
+  return true
+`;
+class SynchronizationManagerRedis {
+    namespace;
+    client;
+    constructor() {
+        const config = getConfigFromEnv('SYNCHRONIZATION_REDIS');
+        this.client = new Redis(env['SYNCHRONIZATION_REDIS'] ?? config);
+        this.namespace = env['SYNCHRONIZATION_NAMESPACE'] ?? 'directus';
+        this.client.defineCommand('setGreaterThan', {
+            numberOfKeys: 1,
+            lua: SET_GREATER_THAN_SCRIPT,
+        });
+    }
+    async set(key, value) {
+        await this.client.set(this.getNamespacedKey(key), value);
+    }
+    get(key) {
+        return this.client.get(this.getNamespacedKey(key));
+    }
+    async delete(key) {
+        await this.client.del(this.getNamespacedKey(key));
+    }
+    async exists(key) {
+        const doesExist = await this.client.exists(this.getNamespacedKey(key));
+        return doesExist === 1;
+    }
+    async setGreaterThan(key, value) {
+        const client = this.client;
+        const wasSet = await client.setGreaterThan(this.getNamespacedKey(key), value);
+        return wasSet === 1;
+    }
+    getNamespacedKey(key) {
+        return `${this.namespace}:${key}`;
+    }
+}
+export class SynchronizedClock {
+    key;
+    synchronizationManager;
+    constructor(id) {
+        this.key = `clock:${id}`;
+        this.synchronizationManager = getSynchronizationManager();
+    }
+    async set(timestamp) {
+        const wasSet = await this.synchronizationManager.setGreaterThan(this.key, timestamp);
+        return wasSet;
+    }
+    async reset() {
+        await this.synchronizationManager.delete(this.key);
+    }
+}

package/dist/types/assets.d.ts

@@ -6,10 +6,15 @@ export type TransformationMap = {
 };
 export type Transformation = TransformationMap[keyof TransformationMap];
 export type TransformationResize = Pick<ResizeOptions, 'width' | 'height' | 'fit' | 'withoutEnlargement'>;
+export type TransformationFormat = 'jpg' | 'jpeg' | 'png' | 'webp' | 'tiff' | 'avif';
 export type TransformationParams = {
     key?: string;
     transforms?: Transformation[];
-    format?: 'auto' | 'jpg' | 'jpeg' | 'png' | 'webp' | 'tiff' | 'avif';
+    format?: TransformationFormat | 'auto';
     quality?: number;
 } & TransformationResize;
+export type TransformationSet = {
+    transformationParams: TransformationParams;
+    acceptFormat?: TransformationFormat | undefined;
+};
 export {};

package/dist/types/events.d.ts

@@ -1,5 +1,5 @@
 import type { ActionHandler, FilterHandler, InitHandler } from '@directus/types';
-import type { ScheduledTask } from 'node-cron';
+import type { ScheduledJob } from '../utils/schedule.js';
 export type EventHandler = {
     type: 'filter';
     name: string;
@@ -14,5 +14,5 @@ export type EventHandler = {
     handler: InitHandler;
 } | {
     type: 'schedule';
-    task: ScheduledTask;
+    job: ScheduledJob;
 };

package/dist/utils/apply-query.d.ts

@@ -11,6 +11,7 @@ export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex
     hasMultiRelationalSort?: boolean | undefined;
 }): {
     query: Knex.QueryBuilder<any, any>;
+    hasJoins: boolean;
     hasMultiRelationalFilter: boolean;
 };
 export type ColumnSortRecord = {
@@ -22,13 +23,19 @@ export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery:
         order: "asc" | "desc";
         column: any;
     }[];
+    hasJoins: boolean;
     hasMultiRelationalSort: boolean;
-} | undefined;
+} | {
+    hasJoins: boolean;
+    hasMultiRelationalSort: boolean;
+    sortRecords?: never;
+};
 export declare function applyLimit(knex: Knex, rootQuery: Knex.QueryBuilder, limit: any): void;
 export declare function applyOffset(knex: Knex, rootQuery: Knex.QueryBuilder, offset: any): void;
 export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootFilter: Filter, collection: string, aliasMap: AliasMap): {
     query: Knex.QueryBuilder<any, any>;
+    hasJoins: boolean;
     hasMultiRelationalFilter: boolean;
 };
 export declare function applySearch(schema: SchemaOverview, dbQuery: Knex.QueryBuilder, searchQuery: string, collection: string): Promise<void>;
-export declare function applyAggregate(dbQuery: Knex.QueryBuilder, aggregate: Aggregate, collection: string): void;
+export declare function applyAggregate(schema: SchemaOverview, dbQuery: Knex.QueryBuilder, aggregate: Aggregate, collection: string, hasJoins: boolean): void;

package/dist/utils/apply-query.js

@@ -15,6 +15,7 @@ export const generateAlias = customAlphabet('abcdefghijklmnopqrstuvwxyz', 5);
  */
 export default function applyQuery(knex, collection, dbQuery, query, schema, options) {
     const aliasMap = options?.aliasMap ?? Object.create(null);
+    let hasJoins = false;
     let hasMultiRelationalFilter = false;
     applyLimit(knex, dbQuery, query.limit);
     if (query.offset) {
@@ -24,7 +25,10 @@ export default function applyQuery(knex, collection, dbQuery, query, schema, opt
         applyOffset(knex, dbQuery, query.limit * (query.page - 1));
     }
     if (query.sort && !options?.isInnerQuery && !options?.hasMultiRelationalSort) {
-        applySort(knex, schema, dbQuery, query.sort, collection, aliasMap);
+        const sortResult = applySort(knex, schema, dbQuery, query.sort, collection, aliasMap);
+        if (!hasJoins) {
+            hasJoins = sortResult.hasJoins;
+        }
     }
     if (query.search) {
         applySearch(schema, dbQuery, query.search, collection);
@@ -32,19 +36,24 @@ export default function applyQuery(knex, collection, dbQuery, query, schema, opt
     if (query.group) {
         dbQuery.groupBy(query.group.map((column) => getColumn(knex, collection, column, false, schema)));
     }
-    if (query.aggregate) {
-        applyAggregate(dbQuery, query.aggregate, collection);
-    }
     if (query.filter) {
-        hasMultiRelationalFilter = applyFilter(knex, schema, dbQuery, query.filter, collection, aliasMap).hasMultiRelationalFilter;
+        const filterResult = applyFilter(knex, schema, dbQuery, query.filter, collection, aliasMap);
+        if (!hasJoins) {
+            hasJoins = filterResult.hasJoins;
+        }
+        hasMultiRelationalFilter = filterResult.hasMultiRelationalFilter;
+    }
+    if (query.aggregate) {
+        applyAggregate(schema, dbQuery, query.aggregate, collection, hasJoins);
     }
-    return { query: dbQuery, hasMultiRelationalFilter };
+    return { query: dbQuery, hasJoins, hasMultiRelationalFilter };
 }
 function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, knex }) {
     let hasMultiRelational = false;
+    let isJoinAdded = false;
     path = clone(path);
     followRelation(path);
-    return hasMultiRelational;
+    return { hasMultiRelational, isJoinAdded };
     function followRelation(pathParts, parentCollection = collection, parentFields) {
         /**
          * For A2M fields, the path can contain an optional collection scope <field>:<scope>
@@ -65,6 +74,7 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, kne
             if (relationType === 'm2o') {
                 rootQuery.leftJoin({ [alias]: relation.related_collection }, `${aliasedParentCollection}.${relation.field}`, `${alias}.${schema.collections[relation.related_collection].primary}`);
                 aliasMap[aliasKey].collection = relation.related_collection;
+                isJoinAdded = true;
             }
             else if (relationType === 'a2o') {
                 const pathScope = pathParts[0].split(':')[1];
@@ -77,6 +87,7 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, kne
                         .andOn(`${aliasedParentCollection}.${relation.field}`, '=', knex.raw(getHelpers(knex).schema.castA2oPrimaryKey(), `${alias}.${schema.collections[pathScope].primary}`));
                 });
                 aliasMap[aliasKey].collection = pathScope;
+                isJoinAdded = true;
             }
             else if (relationType === 'o2a') {
                 rootQuery.leftJoin({ [alias]: relation.collection }, (joinClause) => {
@@ -86,11 +97,13 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, kne
                 });
                 aliasMap[aliasKey].collection = relation.collection;
                 hasMultiRelational = true;
+                isJoinAdded = true;
             }
             else if (relationType === 'o2m') {
                 rootQuery.leftJoin({ [alias]: relation.collection }, `${aliasedParentCollection}.${schema.collections[relation.related_collection].primary}`, `${alias}.${relation.field}`);
                 aliasMap[aliasKey].collection = relation.collection;
                 hasMultiRelational = true;
+                isJoinAdded = true;
             }
         }
         let parent;
@@ -114,6 +127,7 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, kne
 }
 export function applySort(knex, schema, rootQuery, rootSort, collection, aliasMap, returnRecords = false) {
     const relations = schema.relations;
+    let hasJoins = false;
     let hasMultiRelationalSort = false;
     const sortRecords = rootSort.map((sortField) => {
         const column = sortField.split('.');
@@ -134,7 +148,7 @@ export function applySort(knex, schema, rootQuery, rootSort, collection, aliasMa
                 };
             }
         }
-        const hasMultiRelational = addJoin({
+        const { hasMultiRelational, isJoinAdded } = addJoin({
             path: column,
             collection,
             aliasMap,
@@ -151,6 +165,9 @@ export function applySort(knex, schema, rootQuery, rootSort, collection, aliasMa
             schema,
         });
         const [alias, field] = columnPath.split('.');
+        if (!hasJoins) {
+            hasJoins = isJoinAdded;
+        }
         if (!hasMultiRelationalSort) {
             hasMultiRelationalSort = hasMultiRelational;
         }
@@ -160,11 +177,11 @@ export function applySort(knex, schema, rootQuery, rootSort, collection, aliasMa
         };
     });
     if (returnRecords)
-        return { sortRecords, hasMultiRelationalSort };
+        return { sortRecords, hasJoins, hasMultiRelationalSort };
     // Clears the order if any, eg: from MSSQL offset
     rootQuery.clear('order');
     rootQuery.orderBy(sortRecords);
-    return undefined;
+    return { hasJoins, hasMultiRelationalSort };
 }
 export function applyLimit(knex, rootQuery, limit) {
     if (typeof limit === 'number') {
@@ -179,10 +196,11 @@ export function applyOffset(knex, rootQuery, offset) {
 export function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap) {
     const helpers = getHelpers(knex);
     const relations = schema.relations;
+    let hasJoins = false;
     let hasMultiRelationalFilter = false;
     addJoins(rootQuery, rootFilter, collection);
     addWhereClauses(knex, rootQuery, rootFilter, collection);
-    return { query: rootQuery, hasMultiRelationalFilter };
+    return { query: rootQuery, hasJoins, hasMultiRelationalFilter };
     function addJoins(dbQuery, filter, collection) {
         for (const [key, value] of Object.entries(filter)) {
             if (key === '_or' || key === '_and') {
@@ -198,8 +216,8 @@ export function applyFilter(knex, schema, rootQuery, rootFilter, collection, ali
             }
             const filterPath = getFilterPath(key, value);
             if (filterPath.length > 1 ||
-                (!(key.includes('(') && key.includes(')')) && schema.collections[collection].fields[key].type === 'alias')) {
-                const hasMultiRelational = addJoin({
+                (!(key.includes('(') && key.includes(')')) && schema.collections[collection]?.fields[key]?.type === 'alias')) {
+                const { hasMultiRelational, isJoinAdded } = addJoin({
                     path: filterPath,
                     collection,
                     knex,
@@ -208,6 +226,9 @@ export function applyFilter(knex, schema, rootQuery, rootFilter, collection, ali
                     rootQuery,
                     aliasMap,
                 });
+                if (!hasJoins) {
+                    hasJoins = isJoinAdded;
+                }
                 if (!hasMultiRelationalFilter) {
                     hasMultiRelationalFilter = hasMultiRelational;
                 }
@@ -238,7 +259,7 @@ export function applyFilter(knex, schema, rootQuery, rootFilter, collection, ali
             const { relation, relationType } = getRelationInfo(relations, collection, pathRoot);
             const { operator: filterOperator, value: filterValue } = getOperation(key, value);
             if (filterPath.length > 1 ||
-                (!(key.includes('(') && key.includes(')')) && schema.collections[collection].fields[key].type === 'alias')) {
+                (!(key.includes('(') && key.includes(')')) && schema.collections[collection]?.fields[key]?.type === 'alias')) {
                 if (!relation)
                     continue;
                 if (relationType === 'o2m' || relationType === 'o2a') {
@@ -503,7 +524,7 @@ function validateNumber(value, parsed) {
     // (prevent unintended number parsing, e.g. String(7) !== "ob111")
     return String(parsed) === value;
 }
-export function applyAggregate(dbQuery, aggregate, collection) {
+export function applyAggregate(schema, dbQuery, aggregate, collection, hasJoins) {
     for (const [operation, fields] of Object.entries(aggregate)) {
         if (!fields)
             continue;
@@ -526,7 +547,13 @@ export function applyAggregate(dbQuery, aggregate, collection) {
                 }
             }
             if (operation === 'countDistinct') {
-                dbQuery.countDistinct(`${collection}.${field}`, { as: `countDistinct->${field}` });
+                if (!hasJoins && schema.collections[collection]?.primary === field) {
+                    // Optimize to count as primary keys are unique
+                    dbQuery.count(`${collection}.${field}`, { as: `countDistinct->${field}` });
+                }
+                else {
+                    dbQuery.countDistinct(`${collection}.${field}`, { as: `countDistinct->${field}` });
+                }
             }
             if (operation === 'sum') {
                 dbQuery.sum(`${collection}.${field}`, { as: `sum->${field}` });

package/dist/utils/md.js

@@ -4,5 +4,5 @@ import sanitizeHTML from 'sanitize-html';
  * Render and sanitize a markdown string
  */
 export function md(str) {
-    return sanitizeHTML(marked(str));
+    return sanitizeHTML(marked(str, { headerIds: false, mangle: false }));
 }