@directus/api 22.1.1 → 22.2.0

package/dist/logger/index.js

@@ -1,12 +1,15 @@
 import { useEnv } from '@directus/env';
-import { REDACTED_TEXT, toArray } from '@directus/utils';
+import { REDACTED_TEXT, toArray, toBoolean } from '@directus/utils';
 import { merge } from 'lodash-es';
 import { URL } from 'node:url';
 import { pino } from 'pino';
 import { pinoHttp, stdSerializers } from 'pino-http';
+import { httpPrintFactory } from 'pino-http-print';
+import { build as pinoPretty } from 'pino-pretty';
 import { getConfigFromEnv } from '../utils/get-config-from-env.js';
+import { LogsStream } from './logs-stream.js';
 import { redactQuery } from './redact-query.js';
-export const _cache = { logger: undefined };
+export const _cache = { logger: undefined, logsStream: undefined, httpLogsStream: undefined };
 export const useLogger = () => {
     if (_cache.logger) {
         return _cache.logger;
@@ -14,6 +17,23 @@ export const useLogger = () => {
     _cache.logger = createLogger();
     return _cache.logger;
 };
+export const getLogsStream = (pretty) => {
+    if (_cache.logsStream) {
+        return _cache.logsStream;
+    }
+    _cache.logsStream = new LogsStream(pretty ? 'basic' : false);
+    return _cache.logsStream;
+};
+export const getHttpLogsStream = (pretty) => {
+    if (_cache.httpLogsStream) {
+        return _cache.httpLogsStream;
+    }
+    _cache.httpLogsStream = new LogsStream(pretty ? 'http' : false);
+    return _cache.httpLogsStream;
+};
+export const getLoggerLevelValue = (level) => {
+    return pino.levels.values[level] || pino.levels.values['info'];
+};
 export const createLogger = () => {
     const env = useEnv();
     const pinoOptions = {
@@ -23,15 +43,6 @@ export const createLogger = () => {
             censor: REDACTED_TEXT,
         },
     };
-    if (env['LOG_STYLE'] !== 'raw') {
-        pinoOptions.transport = {
-            target: 'pino-pretty',
-            options: {
-                ignore: 'hostname,pid',
-                sync: true,
-            },
-        };
-    }
     const loggerEnvConfig = getConfigFromEnv('LOGGER_', 'LOGGER_HTTP');
     // Expose custom log levels into formatter function
     if (loggerEnvConfig['levels']) {
@@ -50,7 +61,33 @@ export const createLogger = () => {
         };
         delete loggerEnvConfig['levels'];
     }
-    return pino(merge(pinoOptions, loggerEnvConfig));
+    const mergedOptions = merge(pinoOptions, loggerEnvConfig);
+    const streams = [];
+    // Console Logs
+    if (env['LOG_STYLE'] !== 'raw') {
+        streams.push({
+            level: mergedOptions.level,
+            stream: pinoPretty({
+                ignore: 'hostname,pid',
+                sync: true,
+            }),
+        });
+    }
+    else {
+        streams.push({ level: mergedOptions.level, stream: process.stdout });
+    }
+    // WebSocket Logs
+    if (toBoolean(env['WEBSOCKETS_LOGS_ENABLED'])) {
+        const wsLevel = env['WEBSOCKETS_LOGS_LEVEL'] || 'info';
+        if (getLoggerLevelValue(wsLevel) < getLoggerLevelValue(mergedOptions.level)) {
+            mergedOptions.level = wsLevel;
+        }
+        streams.push({
+            level: wsLevel,
+            stream: getLogsStream(env['WEBSOCKETS_LOGS_STYLE'] !== 'raw'),
+        });
+    }
+    return pino(mergedOptions, pino.multistream(streams));
 };
 export const createExpressLogger = () => {
     const env = useEnv();
@@ -63,21 +100,7 @@ export const createExpressLogger = () => {
             censor: REDACTED_TEXT,
         },
     };
-    if (env['LOG_STYLE'] !== 'raw') {
-        httpLoggerOptions.transport = {
-            target: 'pino-http-print',
-            options: {
-                all: true,
-                translateTime: 'SYS:HH:MM:ss',
-                relativeUrl: true,
-                prettyOptions: {
-                    ignore: 'hostname,pid',
-                    sync: true,
-                },
-            },
-        };
-    }
-    if (env['LOG_STYLE'] === 'raw') {
+    if (env['LOG_STYLE'] === 'raw' || toBoolean(env['WEBSOCKETS_LOGS_ENABLED'])) {
         httpLoggerOptions.redact = {
             paths: ['req.headers.authorization', 'req.headers.cookie', 'res.headers', 'req.query.access_token'],
             censor: (value, pathParts) => {
@@ -120,8 +143,36 @@ export const createExpressLogger = () => {
             },
         };
     }
+    const mergedHttpOptions = merge(httpLoggerOptions, loggerEnvConfig);
+    const streams = [];
+    if (env['LOG_STYLE'] !== 'raw') {
+        const pinoHttpPretty = httpPrintFactory({
+            all: true,
+            translateTime: 'SYS:HH:MM:ss',
+            relativeUrl: true,
+            prettyOptions: {
+                ignore: 'hostname,pid',
+                sync: true,
+            },
+        });
+        streams.push({ level: mergedHttpOptions.level, stream: pinoHttpPretty(process.stdout) });
+    }
+    else {
+        streams.push({ level: mergedHttpOptions.level, stream: process.stdout });
+    }
+    // WebSocket Logs
+    if (toBoolean(env['WEBSOCKETS_LOGS_ENABLED'])) {
+        const wsLevel = env['WEBSOCKETS_LOGS_LEVEL'] || 'info';
+        if (getLoggerLevelValue(wsLevel) < getLoggerLevelValue(mergedHttpOptions.level)) {
+            mergedHttpOptions.level = wsLevel;
+        }
+        streams.push({
+            level: wsLevel,
+            stream: getHttpLogsStream(env['WEBSOCKETS_LOGS_STYLE'] !== 'raw'),
+        });
+    }
     return pinoHttp({
-        logger: pino(merge(httpLoggerOptions, loggerEnvConfig)),
+        logger: pino(mergedHttpOptions, pino.multistream(streams)),
         ...httpLoggerEnvConfig,
         serializers: {
             req(request) {

package/dist/logger/logs-stream.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Bus } from '@directus/memory';
+import { Writable } from 'stream';
+type PrettyType = 'basic' | 'http' | false;
+export declare class LogsStream extends Writable {
+    messenger: Bus;
+    pretty: PrettyType;
+    constructor(pretty: PrettyType);
+    _write(chunk: string, _encoding: string, callback: (error?: Error | null) => void): void;
+}
+export {};

package/dist/logger/logs-stream.js

@@ -0,0 +1,41 @@
+import { nanoid } from 'nanoid';
+import { Writable } from 'stream';
+import { useBus } from '../bus/index.js';
+const nodeId = nanoid(8);
+export class LogsStream extends Writable {
+    messenger;
+    pretty;
+    constructor(pretty) {
+        super({ objectMode: true });
+        this.messenger = useBus();
+        this.pretty = pretty;
+    }
+    _write(chunk, _encoding, callback) {
+        if (!this.pretty) {
+            // keeping this string interpolation for performance on RAW logs
+            this.messenger.publish('logs', `{"log":${chunk},"nodeId":"${nodeId}"}`);
+            return callback();
+        }
+        const log = JSON.parse(chunk);
+        if (this.pretty === 'http' && log.req?.method && log.req?.url && log.res?.statusCode && log.responseTime) {
+            this.messenger.publish('logs', JSON.stringify({
+                log: {
+                    level: log['level'],
+                    time: log['time'],
+                    msg: `${log.req.method} ${log.req.url} ${log.res.statusCode} ${log.responseTime}ms`,
+                },
+                nodeId: nodeId,
+            }));
+            return callback();
+        }
+        this.messenger.publish('logs', JSON.stringify({
+            log: {
+                level: log['level'],
+                time: log['time'],
+                msg: log['msg'],
+            },
+            nodeId: nodeId,
+        }));
+        callback();
+    }
+}

package/dist/middleware/respond.js

@@ -20,6 +20,7 @@ export const respond = asyncHandler(async (req, res) => {
         exceedsMaxSize = valueSize > maxSize;
     }
     if ((req.method.toLowerCase() === 'get' || req.originalUrl?.startsWith('/graphql')) &&
+        req.originalUrl?.startsWith('/auth') === false &&
         env['CACHE_ENABLED'] === true &&
         cache &&
         !req.sanitizedQuery.export &&

package/dist/request/is-denied-ip.js

@@ -1,5 +1,6 @@
 import { useEnv } from '@directus/env';
 import os from 'node:os';
+import { matches } from 'ip-matching';
 import { useLogger } from '../logger/index.js';
 import { ipInNetworks } from '../utils/ip-in-networks.js';
 export function isDeniedIp(ip) {
@@ -24,8 +25,13 @@ export function isDeniedIp(ip) {
             if (!networkInfo)
                 continue;
             for (const info of networkInfo) {
-                if (info.address === ip)
+                if (info.internal && info.cidr) {
+                    if (matches(ip, info.cidr))
+                        return true;
+                }
+                else if (info.address === ip) {
                     return true;
+                }
             }
         }
     }

package/dist/server.js

@@ -14,7 +14,7 @@ import { useLogger } from './logger/index.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { getIPFromReq } from './utils/get-ip-from-req.js';
 import { getAddress } from './utils/get-address.js';
-import { createSubscriptionController, createWebSocketController, getSubscriptionController, getWebSocketController, } from './websocket/controllers/index.js';
+import { createLogsController, createSubscriptionController, createWebSocketController, getLogsController, getSubscriptionController, getWebSocketController, } from './websocket/controllers/index.js';
 import { startWebSocketHandlers } from './websocket/handlers/index.js';
 export let SERVER_ONLINE = true;
 const env = useEnv();
@@ -77,6 +77,7 @@ export async function createServer() {
     if (toBoolean(env['WEBSOCKETS_ENABLED']) === true) {
         createSubscriptionController(server);
         createWebSocketController(server);
+        createLogsController(server);
         startWebSocketHandlers();
     }
     const terminusOptions = {
@@ -99,6 +100,7 @@ export async function createServer() {
     async function onSignal() {
         getSubscriptionController()?.terminate();
         getWebSocketController()?.terminate();
+        getLogsController()?.terminate();
         const database = getDatabase();
         await database.destroy();
         logger.info('Database connections destroyed');
@@ -126,7 +128,7 @@ export async function startServer() {
     else {
         listenOptions = {
             host,
-            port: parseInt(port || '8055'),
+            port: parseInt(port),
         };
     }
     server

package/dist/services/fields.js

@@ -5,7 +5,7 @@ import { createInspector } from '@directus/schema';
 import { addFieldFlag, toArray } from '@directus/utils';
 import { isEqual, isNil, merge } from 'lodash-es';
 import { clearSystemCache, getCache, getCacheValue, setCacheValue } from '../cache.js';
-import { ALIAS_TYPES } from '../constants.js';
+import { ALIAS_TYPES, ALLOWED_DB_DEFAULT_FUNCTIONS } from '../constants.js';
 import { translateDatabaseError } from '../database/errors/translate.js';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase, { getSchemaInspector } from '../database/index.js';
@@ -384,8 +384,16 @@ export class FieldsService {
             }
             if (hookAdjustedField.schema) {
                 const existingColumn = await this.columnInfo(collection, hookAdjustedField.field);
-                if (hookAdjustedField.schema?.is_nullable === true && existingColumn.is_primary_key) {
-                    throw new InvalidPayloadError({ reason: 'Primary key cannot be null' });
+                if (existingColumn.is_primary_key) {
+                    if (hookAdjustedField.schema?.is_nullable === true) {
+                        throw new InvalidPayloadError({ reason: 'Primary key cannot be null' });
+                    }
+                    if (hookAdjustedField.schema?.is_unique === false) {
+                        throw new InvalidPayloadError({ reason: 'Primary key must be unique' });
+                    }
+                    if (hookAdjustedField.schema?.is_indexed === true) {
+                        throw new InvalidPayloadError({ reason: 'Primary key cannot be indexed' });
+                    }
                 }
                 // Sanitize column only when applying snapshot diff as opts is only passed from /utils/apply-diff.ts
                 const columnToCompare = opts?.bypassLimits && opts.autoPurgeSystemCache === false ? sanitizeColumn(existingColumn) : existingColumn;
@@ -662,12 +670,12 @@ export class FieldsService {
         else {
             throw new InvalidPayloadError({ reason: `Illegal type passed: "${field.type}"` });
         }
-        const defaultValue = field.schema?.default_value !== undefined ? field.schema?.default_value : existing?.default_value;
-        if (defaultValue) {
+        const setDefaultValue = (defaultValue) => {
             const newDefaultValueIsString = typeof defaultValue === 'string';
             const newDefaultIsNowFunction = newDefaultValueIsString && defaultValue.toLowerCase() === 'now()';
             const newDefaultIsCurrentTimestamp = newDefaultValueIsString && defaultValue === 'CURRENT_TIMESTAMP';
             const newDefaultIsSetToCurrentTime = newDefaultIsNowFunction || newDefaultIsCurrentTimestamp;
+            const newDefaultIsAFunction = newDefaultValueIsString && ALLOWED_DB_DEFAULT_FUNCTIONS.includes(defaultValue);
             const newDefaultIsTimestampWithPrecision = newDefaultValueIsString && defaultValue.includes('CURRENT_TIMESTAMP(') && defaultValue.includes(')');
             if (newDefaultIsSetToCurrentTime) {
                 column.defaultTo(this.knex.fn.now());
@@ -676,31 +684,61 @@ export class FieldsService {
                 const precision = defaultValue.match(REGEX_BETWEEN_PARENS)[1];
                 column.defaultTo(this.knex.fn.now(Number(precision)));
             }
+            else if (newDefaultIsAFunction) {
+                column.defaultTo(this.knex.raw(defaultValue));
+            }
             else {
                 column.defaultTo(defaultValue);
             }
+        };
+        // for a new item, set the default value and nullable as provided without any further considerations
+        if (!existing) {
+            if (field.schema?.default_value !== undefined) {
+                setDefaultValue(field.schema.default_value);
+            }
+            if (field.schema?.is_nullable || field.schema?.is_nullable === undefined) {
+                column.nullable();
+            }
+            else {
+                column.notNullable();
+            }
         }
         else {
-            column.defaultTo(null);
-        }
-        const isNullable = field.schema?.is_nullable ?? existing?.is_nullable ?? true;
-        if (isNullable) {
-            column.nullable();
-        }
-        else {
-            column.notNullable();
+            // for an existing item: if nullable option changed, we have to provide the default values as well and actually vice versa
+            // see https://knexjs.org/guide/schema-builder.html#alter
+            // To overwrite a nullable option with the same value this is not possible for Oracle though, hence the DB helper
+            if (field.schema?.default_value !== undefined || field.schema?.is_nullable !== undefined) {
+                this.helpers.nullableUpdate.updateNullableValue(column, field, existing);
+                let defaultValue = null;
+                if (field.schema?.default_value !== undefined) {
+                    defaultValue = field.schema.default_value;
+                }
+                else if (existing.default_value !== undefined) {
+                    defaultValue = existing.default_value;
+                }
+                setDefaultValue(defaultValue);
+            }
         }
         if (field.schema?.is_primary_key) {
             column.primary().notNullable();
         }
-        else if (field.schema?.is_unique === true) {
-            if (!existing || existing.is_unique === false) {
-                column.unique();
+        else if (!existing?.is_primary_key) {
+            // primary key will already have unique/index constraints
+            if (field.schema?.is_unique === true) {
+                if (!existing || existing.is_unique === false) {
+                    column.unique();
+                }
             }
-        }
-        else if (field.schema?.is_unique === false) {
-            if (existing && existing.is_unique === true) {
-                table.dropUnique([field.field]);
+            else if (field.schema?.is_unique === false) {
+                if (existing && existing.is_unique === true) {
+                    table.dropUnique([field.field]);
+                }
+            }
+            if (field.schema?.is_indexed === true && !existing?.is_indexed) {
+                column.index();
+            }
+            else if (field.schema?.is_indexed === false && existing?.is_indexed) {
+                table.dropIndex([field.field]);
             }
         }
         if (existing) {

package/dist/services/mail/index.js

@@ -36,11 +36,7 @@ export class MailService {
         }
     }
     async send(options) {
-        const payload = await emitter.emitFilter(`email.send`, options, {
-            database: getDatabase(),
-            schema: null,
-            accountability: null,
-        });
+        const payload = await emitter.emitFilter(`email.send`, options, {});
         if (!payload)
             return null;
         const { template, ...emailOptions } = payload;

package/dist/services/notifications.d.ts

@@ -1,11 +1,7 @@
 import type { Notification, PrimaryKey } from '@directus/types';
 import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
-import { MailService } from './mail/index.js';
-import { UsersService } from './users.js';
 export declare class NotificationsService extends ItemsService {
-    usersService: UsersService;
-    mailService: MailService;
     constructor(options: AbstractServiceOptions);
     createOne(data: Partial<Notification>, opts?: MutationOptions): Promise<PrimaryKey>;
     sendEmail(data: Partial<Notification>): Promise<void>;

package/dist/services/notifications.js

@@ -10,12 +10,8 @@ import { UsersService } from './users.js';
 const env = useEnv();
 const logger = useLogger();
 export class NotificationsService extends ItemsService {
-    usersService;
-    mailService;
     constructor(options) {
         super('directus_notifications', options);
-        this.usersService = new UsersService({ schema: this.schema });
-        this.mailService = new MailService({ schema: this.schema, accountability: this.accountability });
     }
     async createOne(data, opts) {
         const response = await super.createOne(data, opts);
@@ -24,7 +20,8 @@ export class NotificationsService extends ItemsService {
     }
     async sendEmail(data) {
         if (data.recipient) {
-            const user = await this.usersService.readOne(data.recipient, {
+            const usersService = new UsersService({ schema: this.schema, knex: this.knex });
+            const user = await usersService.readOne(data.recipient, {
                 fields: ['id', 'email', 'email_notifications', 'role'],
             });
             if (user['email'] && user['email_notifications'] === true) {
@@ -38,7 +35,12 @@ export class NotificationsService extends ItemsService {
                     roles,
                     ip: null,
                 }, this.knex);
-                this.mailService
+                const mailService = new MailService({
+                    schema: this.schema,
+                    knex: this.knex,
+                    accountability: this.accountability,
+                });
+                mailService
                     .send({
                     template: {
                         name: 'base',

package/dist/services/server.js

@@ -5,6 +5,7 @@ import { merge } from 'lodash-es';
 import { Readable } from 'node:stream';
 import { performance } from 'perf_hooks';
 import { getCache } from '../cache.js';
+import { RESUMABLE_UPLOADS } from '../constants.js';
 import getDatabase, { hasDatabaseConnection } from '../database/index.js';
 import { useLogger } from '../logger/index.js';
 import getMailer from '../mailer.js';
@@ -12,8 +13,8 @@ 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 { getAllowedLogLevels } from '../utils/get-allowed-log-levels.js';
 import { SettingsService } from './settings.js';
-import { RESUMABLE_UPLOADS } from '../constants.js';
 const env = useEnv();
 const logger = useLogger();
 export class ServerService {
@@ -95,6 +96,12 @@ export class ServerService {
                 info['websocket'].heartbeat = toBoolean(env['WEBSOCKETS_HEARTBEAT_ENABLED'])
                     ? env['WEBSOCKETS_HEARTBEAT_PERIOD']
                     : false;
+                info['websocket'].logs =
+                    toBoolean(env['WEBSOCKETS_LOGS_ENABLED']) && this.accountability.admin
+                        ? {
+                            allowedLogLevels: getAllowedLogLevels(env['WEBSOCKETS_LOGS_LEVEL'] || 'info'),
+                        }
+                        : false;
             }
             else {
                 info['websocket'] = false;

package/dist/services/specifications.js

@@ -37,20 +37,20 @@ class OASSpecsService {
         this.schema = options.schema;
     }
     async generate(host) {
-        let schema = this.schema;
+        let schemaForSpec = this.schema;
         let permissions = [];
         if (this.accountability && this.accountability.admin !== true) {
             const allowedFields = await fetchAllowedFieldMap({
                 accountability: this.accountability,
                 action: 'read',
-            }, { schema, knex: this.knex });
-            schema = reduceSchema(schema, allowedFields);
-            const policies = await fetchPolicies(this.accountability, { schema, knex: this.knex });
-            permissions = await fetchPermissions({ action: 'read', policies, accountability: this.accountability }, { schema, knex: this.knex });
+            }, { schema: this.schema, knex: this.knex });
+            schemaForSpec = reduceSchema(this.schema, allowedFields);
+            const policies = await fetchPolicies(this.accountability, { schema: this.schema, knex: this.knex });
+            permissions = await fetchPermissions({ policies, accountability: this.accountability }, { schema: this.schema, knex: this.knex });
         }
-        const tags = await this.generateTags(schema);
+        const tags = await this.generateTags(schemaForSpec);
         const paths = await this.generatePaths(permissions, tags);
-        const components = await this.generateComponents(schema, tags);
+        const components = await this.generateComponents(schemaForSpec, tags);
         const isDefaultPublicUrl = env['PUBLIC_URL'] === '/';
         const url = isDefaultPublicUrl && host ? host : env['PUBLIC_URL'];
         const spec = {

package/dist/services/users.js

@@ -102,7 +102,10 @@ export class UsersService extends ItemsService {
      */
     inviteUrl(email, url) {
         const payload = { email, scope: 'invite' };
-        const token = jwt.sign(payload, getSecret(), { expiresIn: '7d', issuer: 'directus' });
+        const token = jwt.sign(payload, getSecret(), {
+            expiresIn: env['USER_INVITE_TOKEN_TTL'],
+            issuer: 'directus',
+        });
         return (url ? new Url(url) : new Url(env['PUBLIC_URL']).addPath('admin', 'accept-invite'))
             .setQuery('token', token)
             .toString();

package/dist/utils/get-address.d.ts

@@ -2,4 +2,4 @@
 /// <reference types="node/http.js" />
 /// <reference types="pino-http" />
 import * as http from 'http';
-export declare function getAddress(server: http.Server): string | undefined;
+export declare function getAddress(server: http.Server): {};

package/dist/utils/get-address.js

@@ -1,9 +1,14 @@
 import * as http from 'http';
+import { useEnv } from '@directus/env';
 export function getAddress(server) {
+    const env = useEnv();
     const address = server.address();
     if (address === null) {
         // Before the 'listening' event has been emitted or after calling server.close()
-        return;
+        if (env['UNIX_SOCKET_PATH']) {
+            return env['UNIX_SOCKET_PATH'];
+        }
+        return `${env['HOST']}:${env['PORT']}`;
     }
     if (typeof address === 'string') {
         // unix path

package/dist/utils/get-allowed-log-levels.d.ts

@@ -0,0 +1,3 @@
+export declare const getAllowedLogLevels: (level: string) => {
+    [k: string]: number;
+};

package/dist/utils/get-allowed-log-levels.js

@@ -0,0 +1,11 @@
+import { useLogger } from '../logger/index.js';
+const logger = useLogger();
+export const getAllowedLogLevels = (level) => {
+    const levelValue = logger.levels.values[level];
+    if (levelValue === undefined) {
+        throw new Error(`Invalid "${level}" log level`);
+    }
+    return Object.fromEntries(Object.entries(logger.levels.values)
+        .filter(([_, value]) => value >= levelValue)
+        .sort((a, b) => a[1] - b[1]));
+};

package/dist/utils/get-schema.js

@@ -4,7 +4,7 @@ import { systemCollectionRows } from '@directus/system-data';
 import { parseJSON, toArray } from '@directus/utils';
 import { mapValues } from 'lodash-es';
 import { useBus } from '../bus/index.js';
-import { getSchemaCache, setSchemaCache } from '../cache.js';
+import { getLocalSchemaCache, setLocalSchemaCache } from '../cache.js';
 import { ALIAS_TYPES } from '../constants.js';
 import getDatabase from '../database/index.js';
 import { useLock } from '../lock/index.js';
@@ -22,7 +22,7 @@ export async function getSchema(options, attempt = 0) {
         const schemaInspector = createInspector(database);
         return await getDatabaseSchema(database, schemaInspector);
     }
-    const cached = await getSchemaCache();
+    const cached = await getLocalSchemaCache();
     if (cached) {
         return cached;
     }
@@ -40,39 +40,34 @@ export async function getSchema(options, attempt = 0) {
     const currentProcessShouldHandleOperation = processId === 1;
     if (currentProcessShouldHandleOperation === false) {
         logger.trace('Schema cache is prepared in another process, waiting for result.');
-        return new Promise((resolve, reject) => {
-            const TIMEOUT = 10000;
-            const timeout = setTimeout(() => {
-                logger.trace('Did not receive schema callback message in time. Pulling schema...');
-                callback().catch(reject);
-            }, TIMEOUT);
-            bus.subscribe(messageKey, callback);
-            async function callback() {
-                try {
-                    if (timeout)
-                        clearTimeout(timeout);
-                    const schema = await getSchema(options, attempt + 1);
-                    resolve(schema);
-                }
-                catch (error) {
-                    reject(error);
-                }
-                finally {
-                    bus.unsubscribe(messageKey, callback);
+        const timeout = new Promise((_, reject) => setTimeout(reject, env['CACHE_SCHEMA_SYNC_TIMEOUT']));
+        const subscription = new Promise((resolve, reject) => {
+            bus.subscribe(messageKey, busListener).catch(reject);
+            function busListener(options) {
+                if (options.schema === null) {
+                    return reject();
                 }
+                cleanup();
+                setLocalSchemaCache(options.schema).catch(reject);
+                resolve(options.schema);
+            }
+            function cleanup() {
+                bus.unsubscribe(messageKey, busListener).catch(reject);
             }
         });
+        return Promise.race([timeout, subscription]).catch(() => getSchema(options, attempt + 1));
     }
+    let schema = null;
     try {
         const database = options?.database || getDatabase();
         const schemaInspector = createInspector(database);
-        const schema = await getDatabaseSchema(database, schemaInspector);
-        await setSchemaCache(schema);
+        schema = await getDatabaseSchema(database, schemaInspector);
+        await setLocalSchemaCache(schema);
         return schema;
     }
     finally {
+        await bus.publish(messageKey, { schema });
         await lock.delete(lockKey);
-        bus.publish(messageKey, { ready: true });
     }
 }
 async function getDatabaseSchema(database, schemaInspector) {

package/dist/utils/parse-filter-key.js

@@ -13,10 +13,6 @@ export function parseFilterKey(key) {
     const match = key.match(FILTER_KEY_REGEX);
     const fieldNameWithFunction = match?.[3]?.trim();
     const fieldName = fieldNameWithFunction || key.trim();
-    let functionName;
-    if (fieldNameWithFunction) {
-        functionName = match?.[1]?.trim();
-        return { fieldName, functionName };
-    }
+    const functionName = fieldNameWithFunction ? match?.[1]?.trim() : undefined;
     return { fieldName, functionName };
 }