@directus/api 10.2.0 → 11.0.0

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 {
@@ -69,22 +67,6 @@ export class ServerService {
                 max: Number.isFinite(env['QUERY_LIMIT_MAX']) ? env['QUERY_LIMIT_MAX'] : -1,
             };
         }
-        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(),
-            };
-        }
         return info;
     }
     async health() {

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/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') {
@@ -199,7 +217,7 @@ 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({
+                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;
                 }
@@ -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 }));
 }

package/dist/utils/redact.d.ts

@@ -0,0 +1,11 @@
+import type { UnknownObject } from '@directus/types';
+type Paths = string[][];
+/**
+ * Redact values at certain paths in an object.
+ * @param input Input object in which values should be redacted.
+ * @param paths Nested array of object paths to be redacted (supports `*` for shallow matching, `**` for deep matching).
+ * @param replacement Replacement the values are redacted by.
+ * @returns Redacted object.
+ */
+export declare function redact(input: UnknownObject, paths: Paths, replacement: string): UnknownObject;
+export {};

package/dist/utils/redact.js

@@ -0,0 +1,75 @@
+import { isObject } from '@directus/utils';
+/**
+ * Redact values at certain paths in an object.
+ * @param input Input object in which values should be redacted.
+ * @param paths Nested array of object paths to be redacted (supports `*` for shallow matching, `**` for deep matching).
+ * @param replacement Replacement the values are redacted by.
+ * @returns Redacted object.
+ */
+export function redact(input, paths, replacement) {
+    const wildcardChars = ['*', '**'];
+    const clone = structuredClone(input);
+    const visited = new WeakSet();
+    traverse(clone, paths);
+    return clone;
+    function traverse(object, checkPaths) {
+        if (checkPaths.length === 0) {
+            return;
+        }
+        visited.add(object);
+        const globalCheckPaths = [];
+        for (const key of Object.keys(object)) {
+            const localCheckPaths = [];
+            for (const [index, path] of [...checkPaths].entries()) {
+                const [current, ...remaining] = path;
+                const escapedKey = wildcardChars.includes(key) ? `\\${key}` : key;
+                switch (current) {
+                    case escapedKey:
+                        if (remaining.length > 0) {
+                            localCheckPaths.push(remaining);
+                        }
+                        else {
+                            object[key] = replacement;
+                            checkPaths.splice(index, 1);
+                        }
+                        break;
+                    case '*':
+                        if (remaining.length > 0) {
+                            globalCheckPaths.push(remaining);
+                            checkPaths.splice(index, 1);
+                        }
+                        else {
+                            object[key] = replacement;
+                        }
+                        break;
+                    case '**':
+                        if (remaining.length > 0) {
+                            const [next, ...nextRemaining] = remaining;
+                            if (next === escapedKey) {
+                                if (nextRemaining.length === 0) {
+                                    object[key] = replacement;
+                                }
+                                else {
+                                    localCheckPaths.push(nextRemaining);
+                                }
+                            }
+                            else if (next !== undefined && wildcardChars.includes(next)) {
+                                localCheckPaths.push(remaining);
+                            }
+                            else {
+                                localCheckPaths.push(path);
+                            }
+                        }
+                        else {
+                            object[key] = replacement;
+                        }
+                        break;
+                }
+            }
+            const value = object[key];
+            if (isObject(value) && !visited.has(value)) {
+                traverse(value, [...globalCheckPaths, ...localCheckPaths]);
+            }
+        }
+    }
+}

package/dist/utils/schedule.d.ts

@@ -0,0 +1,5 @@
+export interface ScheduledJob {
+    stop(): Promise<void>;
+}
+export declare function validateCron(rule: string): boolean;
+export declare function scheduleSynchronizedJob(id: string, rule: string, cb: (fireDate: Date) => void | Promise<void>): ScheduledJob;

package/dist/utils/schedule.js

@@ -0,0 +1,27 @@
+import cron from 'cron-parser';
+import schedule from 'node-schedule';
+import { SynchronizedClock } from '../synchronization.js';
+export function validateCron(rule) {
+    try {
+        cron.parseExpression(rule);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+export function scheduleSynchronizedJob(id, rule, cb) {
+    const clock = new SynchronizedClock(`${id}:${rule}`);
+    const job = schedule.scheduleJob(rule, async (fireDate) => {
+        const nextTimestamp = job.nextInvocation().getTime();
+        const wasSet = await clock.set(nextTimestamp);
+        if (wasSet) {
+            await cb(fireDate);
+        }
+    });
+    const stop = async () => {
+        job.cancel();
+        await clock.reset();
+    };
+    return { stop };
+}

package/dist/utils/should-clear-cache.d.ts

@@ -0,0 +1,10 @@
+import type Keyv from 'keyv';
+import type { MutationOptions } from '../types/items.js';
+/**
+ * Check whether cache should be cleared
+ *
+ * @param cache Cache instance
+ * @param opts Mutation options
+ * @param collection Collection name to check if cache purging should be ignored
+ */
+export declare function shouldClearCache(cache: Keyv<any> | null, opts?: MutationOptions, collection?: string): cache is Keyv<any>;