@directus/api 22.1.0 → 22.2.0

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;
@@ -621,7 +629,7 @@ export class FieldsService {
             }
         }
     }
-    addColumnToTable(table, field, alter = null) {
+    addColumnToTable(table, field, existing = null) {
         let column;
         // Don't attempt to add a DB column for alias / corrupt fields
         if (field.type === 'alias' || field.type === 'unknown')
@@ -662,45 +670,78 @@ export class FieldsService {
         else {
             throw new InvalidPayloadError({ reason: `Illegal type passed: "${field.type}"` });
         }
-        if (field.schema?.default_value !== undefined) {
-            if (typeof field.schema.default_value === 'string' &&
-                (field.schema.default_value.toLowerCase() === 'now()' || field.schema.default_value === 'CURRENT_TIMESTAMP')) {
+        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());
             }
-            else if (typeof field.schema.default_value === 'string' &&
-                field.schema.default_value.includes('CURRENT_TIMESTAMP(') &&
-                field.schema.default_value.includes(')')) {
-                const precision = field.schema.default_value.match(REGEX_BETWEEN_PARENS)[1];
+            else if (newDefaultIsTimestampWithPrecision) {
+                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(field.schema.default_value);
+                column.defaultTo(defaultValue);
             }
-        }
-        if (field.schema?.is_nullable === false) {
-            if (!alter || alter.is_nullable === true) {
+        };
+        // 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 {
-            if (!alter || alter.is_nullable === false) {
-                column.nullable();
+            // 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 (!alter || alter.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 (alter && alter.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 (alter) {
+        if (existing) {
             column.alter();
         }
     }

package/dist/services/import-export.js

@@ -133,6 +133,8 @@ export class ImportService {
             };
             const PapaOptions = {
                 header: true,
+                // Trim whitespaces in headers, including the byte order mark (BOM) zero-width no-break space
+                transformHeader: (header) => header.trim(),
                 transform,
             };
             return new Promise((resolve, reject) => {
@@ -304,7 +306,6 @@ export class ExportService {
             const savedFile = await filesService.uploadOne(createReadStream(tmpFile.path), fileWithDefaults);
             if (this.accountability?.user) {
                 const notificationsService = new NotificationsService({
-                    accountability: this.accountability,
                     schema: this.schema,
                 });
                 const usersService = new UsersService({
@@ -333,7 +334,6 @@ Your export of ${collection} is ready. <a href="${href}">Click here to view.</a>
             logger.error(err, `Couldn't export ${collection}: ${err.message}`);
             if (this.accountability?.user) {
                 const notificationsService = new NotificationsService({
-                    accountability: this.accountability,
                     schema: this.schema,
                 });
                 await notificationsService.createOne({

package/dist/services/items.js

@@ -370,7 +370,7 @@ export class ItemsService {
             knex: this.knex,
         });
         ast = await processAst({ ast, action: 'read', accountability: this.accountability }, { knex: this.knex, schema: this.schema });
-        const records = await runAst(ast, this.schema, {
+        const records = await runAst(ast, this.schema, this.accountability, {
             knex: this.knex,
             // GraphQL requires relational keys to be returned regardless
             stripNonRequested: opts?.stripNonRequested !== undefined ? opts.stripNonRequested : true,

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/meta.js

@@ -45,14 +45,14 @@ export class MetaService {
                 action: 'read',
                 policies,
                 accountability: this.accountability,
-                ...(collection ? { collections: [collection] } : {}),
             }, context);
-            const rules = dedupeAccess(permissions);
+            const collectionPermissions = permissions.filter((permission) => permission.collection === collection);
+            const rules = dedupeAccess(collectionPermissions);
             const cases = rules.map(({ rule }) => rule);
             const filter = {
                 _or: cases,
             };
-            const result = applyFilter(this.knex, this.schema, dbQuery, filter, collection, {}, cases);
+            const result = applyFilter(this.knex, this.schema, dbQuery, filter, collection, {}, cases, permissions);
             hasJoins = result.hasJoins;
         }
         if (hasJoins) {
@@ -70,6 +70,7 @@ export class MetaService {
         let filter = query.filter || {};
         let hasJoins = false;
         let cases = [];
+        let permissions = [];
         if (this.accountability && this.accountability.admin === false) {
             const context = { knex: this.knex, schema: this.schema };
             await validateAccess({
@@ -78,13 +79,13 @@ export class MetaService {
                 collection,
             }, context);
             const policies = await fetchPolicies(this.accountability, context);
-            const permissions = await fetchPermissions({
+            permissions = await fetchPermissions({
                 action: 'read',
                 policies,
                 accountability: this.accountability,
-                ...(collection ? { collections: [collection] } : {}),
             }, context);
-            const rules = dedupeAccess(permissions);
+            const collectionPermissions = permissions.filter((permission) => permission.collection === collection);
+            const rules = dedupeAccess(collectionPermissions);
             cases = rules.map(({ rule }) => rule);
             const permissionsFilter = {
                 _or: cases,
@@ -97,7 +98,7 @@ export class MetaService {
             }
         }
         if (Object.keys(filter).length > 0) {
-            ({ hasJoins } = applyFilter(this.knex, this.schema, dbQuery, filter, collection, {}, cases));
+            ({ hasJoins } = applyFilter(this.knex, this.schema, dbQuery, filter, collection, {}, cases, permissions));
         }
         if (query.search) {
             applySearch(this.knex, this.schema, dbQuery, query.search, collection);

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/permissions.js

@@ -1,5 +1,8 @@
 import { ForbiddenError } from '@directus/errors';
+import { uniq } from 'lodash-es';
 import { clearSystemCache } from '../cache.js';
+import { fetchPermissions } from '../permissions/lib/fetch-permissions.js';
+import { fetchPolicies } from '../permissions/lib/fetch-policies.js';
 import { withAppMinimalPermissions } from '../permissions/lib/with-app-minimal-permissions.js';
 import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
 import { ItemsService } from './items.js';
@@ -105,27 +108,24 @@ export class PermissionsService extends ItemsService {
                 .catch(() => { });
         }));
         if (schema?.singleton && itemPermissions.update.access) {
-            const query = {
-                filter: {
-                    _and: [
-                        ...(this.accountability?.role ? [{ role: { _eq: this.accountability.role } }] : []),
-                        { collection: { _eq: collection } },
-                        { action: { _eq: updateAction } },
-                    ],
-                },
-                fields: ['presets', 'fields'],
-            };
-            try {
-                const result = await this.readByQuery(query);
-                const permission = result[0];
-                if (permission) {
-                    itemPermissions.update.presets = permission['presets'];
-                    itemPermissions.update.fields = permission['fields'];
+            const context = { schema: this.schema, knex: this.knex };
+            const policies = await fetchPolicies(this.accountability, context);
+            const permissions = await fetchPermissions({ policies, accountability: this.accountability, action: updateAction, collections: [collection] }, context);
+            let fields = [];
+            let presets = {};
+            for (const permission of permissions) {
+                if (permission.fields && fields[0] !== '*') {
+                    fields = uniq([...fields, ...permission.fields]);
+                    if (fields.includes('*')) {
+                        fields = ['*'];
+                    }
+                }
+                if (permission.presets) {
+                    presets = { ...(presets ?? {}), ...permission.presets };
                 }
             }
-            catch {
-                // No permission
-            }
+            itemPermissions.update.fields = fields;
+            itemPermissions.update.presets = presets;
         }
         return itemPermissions;
     }

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

@@ -1,4 +1,4 @@
-import type { Aggregate, Filter, Query, SchemaOverview } from '@directus/types';
+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;
@@ -11,7 +11,7 @@ type ApplyQueryOptions = {
 /**
  * Apply the Query to a given Knex query builder instance
  */
-export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, cases: Filter[], options?: ApplyQueryOptions): {
+export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, cases: Filter[], permissions: Permission[], options?: ApplyQueryOptions): {
     query: Knex.QueryBuilder<any, any>;
     hasJoins: boolean;
     hasMultiRelationalFilter: boolean;
@@ -34,7 +34,7 @@ export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery:
 };
 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, cases: Filter[]): {
+export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootFilter: Filter, collection: string, aliasMap: AliasMap, cases: Filter[], permissions: Permission[]): {
     query: Knex.QueryBuilder<any, any>;
     hasJoins: boolean;
     hasMultiRelationalFilter: boolean;

package/dist/utils/apply-query.js

@@ -5,6 +5,7 @@ import { clone, isPlainObject } from 'lodash-es';
 import { customAlphabet } from 'nanoid/non-secure';
 import { getHelpers } from '../database/helpers/index.js';
 import { applyCaseWhen } from '../database/run-ast/utils/apply-case-when.js';
+import { getCases } from '../permissions/modules/process-ast/lib/get-cases.js';
 import { getColumnPath } from './get-column-path.js';
 import { getColumn } from './get-column.js';
 import { getRelationInfo } from './get-relation-info.js';
@@ -15,7 +16,7 @@ export const generateAlias = customAlphabet('abcdefghijklmnopqrstuvwxyz', 5);
 /**
  * Apply the Query to a given Knex query builder instance
  */
-export default function applyQuery(knex, collection, dbQuery, query, schema, cases, options) {
+export default function applyQuery(knex, collection, dbQuery, query, schema, cases, permissions, options) {
     const aliasMap = options?.aliasMap ?? Object.create(null);
     let hasJoins = false;
     let hasMultiRelationalFilter = false;
@@ -42,7 +43,7 @@ export default function applyQuery(knex, collection, dbQuery, query, schema, cas
     // you're actually allowed to read
     const filter = joinFilterWithCases(query.filter, cases);
     if (filter) {
-        const filterResult = applyFilter(knex, schema, dbQuery, filter, collection, aliasMap, cases);
+        const filterResult = applyFilter(knex, schema, dbQuery, filter, collection, aliasMap, cases, permissions);
         if (!hasJoins) {
             hasJoins = filterResult.hasJoins;
         }
@@ -58,6 +59,7 @@ export default function applyQuery(knex, collection, dbQuery, query, schema, cas
                 aliasMap,
                 cases,
                 table: collection,
+                permissions,
             }, {
                 knex,
                 schema,
@@ -261,7 +263,7 @@ export function applyOffset(knex, rootQuery, offset) {
         getHelpers(knex).schema.applyOffset(rootQuery, offset);
     }
 }
-export function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap, cases) {
+export function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap, cases, permissions) {
     const helpers = getHelpers(knex);
     const relations = schema.relations;
     let hasJoins = false;
@@ -349,24 +351,27 @@ export function applyFilter(knex, schema, rootQuery, rootFilter, collection, ali
                     if (relationType === 'o2a') {
                         pkField = knex.raw(getHelpers(knex).schema.castA2oPrimaryKey(), [pkField]);
                     }
-                    const subQueryBuilder = (filter) => (subQueryKnex) => {
-                        const field = relation.field;
-                        const collection = relation.collection;
-                        const column = `${collection}.${field}`;
-                        subQueryKnex
-                            .select({ [field]: column })
-                            .from(collection)
-                            .whereNotNull(column);
-                        applyQuery(knex, relation.collection, subQueryKnex, { filter }, schema, cases);
-                    };
                     const childKey = Object.keys(value)?.[0];
-                    if (childKey === '_none') {
-                        dbQuery[logical].whereNotIn(pkField, subQueryBuilder(Object.values(value)[0]));
-                        continue;
-                    }
-                    else if (childKey === '_some') {
-                        dbQuery[logical].whereIn(pkField, subQueryBuilder(Object.values(value)[0]));
-                        continue;
+                    if (childKey === '_none' || childKey === '_some') {
+                        const subQueryBuilder = (filter, cases) => (subQueryKnex) => {
+                            const field = relation.field;
+                            const collection = relation.collection;
+                            const column = `${collection}.${field}`;
+                            subQueryKnex
+                                .select({ [field]: column })
+                                .from(collection)
+                                .whereNotNull(column);
+                            applyQuery(knex, relation.collection, subQueryKnex, { filter }, schema, cases, permissions);
+                        };
+                        const { cases: subCases } = getCases(relation.collection, permissions, []);
+                        if (childKey === '_none') {
+                            dbQuery[logical].whereNotIn(pkField, subQueryBuilder(Object.values(value)[0], subCases));
+                            continue;
+                        }
+                        else if (childKey === '_some') {
+                            dbQuery[logical].whereIn(pkField, subQueryBuilder(Object.values(value)[0], subCases));
+                            continue;
+                        }
                     }
                 }
                 if (filterPath.includes('_none') || filterPath.includes('_some')) {

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-column.d.ts

@@ -1,10 +1,14 @@
-import type { Filter, Query, SchemaOverview } from '@directus/types';
+import type { Filter, Permission, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
-type GetColumnOptions = {
-    query?: Query | undefined;
-    cases?: Filter[];
+type FunctionColumnOptions = {
+    query: Query;
+    cases: Filter[];
+    permissions: Permission[];
+};
+type OriginalCollectionName = {
     originalCollectionName?: string | undefined;
 };
+type GetColumnOptions = OriginalCollectionName | (FunctionColumnOptions & OriginalCollectionName);
 /**
  * Return column prefixed by table. If column includes functions (like `year(date_created)`), the
  * column is replaced with the appropriate SQL

package/dist/utils/get-column.js

@@ -29,8 +29,13 @@ export function getColumn(knex, table, column, alias = applyFunctionToColumnName
             }
             const result = fn[functionName](table, columnName, {
                 type,
-                query: options?.query,
-                cases: options?.cases,
+                relationalCountOptions: isFunctionColumnOptions(options)
+                    ? {
+                        query: options.query,
+                        cases: options.cases,
+                        permissions: options.permissions,
+                    }
+                    : undefined,
                 originalCollectionName: options?.originalCollectionName,
             });
             if (alias) {
@@ -47,3 +52,6 @@ export function getColumn(knex, table, column, alias = applyFunctionToColumnName
     }
     return knex.ref(`${table}.${column}`);
 }
+function isFunctionColumnOptions(options) {
+    return !!options && 'query' in options;
+}