@directus/api 19.0.1 → 19.1.0

package/dist/app.js

@@ -58,20 +58,13 @@ import schema from './middleware/schema.js';
 import { initTelemetry } from './telemetry/index.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { Url } from './utils/url.js';
-import { validateEnv } from './utils/validate-env.js';
 import { validateStorage } from './utils/validate-storage.js';
 const require = createRequire(import.meta.url);
 export default async function createApp() {
     const env = useEnv();
     const logger = useLogger();
     const helmet = await import('helmet');
-    validateEnv(['KEY', 'SECRET']);
-    if (!new Url(env['PUBLIC_URL']).isAbsolute()) {
-        logger.warn('PUBLIC_URL should be a full URL');
-    }
-    await validateStorage();
     await validateDatabaseConnection();
-    await validateDatabaseExtensions();
     if ((await isInstalled()) === false) {
         logger.error(`Database doesn't have Directus tables installed.`);
         process.exit(1);
@@ -79,6 +72,14 @@ export default async function createApp() {
     if ((await validateMigrations()) === false) {
         logger.warn(`Database migrations have not all been run`);
     }
+    if (!env['SECRET']) {
+        logger.warn(`"SECRET" env variable is missing. Using a random value instead. Tokens will not persist between restarts. This is not appropriate for production usage.`);
+    }
+    if (!new Url(env['PUBLIC_URL']).isAbsolute()) {
+        logger.warn('"PUBLIC_URL" should be a full URL');
+    }
+    await validateDatabaseExtensions();
+    await validateStorage();
     await registerAuthProviders();
     const extensionManager = getExtensionManager();
     const flowManager = getFlowManager();

package/dist/auth/drivers/oauth2.js

@@ -19,6 +19,7 @@ import { getIPFromReq } from '../../utils/get-ip-from-req.js';
 import { isLoginRedirectAllowed } from '../../utils/is-login-redirect-allowed.js';
 import { Url } from '../../utils/url.js';
 import { LocalAuthDriver } from './local.js';
+import { getSecret } from '../../utils/get-secret.js';
 export class OAuth2AuthDriver extends LocalAuthDriver {
     client;
     redirectUrl;
@@ -224,7 +225,7 @@ export function createOAuth2AuthRouter(providerName) {
         if (isLoginRedirectAllowed(redirect, providerName) === false) {
             throw new InvalidPayloadError({ reason: `URL "${redirect}" can't be used to redirect after login` });
         }
-        const token = jwt.sign({ verifier: codeVerifier, redirect, prompt }, env['SECRET'], {
+        const token = jwt.sign({ verifier: codeVerifier, redirect, prompt }, getSecret(), {
             expiresIn: '5m',
             issuer: 'directus',
         });
@@ -241,7 +242,7 @@ export function createOAuth2AuthRouter(providerName) {
         const logger = useLogger();
         let tokenData;
         try {
-            tokenData = jwt.verify(req.cookies[`oauth2.${providerName}`], env['SECRET'], {
+            tokenData = jwt.verify(req.cookies[`oauth2.${providerName}`], getSecret(), {
                 issuer: 'directus',
             });
         }

package/dist/auth/drivers/openid.js

@@ -16,6 +16,7 @@ import { UsersService } from '../../services/users.js';
 import asyncHandler from '../../utils/async-handler.js';
 import { getConfigFromEnv } from '../../utils/get-config-from-env.js';
 import { getIPFromReq } from '../../utils/get-ip-from-req.js';
+import { getSecret } from '../../utils/get-secret.js';
 import { isLoginRedirectAllowed } from '../../utils/is-login-redirect-allowed.js';
 import { Url } from '../../utils/url.js';
 import { LocalAuthDriver } from './local.js';
@@ -245,7 +246,7 @@ export function createOpenIDAuthRouter(providerName) {
         if (isLoginRedirectAllowed(redirect, providerName) === false) {
             throw new InvalidPayloadError({ reason: `URL "${redirect}" can't be used to redirect after login` });
         }
-        const token = jwt.sign({ verifier: codeVerifier, redirect, prompt }, env['SECRET'], {
+        const token = jwt.sign({ verifier: codeVerifier, redirect, prompt }, getSecret(), {
             expiresIn: '5m',
             issuer: 'directus',
         });
@@ -262,7 +263,7 @@ export function createOpenIDAuthRouter(providerName) {
         const logger = useLogger();
         let tokenData;
         try {
-            tokenData = jwt.verify(req.cookies[`openid.${providerName}`], env['SECRET'], {
+            tokenData = jwt.verify(req.cookies[`openid.${providerName}`], getSecret(), {
                 issuer: 'directus',
             });
         }

package/dist/cli/utils/create-env/env-stub.liquid

@@ -195,9 +195,6 @@ STORAGE_LOCAL_ROOT="./uploads"
 
 {{ security }}
 
-# Unique identifier for the project
-# KEY="xxxxxxx-xxxxxx-xxxxxxxx-xxxxxxxxxx"
-
 # Secret string for the project
 # SECRET="abcdef"
 

package/dist/cli/utils/create-env/index.js

@@ -1,6 +1,5 @@
 import fs from 'fs';
 import { Liquid } from 'liquidjs';
-import { randomUUID } from 'node:crypto';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import path from 'path';
@@ -17,7 +16,6 @@ export default async function createEnv(client, credentials, directory) {
     const { nanoid } = await import('nanoid');
     const config = {
         security: {
-            KEY: randomUUID(),
             SECRET: nanoid(32),
         },
         database: {

package/dist/controllers/auth.js

@@ -2,7 +2,7 @@ import { useEnv } from '@directus/env';
 import { ErrorCode, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import { Router } from 'express';
 import { createLDAPAuthRouter, createLocalAuthRouter, createOAuth2AuthRouter, createOpenIDAuthRouter, createSAMLAuthRouter, } from '../auth/drivers/index.js';
-import { REFRESH_COOKIE_OPTIONS, DEFAULT_AUTH_PROVIDER, SESSION_COOKIE_OPTIONS } from '../constants.js';
+import { DEFAULT_AUTH_PROVIDER, REFRESH_COOKIE_OPTIONS, SESSION_COOKIE_OPTIONS } from '../constants.js';
 import { useLogger } from '../logger.js';
 import { respond } from '../middleware/respond.js';
 import { AuthenticationService } from '../services/authentication.js';
@@ -10,6 +10,7 @@ import { UsersService } from '../services/users.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getAuthProviders } from '../utils/get-auth-providers.js';
 import { getIPFromReq } from '../utils/get-ip-from-req.js';
+import { getSecret } from '../utils/get-secret.js';
 import isDirectusJWT from '../utils/is-directus-jwt.js';
 import { verifyAccessJWT } from '../utils/jwt.js';
 const router = Router();
@@ -63,7 +64,7 @@ function getCurrentRefreshToken(req, mode) {
     if (mode === 'session') {
         const token = req.cookies[env['SESSION_COOKIE_NAME']];
         if (isDirectusJWT(token)) {
-            const payload = verifyAccessJWT(token, env['SECRET']);
+            const payload = verifyAccessJWT(token, getSecret());
             return payload.session;
         }
     }

package/dist/controllers/extensions.js

@@ -1,9 +1,10 @@
 import { useEnv } from '@directus/env';
-import { ErrorCode, ForbiddenError, RouteNotFoundError, isDirectusError } from '@directus/errors';
+import { ErrorCode, ForbiddenError, isDirectusError, RouteNotFoundError } from '@directus/errors';
 import { EXTENSION_TYPES } from '@directus/extensions';
 import { account, describe, list, } from '@directus/extensions-registry';
 import { isIn } from '@directus/utils';
 import express from 'express';
+import { isNil } from 'lodash-es';
 import { UUID_REGEX } from '../constants.js';
 import { getExtensionManager } from '../extensions/index.js';
 import { respond } from '../middleware/respond.js';
@@ -28,28 +29,38 @@ router.get('/registry', asyncHandler(async (req, res, next) => {
     if (req.accountability && req.accountability.admin !== true) {
         throw new ForbiddenError();
     }
-    const { search, limit, offset, type, by, sort } = req.query;
+    const { search, limit, offset, sort, filter } = req.sanitizedQuery;
     const query = {};
-    if (typeof search === 'string') {
+    if (!isNil(search)) {
         query.search = search;
     }
-    if (typeof limit === 'string') {
-        query.limit = Number(limit);
-    }
-    if (typeof offset === 'string') {
-        query.offset = Number(offset);
-    }
-    if (typeof by === 'string') {
-        query.by = by;
-    }
-    if (typeof sort === 'string' && isIn(sort, ['popular', 'recent', 'downloads'])) {
-        query.sort = sort;
-    }
-    if (typeof type === 'string') {
-        if (isIn(type, EXTENSION_TYPES) === false) {
-            throw new ForbiddenError();
+    if (!isNil(limit)) {
+        query.limit = limit;
+    }
+    if (!isNil(offset)) {
+        query.offset = offset;
+    }
+    if (filter) {
+        const getFilterValue = (key) => {
+            const field = filter[key];
+            if (!field || !('_eq' in field) || typeof field._eq !== 'string')
+                return;
+            return field._eq;
+        };
+        const by = getFilterValue('by');
+        const type = getFilterValue('type');
+        if (by) {
+            query.by = by;
         }
-        query.type = type;
+        if (type) {
+            if (isIn(type, EXTENSION_TYPES) === false) {
+                throw new ForbiddenError();
+            }
+            query.type = type;
+        }
+    }
+    if (!isNil(sort) && sort[0] && isIn(sort[0], ['popular', 'recent', 'downloads'])) {
+        query.sort = sort[0];
     }
     if (env['MARKETPLACE_TRUST'] === 'sandbox') {
         query.sandbox = true;

package/dist/controllers/users.js

@@ -1,6 +1,7 @@
 import { ErrorCode, ForbiddenError, InvalidCredentialsError, InvalidPayloadError, isDirectusError, } from '@directus/errors';
 import express from 'express';
 import Joi from 'joi';
+import checkRateLimit from '../middleware/rate-limiter-registration.js';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
@@ -354,4 +355,28 @@ router.post('/:pk/tfa/disable', asyncHandler(async (req, _res, next) => {
     await service.disableTFA(req.params['pk']);
     return next();
 }), respond);
+const registerSchema = Joi.object({
+    email: Joi.string().email().required(),
+    password: Joi.string().required(),
+    first_name: Joi.string(),
+    last_name: Joi.string(),
+});
+router.post('/register', checkRateLimit, asyncHandler(async (req, _res, next) => {
+    const { error, value } = registerSchema.validate(req.body);
+    if (error)
+        throw new InvalidPayloadError({ reason: error.message });
+    const usersService = new UsersService({ accountability: null, schema: req.schema });
+    await usersService.registerUser(value);
+    return next();
+}), respond);
+const verifyRegistrationSchema = Joi.string();
+router.get('/register/verify-email', asyncHandler(async (req, res, _next) => {
+    const { error, value } = verifyRegistrationSchema.validate(req.query['token']);
+    if (error) {
+        return res.redirect('/admin/login');
+    }
+    const service = new UsersService({ accountability: null, schema: req.schema });
+    const id = await service.verifyRegistration(value);
+    return res.redirect(`/admin/users/${id}`);
+}), respond);
 export default router;

package/dist/controllers/utils.js

@@ -114,7 +114,8 @@ router.post('/cache/clear', asyncHandler(async (req, res) => {
         accountability: req.accountability,
         schema: req.schema,
     });
-    await service.clearCache();
+    const clearSystemCache = 'system' in req.query && (req.query['system'] === '' || Boolean(req.query['system']));
+    await service.clearCache({ system: clearSystemCache });
     res.status(200).end();
 }));
 export default router;

package/dist/database/helpers/fn/types.js

@@ -1,4 +1,4 @@
-import { applyFilter } from '../../../utils/apply-query.js';
+import { applyFilter, generateAlias } from '../../../utils/apply-query.js';
 import { DatabaseHelper } from '../types.js';
 export class FnHelper extends DatabaseHelper {
     schema;
@@ -14,10 +14,11 @@ export class FnHelper extends DatabaseHelper {
         if (!relation) {
             throw new Error(`Field ${collectionName}.${column} isn't a nested relational collection`);
         }
+        const alias = generateAlias();
         let countQuery = this.knex
             .count('*')
-            .from(relation.collection)
-            .where(relation.field, '=', this.knex.raw(`??.??`, [table, currentPrimary]));
+            .from({ [alias]: relation.collection })
+            .where(this.knex.raw(`??.??`, [alias, relation.field]), '=', this.knex.raw(`??.??`, [table, currentPrimary]));
         if (options?.query?.filter) {
             countQuery = applyFilter(this.knex, this.schema, countQuery, options.query.filter, relation.collection, {}).query;
         }

package/dist/database/helpers/index.d.ts

@@ -5,11 +5,13 @@ import * as fnHelpers from './fn/index.js';
 import * as geometryHelpers from './geometry/index.js';
 import * as schemaHelpers from './schema/index.js';
 import * as sequenceHelpers from './sequence/index.js';
+import * as numberHelpers from './number/index.js';
 export declare function getHelpers(database: Knex): {
     date: dateHelpers.postgres | dateHelpers.oracle | dateHelpers.mysql | dateHelpers.mssql | dateHelpers.sqlite;
     st: geometryHelpers.mysql | geometryHelpers.postgres | geometryHelpers.mssql | geometryHelpers.sqlite | geometryHelpers.oracle | geometryHelpers.redshift;
     schema: schemaHelpers.mysql | schemaHelpers.cockroachdb | schemaHelpers.mssql | schemaHelpers.postgres | schemaHelpers.sqlite | schemaHelpers.oracle;
     sequence: sequenceHelpers.mysql | sequenceHelpers.postgres;
+    number: numberHelpers.cockroachdb | numberHelpers.mssql | numberHelpers.postgres | numberHelpers.sqlite | numberHelpers.oracle;
 };
 export declare function getFunctions(database: Knex, schema: SchemaOverview): fnHelpers.mysql | fnHelpers.postgres | fnHelpers.mssql | fnHelpers.sqlite | fnHelpers.oracle;
 export type Helpers = ReturnType<typeof getHelpers>;

package/dist/database/helpers/index.js

@@ -4,6 +4,7 @@ import * as fnHelpers from './fn/index.js';
 import * as geometryHelpers from './geometry/index.js';
 import * as schemaHelpers from './schema/index.js';
 import * as sequenceHelpers from './sequence/index.js';
+import * as numberHelpers from './number/index.js';
 export function getHelpers(database) {
     const client = getDatabaseClient(database);
     return {
@@ -11,6 +12,7 @@ export function getHelpers(database) {
         st: new geometryHelpers[client](database),
         schema: new schemaHelpers[client](database),
         sequence: new sequenceHelpers[client](database),
+        number: new numberHelpers[client](database),
     };
 }
 export function getFunctions(database, schema) {

package/dist/database/helpers/number/dialects/default.d.ts

@@ -0,0 +1,3 @@
+import { NumberDatabaseHelper } from '../types.js';
+export declare class NumberHelperDefault extends NumberDatabaseHelper {
+}

package/dist/database/helpers/number/dialects/default.js

@@ -0,0 +1,3 @@
+import { NumberDatabaseHelper } from '../types.js';
+export class NumberHelperDefault extends NumberDatabaseHelper {
+}

package/dist/database/helpers/number/dialects/mssql.d.ts

@@ -0,0 +1,7 @@
+import type { Knex } from 'knex';
+import { NumberDatabaseHelper, type NumberInfo } from '../types.js';
+import type { NumericValue } from '@directus/types';
+export declare class NumberHelperMSSQL extends NumberDatabaseHelper {
+    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue): Knex.QueryBuilder;
+    isNumberValid(value: NumericValue, info: NumberInfo): boolean;
+}

package/dist/database/helpers/number/dialects/mssql.js

@@ -0,0 +1,11 @@
+import { maybeStringifyBigInt } from '../utils/maybe-stringify-big-int.js';
+import { numberInRange } from '../utils/number-in-range.js';
+import { NumberDatabaseHelper } from '../types.js';
+export class NumberHelperMSSQL extends NumberDatabaseHelper {
+    addSearchCondition(dbQuery, collection, name, value) {
+        return dbQuery.orWhere({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
+    }
+    isNumberValid(value, info) {
+        return numberInRange(value, info);
+    }
+}

package/dist/database/helpers/number/dialects/oracle.d.ts

@@ -0,0 +1,6 @@
+import type { Knex } from 'knex';
+import { NumberDatabaseHelper } from '../types.js';
+import type { NumericValue } from '@directus/types';
+export declare class NumberHelperOracle extends NumberDatabaseHelper {
+    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue): Knex.QueryBuilder;
+}

package/dist/database/helpers/number/dialects/oracle.js

@@ -0,0 +1,7 @@
+import { NumberDatabaseHelper } from '../types.js';
+import { maybeStringifyBigInt } from '../utils/maybe-stringify-big-int.js';
+export class NumberHelperOracle extends NumberDatabaseHelper {
+    addSearchCondition(dbQuery, collection, name, value) {
+        return dbQuery.orWhere({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
+    }
+}

package/dist/database/helpers/number/dialects/postgres.d.ts

@@ -0,0 +1,5 @@
+import type { NumericValue } from '@directus/types';
+import { NumberDatabaseHelper, type NumberInfo } from '../types.js';
+export declare class NumberHelperPostgres extends NumberDatabaseHelper {
+    isNumberValid(value: NumericValue, info: NumberInfo): boolean;
+}

package/dist/database/helpers/number/dialects/postgres.js

@@ -0,0 +1,15 @@
+import { NumberDatabaseHelper } from '../types.js';
+import { numberInRange } from '../utils/number-in-range.js';
+export class NumberHelperPostgres extends NumberDatabaseHelper {
+    isNumberValid(value, info) {
+        // Check that number is within the range of the provided type
+        if (numberInRange(value, info)) {
+            // Ensure that only integer values are used for integer types
+            if (typeof value !== 'bigint' && ['integer', 'bigInteger'].includes(info.type)) {
+                return value % 1 === 0;
+            }
+            return true;
+        }
+        return false;
+    }
+}

package/dist/database/helpers/number/dialects/sqlite.d.ts

@@ -0,0 +1,6 @@
+import type { Knex } from 'knex';
+import { NumberDatabaseHelper } from '../types.js';
+import type { NumericValue } from '@directus/types';
+export declare class NumberHelperSQLite extends NumberDatabaseHelper {
+    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue): Knex.QueryBuilder;
+}

package/dist/database/helpers/number/dialects/sqlite.js

@@ -0,0 +1,7 @@
+import { NumberDatabaseHelper } from '../types.js';
+import { maybeStringifyBigInt } from '../utils/maybe-stringify-big-int.js';
+export class NumberHelperSQLite extends NumberDatabaseHelper {
+    addSearchCondition(dbQuery, collection, name, value) {
+        return dbQuery.orWhere({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
+    }
+}

package/dist/database/helpers/number/index.d.ts

@@ -0,0 +1,7 @@
+export { NumberHelperPostgres as postgres } from './dialects/postgres.js';
+export { NumberHelperPostgres as redshift } from './dialects/postgres.js';
+export { NumberHelperDefault as cockroachdb } from './dialects/default.js';
+export { NumberHelperOracle as oracle } from './dialects/oracle.js';
+export { NumberHelperSQLite as sqlite } from './dialects/sqlite.js';
+export { NumberHelperDefault as mysql } from './dialects/default.js';
+export { NumberHelperMSSQL as mssql } from './dialects/mssql.js';

package/dist/database/helpers/number/index.js

@@ -0,0 +1,7 @@
+export { NumberHelperPostgres as postgres } from './dialects/postgres.js';
+export { NumberHelperPostgres as redshift } from './dialects/postgres.js';
+export { NumberHelperDefault as cockroachdb } from './dialects/default.js';
+export { NumberHelperOracle as oracle } from './dialects/oracle.js';
+export { NumberHelperSQLite as sqlite } from './dialects/sqlite.js';
+export { NumberHelperDefault as mysql } from './dialects/default.js';
+export { NumberHelperMSSQL as mssql } from './dialects/mssql.js';

package/dist/database/helpers/number/types.d.ts

@@ -0,0 +1,12 @@
+import type { Knex } from 'knex';
+import { DatabaseHelper } from '../types.js';
+import type { NumericType, NumericValue } from '@directus/types';
+export type NumberInfo = {
+    type: NumericType;
+    precision: number | null;
+    scale: number | null;
+};
+export declare abstract class NumberDatabaseHelper extends DatabaseHelper {
+    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue): Knex.QueryBuilder;
+    isNumberValid(_value: NumericValue, _info: NumberInfo): boolean;
+}

package/dist/database/helpers/number/types.js

@@ -0,0 +1,9 @@
+import { DatabaseHelper } from '../types.js';
+export class NumberDatabaseHelper extends DatabaseHelper {
+    addSearchCondition(dbQuery, collection, name, value) {
+        return dbQuery.orWhere({ [`${collection}.${name}`]: value });
+    }
+    isNumberValid(_value, _info) {
+        return true;
+    }
+}

package/dist/database/helpers/number/utils/decimal-limit.d.ts

@@ -0,0 +1,4 @@
+export declare function calculateDecimalLimit(precision: number | null, scale: number | null): {
+    max: number;
+    min: number;
+};

package/dist/database/helpers/number/utils/decimal-limit.js

@@ -0,0 +1,10 @@
+import { DEFAULT_NUMERIC_PRECISION, DEFAULT_NUMERIC_SCALE } from '@directus/constants';
+export function calculateDecimalLimit(precision, scale) {
+    if (precision === null || scale === null) {
+        precision = DEFAULT_NUMERIC_PRECISION;
+        scale = DEFAULT_NUMERIC_SCALE;
+    }
+    const max = 10 ** (precision - scale) - 10 ** -scale;
+    const min = -(10 ** (precision - scale)) + 10 ** -scale;
+    return { max, min };
+}

package/dist/database/helpers/number/utils/maybe-stringify-big-int.d.ts

@@ -0,0 +1 @@
+export declare function maybeStringifyBigInt(value: number | bigint): string | number;

package/dist/database/helpers/number/utils/maybe-stringify-big-int.js

@@ -0,0 +1,6 @@
+export function maybeStringifyBigInt(value) {
+    if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+        return String(value);
+    }
+    return Number(value);
+}

package/dist/database/helpers/number/utils/number-in-range.d.ts

@@ -0,0 +1,3 @@
+import type { NumericValue } from '@directus/types';
+import type { NumberInfo } from '../types.js';
+export declare function numberInRange(value: NumericValue, info: NumberInfo): boolean;

package/dist/database/helpers/number/utils/number-in-range.js

@@ -0,0 +1,20 @@
+import { MAX_SAFE_INT32, MAX_SAFE_INT64, MIN_SAFE_INT32, MIN_SAFE_INT64 } from '@directus/constants';
+import { calculateDecimalLimit } from './decimal-limit.js';
+export function numberInRange(value, info) {
+    switch (info.type) {
+        case 'bigInteger':
+            return value >= MIN_SAFE_INT64 && value <= MAX_SAFE_INT64;
+        case 'decimal': {
+            const { min, max } = calculateDecimalLimit(info.precision, info.scale);
+            return value >= min && value <= max;
+        }
+        case 'integer':
+            return value >= MIN_SAFE_INT32 && value <= MAX_SAFE_INT32;
+        case 'float':
+            // Not sure how to calculate the logical limits of float
+            // Let the database decide and error;
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/database/migrations/20240422A-public-registration.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20240422A-public-registration.js

@@ -0,0 +1,14 @@
+export async function up(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.boolean('public_registration').notNullable().defaultTo(false);
+        table.boolean('public_registration_verify_email').notNullable().defaultTo(true);
+        table.uuid('public_registration_role').nullable();
+        table.foreign('public_registration_role').references('directus_roles.id').onDelete('SET NULL');
+        table.json('public_registration_email_filter').nullable();
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.dropColumns('public_registration', 'public_registration_verify_email', 'public_registration_role', 'public_registration_email_filter');
+    });
+}

package/dist/database/run-ast.js

@@ -6,7 +6,7 @@ import { applyFunctionToColumnName } from '../utils/apply-function-to-column-nam
 import applyQuery, { applyLimit, applySort, generateAlias } from '../utils/apply-query.js';
 import { getCollectionFromAlias } from '../utils/get-collection-from-alias.js';
 import { getColumn } from '../utils/get-column.js';
-import { stripFunction } from '../utils/strip-function.js';
+import { parseFilterKey } from '../utils/parse-filter-key.js';
 import { getHelpers } from './helpers/index.js';
 import getDatabase from './index.js';
 /**
@@ -36,7 +36,7 @@ export default async function runAST(originalAST, schema, options) {
             return null;
         // Run the items through the special transforms
         const payloadService = new PayloadService(collection, { knex, schema });
-        let items = await payloadService.processValues('read', rawItems);
+        let items = await payloadService.processValues('read', rawItems, query.alias ?? {});
         if (!items || (Array.isArray(items) && items.length === 0))
             return items;
         // Apply the `_in` filters to the nested collection batches
@@ -92,7 +92,7 @@ async function parseCurrentLevel(schema, collection, children, query) {
     const nestedCollectionNodes = [];
     for (const child of children) {
         if (child.type === 'field' || child.type === 'functionField') {
-            const fieldName = stripFunction(child.name);
+            const { fieldName } = parseFilterKey(child.name);
             if (columnsInCollection.includes(fieldName)) {
                 columnsToSelectInternal.push(child.fieldKey);
             }
@@ -134,7 +134,8 @@ function getColumnPreprocessor(knex, schema, table) {
         }
         let field;
         if (fieldNode.type === 'field' || fieldNode.type === 'functionField') {
-            field = schema.collections[table].fields[stripFunction(fieldNode.name)];
+            const { fieldName } = parseFilterKey(fieldNode.name);
+            field = schema.collections[table].fields[fieldName];
         }
         else {
             field = schema.collections[fieldNode.relation.collection].fields[fieldNode.relation.field];