@directus/api 22.1.1 → 23.0.0

package/dist/server.d.ts

@@ -1,6 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node/http.js" />
-/// <reference types="pino-http" />
 import * as http from 'http';
 export declare let SERVER_ONLINE: boolean;
 export declare function createServer(): Promise<http.Server>;

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/assets.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { Range, Stat } from '@directus/storage';
 import type { Accountability, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';

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,10 @@ 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' });
+                    }
                 }
                 // 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 +664,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 +678,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/files/utils/get-metadata.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { File } from '@directus/types';
 import type { Readable } from 'node:stream';
 export type Metadata = Partial<Pick<File, 'height' | 'width' | 'description' | 'title' | 'tags' | 'metadata'>>;

package/dist/services/files/utils/parse-image-metadata.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="node" resolution-mode="require"/>
 export declare function parseIptc(buffer: Buffer): Record<string, unknown>;
 export declare function parseXmp(buffer: Buffer): Record<string, unknown>;

package/dist/services/files.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { BusboyFileStream, File, PrimaryKey, Query } from '@directus/types';
 import type { Readable } from 'node:stream';
 import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';

package/dist/services/import-export.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { Accountability, File, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { Readable } from 'node:stream';

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/tus/data-store.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { TusDriver } from '@directus/storage';
 import type { Accountability, File, SchemaOverview } from '@directus/types';
 import stream from 'node:stream';

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();
@@ -370,7 +373,7 @@ export class UsersService extends ItemsService {
             await this.createOne(partialUser);
         }
         // We want to be able to re-send the verification email
-        else if (user.status !== ('unverified')) {
+        else if (user.status !== 'unverified') {
             // To avoid giving attackers infos about registered emails we dont fail for violated unique constraints
             await stall(STALL_TIME, timeStart);
             return;
@@ -412,7 +415,7 @@ export class UsersService extends ItemsService {
         if (scope !== 'pending-registration')
             throw new ForbiddenError();
         const user = await this.getUserByEmail(email);
-        if (user?.status !== ('unverified')) {
+        if (user?.status !== 'unverified') {
             throw new InvalidPayloadError({ reason: 'Invalid verification code' });
         }
         await this.updateOne(user.id, { status: 'active' });

package/dist/types/graphql.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="cookie-parser" />
 import type { Request, Response } from 'express';
 import type { DocumentNode } from 'graphql';
 export interface GraphQLParams {

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

@@ -1,7 +1,7 @@
 import type { Aggregate, Filter, Permission, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { AliasMap } from './get-column-path.js';
-export declare const generateAlias: (size?: number | undefined) => string;
+export declare const generateAlias: (size?: number) => string;
 type ApplyQueryOptions = {
     aliasMap?: AliasMap;
     isInnerQuery?: boolean;

package/dist/utils/compress.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="node" resolution-mode="require"/>
 export declare function compress(raw: Record<string, any> | Record<string, any>[]): Promise<Buffer>;
 export declare function decompress(compressed: Buffer): Promise<any>;

package/dist/utils/delete-from-require-cache.js

@@ -7,7 +7,7 @@ export function deleteFromRequireCache(modulePath) {
         const moduleCachePath = require.resolve(modulePath);
         delete require.cache[moduleCachePath];
     }
-    catch (error) {
+    catch {
         logger.trace(`Module cache not found for ${modulePath}, skipped cache delete.`);
     }
 }

package/dist/utils/fetch-user-count/fetch-user-count.d.ts

@@ -1,6 +1,5 @@
 import { type FetchAccessLookupOptions } from './fetch-access-lookup.js';
-export interface FetchUserCountOptions extends FetchAccessLookupOptions {
-}
+export type FetchUserCountOptions = FetchAccessLookupOptions;
 export interface UserCount {
     admin: number;
     app: number;

package/dist/utils/generate-hash.js

@@ -3,7 +3,7 @@ import { getConfigFromEnv } from './get-config-from-env.js';
 export function generateHash(stringToHash) {
     const argon2HashConfigOptions = getConfigFromEnv('HASH_', 'HASH_RAW'); // Disallow the HASH_RAW option, see https://github.com/directus/directus/discussions/7670#discussioncomment-1255805
     // associatedData, if specified, must be passed as a Buffer to argon2.hash, see https://github.com/ranisalt/node-argon2/wiki/Options#associateddata
-    'associatedData' in argon2HashConfigOptions &&
-        (argon2HashConfigOptions['associatedData'] = Buffer.from(argon2HashConfigOptions['associatedData']));
+    if ('associatedData' in argon2HashConfigOptions)
+        argon2HashConfigOptions['associatedData'] = Buffer.from(argon2HashConfigOptions['associatedData']);
     return argon2.hash(stringToHash, argon2HashConfigOptions);
 }

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

@@ -1,5 +1,2 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <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-cache-headers.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="cookie-parser" />
 import type { Request } from 'express';
 /**
  * Returns the Cache-Control header for the current request

package/dist/utils/get-cache-key.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="cookie-parser" />
 import type { Request } from 'express';
 export declare function getCacheKey(req: Request): Promise<string>;

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

@@ -21,5 +21,5 @@ type GetColumnOptions = OriginalCollectionName | (FunctionColumnOptions & Origin
  * @param options Optional parameters
  * @returns Knex raw instance
  */
-export declare function getColumn(knex: Knex, table: string, column: string, alias: string | false | undefined, schema: SchemaOverview, options?: GetColumnOptions): Knex.Raw;
+export declare function getColumn(knex: Knex, table: string, column: string, alias: (string | false) | undefined, schema: SchemaOverview, options?: GetColumnOptions): Knex.Raw;
 export {};

package/dist/utils/get-graphql-query-and-variables.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="cookie-parser" />
 import type { Request } from 'express';
 export declare function getGraphqlQueryAndVariables(req: Request): Pick<any, "query" | "variables">;

package/dist/utils/get-ip-from-req.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="cookie-parser" />
 import type { Request } from 'express';
 export declare function getIPFromReq(req: Request): string | null;

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/get-snapshot.js

@@ -49,7 +49,7 @@ function sortDeep(raw) {
         return fromPairs(sorted);
     }
     if (isArray(raw)) {
-        return sortBy(raw);
+        return raw.map((raw) => sortDeep(raw));
     }
     return raw;
 }

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 };
 }

package/dist/utils/sanitize-query.js

@@ -192,7 +192,7 @@ function sanitizeAlias(rawAlias) {
         try {
             alias = parseJSON(rawAlias);
         }
-        catch (err) {
+        catch {
             logger.warn('Invalid value passed for alias query parameter.');
         }
     }

package/dist/utils/sanitize-schema.d.ts

@@ -16,7 +16,7 @@ export declare function sanitizeCollection(collection: Collection | undefined):
  * @returns sanitized field
  */
 export declare function sanitizeField(field: Field | undefined, sanitizeAllSchema?: boolean): Partial<Field> | undefined;
-export declare function sanitizeColumn(column: Column): Pick<Column, "table" | "name" | "numeric_precision" | "numeric_scale" | "data_type" | "default_value" | "max_length" | "is_nullable" | "is_unique" | "is_primary_key" | "is_generated" | "generation_expression" | "has_auto_increment" | "foreign_key_table" | "foreign_key_column">;
+export declare function sanitizeColumn(column: Column): Pick<Column, "table" | "name" | "numeric_precision" | "data_type" | "default_value" | "max_length" | "numeric_scale" | "is_nullable" | "is_unique" | "is_primary_key" | "is_generated" | "generation_expression" | "has_auto_increment" | "foreign_key_table" | "foreign_key_column">;
 /**
  * Pick certain database vendor specific relation properties that should be compared when performing diff
  *

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

@@ -1,4 +1,3 @@
-/// <reference types="cookie-parser" />
 import type { Request } from 'express';
 /**
  * Whether to skip caching for the current request

package/dist/websocket/authenticate.js

@@ -28,7 +28,7 @@ export async function authenticateConnection(message) {
         const expires_at = getExpiresAtForToken(access_token);
         return { accountability, expires_at, refresh_token };
     }
-    catch (error) {
+    catch {
         throw new WebSocketError('auth', 'AUTH_FAILED', 'Authentication failed.', message['uid']);
     }
 }