directus 9.0.0-rc.99 → 9.1.1

package/dist/auth/drivers/openid.js

@@ -31,6 +31,12 @@ class OpenIDAuthDriver extends local_1.LocalAuthDriver {
         this.client = new Promise((resolve, reject) => {
             openid_client_1.Issuer.discover(issuerUrl)
                 .then((issuer) => {
+                const supportedTypes = issuer.metadata.response_types_supported;
+                if (!(supportedTypes === null || supportedTypes === void 0 ? void 0 : supportedTypes.includes('code'))) {
+                    reject(new exceptions_1.InvalidConfigException('OpenID provider does not support required code flow', {
+                        provider: additionalConfig.provider,
+                    }));
+                }
                 resolve(new issuer.Client({
                     client_id: clientId,
                     client_secret: clientSecret,
@@ -48,10 +54,13 @@ class OpenIDAuthDriver extends local_1.LocalAuthDriver {
         var _a;
         try {
             const client = await this.client;
+            const codeChallenge = openid_client_1.generators.codeChallenge(codeVerifier);
             return client.authorizationUrl({
                 scope: (_a = this.config.scope) !== null && _a !== void 0 ? _a : 'openid profile email',
-                code_challenge: openid_client_1.generators.codeChallenge(codeVerifier),
+                code_challenge: codeChallenge,
                 code_challenge_method: 'S256',
+                // Some providers require state even with PKCE
+                state: codeChallenge,
                 access_type: 'offline',
             });
         }
@@ -63,8 +72,7 @@ class OpenIDAuthDriver extends local_1.LocalAuthDriver {
         const user = await this.knex
             .select('id')
             .from('directus_users')
-            .whereRaw('LOWER(??) = ?', ['email', identifier.toLowerCase()])
-            .orWhereRaw('LOWER(??) = ?', ['external_identifier', identifier.toLowerCase()])
+            .whereRaw('LOWER(??) = ?', ['external_identifier', identifier.toLowerCase()])
             .first();
         return user === null || user === void 0 ? void 0 : user.id;
     }
@@ -77,8 +85,14 @@ class OpenIDAuthDriver extends local_1.LocalAuthDriver {
         let userInfo;
         try {
             const client = await this.client;
-            tokenSet = await client.callback(this.redirectUrl, { code: payload.code }, { code_verifier: payload.codeVerifier });
-            userInfo = await client.userinfo(tokenSet);
+            tokenSet = await client.callback(this.redirectUrl, { code: payload.code, state: payload.state }, { code_verifier: payload.codeVerifier, state: openid_client_1.generators.codeChallenge(payload.codeVerifier) });
+            const issuer = client.issuer;
+            if (issuer.metadata.userinfo_endpoint) {
+                userInfo = await client.userinfo(tokenSet.access_token);
+            }
+            else {
+                userInfo = tokenSet.claims();
+            }
         }
         catch (e) {
             throw handleError(e);
@@ -106,21 +120,19 @@ class OpenIDAuthDriver extends local_1.LocalAuthDriver {
         if (!allowPublicRegistration || !isEmailVerified) {
             throw new exceptions_1.InvalidCredentialsException();
         }
-        // If email matches identifier, don't set "external_identifier"
-        const emailIsIdentifier = (email === null || email === void 0 ? void 0 : email.toLowerCase()) === identifier.toLowerCase();
         await this.usersService.createOne({
             provider: this.config.provider,
             first_name: userInfo.given_name,
             last_name: userInfo.family_name,
             email: email,
-            external_identifier: !emailIsIdentifier ? identifier : undefined,
+            external_identifier: identifier,
             role: this.config.defaultRoleId,
             auth_data: tokenSet.refresh_token && JSON.stringify({ refreshToken: tokenSet.refresh_token }),
         });
         return (await this.fetchUserId(identifier));
     }
-    async login(user, sessionData) {
-        return this.refresh(user, sessionData);
+    async login(user) {
+        return this.refresh(user, null);
     }
     async refresh(user, sessionData) {
         let authData = user.auth_data;
@@ -181,8 +193,14 @@ function createOpenIDAuthRouter(providerName) {
     }), respond_1.respond);
     router.get('/callback', (0, async_handler_1.default)(async (req, res, next) => {
         var _a;
-        const token = req.cookies[`openid.${providerName}`];
-        const { verifier, redirect } = jsonwebtoken_1.default.verify(token, env_1.default.SECRET, { issuer: 'directus' });
+        let tokenData;
+        try {
+            tokenData = jsonwebtoken_1.default.verify(req.cookies[`openid.${providerName}`], env_1.default.SECRET, { issuer: 'directus' });
+        }
+        catch (e) {
+            throw new exceptions_1.InvalidCredentialsException();
+        }
+        const { verifier, redirect } = tokenData;
         const authenticationService = new services_1.AuthenticationService({
             accountability: {
                 ip: req.ip,
@@ -194,9 +212,13 @@ function createOpenIDAuthRouter(providerName) {
         let authResponse;
         try {
             res.clearCookie(`openid.${providerName}`);
+            if (!req.query.code || !req.query.state) {
+                logger_1.default.warn(`Couldn't extract OpenID code or state from query: ${JSON.stringify(req.query)}`);
+            }
             authResponse = await authenticationService.login(providerName, {
                 code: req.query.code,
                 codeVerifier: verifier,
+                state: req.query.state,
             });
         }
         catch (error) {

package/dist/auth.js

@@ -59,5 +59,7 @@ function getProviderInstance(driver, options, config = {}) {
             return new drivers_1.OAuth2AuthDriver(options, config);
         case 'openid':
             return new drivers_1.OpenIDAuthDriver(options, config);
+        case 'ldap':
+            return new drivers_1.LDAPAuthDriver(options, config);
     }
 }

package/dist/cache.d.ts

@@ -1,6 +1,6 @@
 import Keyv from 'keyv';
 export declare function getCache(): {
     cache: Keyv | null;
-    schemaCache: Keyv | null;
+    systemCache: Keyv;
 };
 export declare function flushCaches(): Promise<void>;

package/dist/cache.js

@@ -11,23 +11,23 @@ const logger_1 = __importDefault(require("./logger"));
 const get_config_from_env_1 = require("./utils/get-config-from-env");
 const validate_env_1 = require("./utils/validate-env");
 let cache = null;
-let schemaCache = null;
+let systemCache = null;
 function getCache() {
     if (env_1.default.CACHE_ENABLED === true && cache === null) {
         (0, validate_env_1.validateEnv)(['CACHE_NAMESPACE', 'CACHE_TTL', 'CACHE_STORE']);
         cache = getKeyvInstance((0, ms_1.default)(env_1.default.CACHE_TTL));
         cache.on('error', (err) => logger_1.default.warn(err, `[cache] ${err}`));
     }
-    if (env_1.default.CACHE_SCHEMA !== false && schemaCache === null) {
-        schemaCache = getKeyvInstance(typeof env_1.default.CACHE_SCHEMA === 'string' ? (0, ms_1.default)(env_1.default.CACHE_SCHEMA) : undefined, '_schema');
-        schemaCache.on('error', (err) => logger_1.default.warn(err, `[cache] ${err}`));
+    if (systemCache === null) {
+        systemCache = getKeyvInstance(undefined, '_system');
+        systemCache.on('error', (err) => logger_1.default.warn(err, `[cache] ${err}`));
     }
-    return { cache, schemaCache };
+    return { cache, systemCache };
 }
 exports.getCache = getCache;
 async function flushCaches() {
-    const { schemaCache, cache } = getCache();
-    await (schemaCache === null || schemaCache === void 0 ? void 0 : schemaCache.clear());
+    const { systemCache, cache } = getCache();
+    await (systemCache === null || systemCache === void 0 ? void 0 : systemCache.clear());
     await (cache === null || cache === void 0 ? void 0 : cache.clear());
 }
 exports.flushCaches = flushCaches;

package/dist/cli/commands/init/index.js

@@ -36,7 +36,7 @@ async function init() {
         const db = (0, create_db_connection_1.default)(dbClient, credentials);
         try {
             await (0, run_2.default)(db);
-            await (0, run_1.default)(db, 'latest');
+            await (0, run_1.default)(db, 'latest', false);
         }
         catch (err) {
             process.stdout.write('\nSomething went wrong while seeding the database:\n');

package/dist/cli/index.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCli = void 0;
 const commander_1 = require("commander");
 const server_1 = require("../server");
-const emitter_1 = require("../emitter");
+const emitter_1 = __importDefault(require("../emitter"));
 const extensions_1 = require("../extensions");
 const bootstrap_1 = __importDefault(require("./commands/bootstrap"));
 const count_1 = __importDefault(require("./commands/count"));
@@ -23,7 +23,7 @@ async function createCli() {
     const program = new commander_1.Command();
     const extensionManager = (0, extensions_1.getExtensionManager)();
     await extensionManager.initialize({ schedule: false });
-    await (0, emitter_1.emitAsyncSafe)('cli.init.before', { program });
+    await emitter_1.default.emitInit('cli.before', { program });
     program.name('directus').usage('[command] [options]');
     program.version(pkg.version, '-v, --version');
     program.command('start').description('Start the Directus API').action(server_1.startServer);
@@ -83,7 +83,7 @@ async function createCli() {
         .option('-y, --yes', `Assume "yes" as answer to all prompts and run non-interactively`)
         .argument('<path>', 'Path to snapshot file')
         .action(apply_1.apply);
-    await (0, emitter_1.emitAsyncSafe)('cli.init.after', { program });
+    await emitter_1.default.emitInit('cli.after', { program });
     return program;
 }
 exports.createCli = createCli;

package/dist/cli/index.test.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = require(".");
+const index_1 = require("./index");
 jest.mock('../env', () => ({
     ...jest.requireActual('../env').default,
     EXTENSIONS_PATH: '',
@@ -16,7 +16,7 @@ jest.mock('@directus/shared/utils/node/get-extensions', () => ({
     getPackageExtensions: jest.fn(() => Promise.resolve([])),
     getLocalExtensions: jest.fn(() => Promise.resolve([customCliExtension])),
 }));
-jest.mock(`/hooks/custom-cli/index.js`, () => () => customCliHook, { virtual: true });
+jest.mock(`/hooks/custom-cli/index.js`, () => customCliHook, { virtual: true });
 const customCliExtension = {
     path: `/hooks/custom-cli`,
     name: 'custom-cli',
@@ -26,12 +26,17 @@ const customCliExtension = {
 };
 const beforeHook = jest.fn();
 const afterAction = jest.fn();
-const afterHook = jest.fn(({ program }) => program.command('custom').action(afterAction));
-const customCliHook = { 'cli.init.before': beforeHook, 'cli.init.after': afterHook };
+const afterHook = jest.fn(({ program }) => {
+    program.command('custom').action(afterAction);
+});
+const customCliHook = ({ init }) => {
+    init('cli.before', beforeHook);
+    init('cli.after', afterHook);
+};
 const writeOut = jest.fn();
 const writeErr = jest.fn();
 const setup = async () => {
-    const program = await (0, _1.createCli)();
+    const program = await (0, index_1.createCli)();
     program.exitOverride();
     program.configureOutput({ writeOut, writeErr });
     return program;

package/dist/constants.js

@@ -38,6 +38,6 @@ exports.ASSET_TRANSFORM_QUERY_KEYS = [
     'withoutEnlargement',
 ];
 exports.FILTER_VARIABLES = ['$NOW', '$CURRENT_USER', '$CURRENT_ROLE'];
-exports.ALIAS_TYPES = ['alias', 'o2m', 'm2m', 'm2a', 'files', 'files', 'translations'];
+exports.ALIAS_TYPES = ['alias', 'o2m', 'm2m', 'm2a', 'files', 'translations'];
 exports.DEFAULT_AUTH_PROVIDER = 'default';
 exports.COLUMN_TRANSFORMS = ['year', 'month', 'day', 'weekday', 'hour', 'minute', 'second'];

package/dist/controllers/auth.js

@@ -28,6 +28,9 @@ for (const authProvider of authProviders) {
         case 'openid':
             authRouter = (0, drivers_1.createOpenIDAuthRouter)(authProvider.name);
             break;
+        case 'ldap':
+            authRouter = (0, drivers_1.createLDAPAuthRouter)(authProvider.name);
+            break;
     }
     if (!authRouter) {
         logger_1.default.warn(`Couldn't create login router for auth provider "${authProvider.name}"`);

package/dist/controllers/extensions.js

@@ -33,6 +33,8 @@ router.get('/:type/index.js', (0, async_handler_1.default)(async (req, res) => {
         throw new exceptions_1.RouteNotFoundException(req.path);
     }
     res.setHeader('Content-Type', 'application/javascript; charset=UTF-8');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Vary', 'Origin, Cache-Control');
     res.end(extensionSource);
 }));
 exports.default = router;

package/dist/controllers/files.js

@@ -21,7 +21,17 @@ router.use((0, use_collection_1.default)('directus_files'));
 const multipartHandler = (0, async_handler_1.default)(async (req, res, next) => {
     if (req.is('multipart/form-data') === false)
         return next();
-    const busboy = new busboy_1.default({ headers: req.headers });
+    let headers;
+    if (req.headers['content-type']) {
+        headers = req.headers;
+    }
+    else {
+        headers = {
+            ...req.headers,
+            'content-type': 'application/octet-stream',
+        };
+    }
+    const busboy = new busboy_1.default({ headers });
     const savedFiles = [];
     const service = new services_1.FilesService({ accountability: req.accountability, schema: req.schema });
     const existingPrimaryKey = req.params.pk || undefined;
@@ -34,16 +44,17 @@ const multipartHandler = (0, async_handler_1.default)(async (req, res, next) =>
     let payload = {};
     let fileCount = 0;
     busboy.on('field', (fieldname, val) => {
-        if (typeof val === 'string' && val.trim() === 'null')
-            val = null;
-        if (typeof val === 'string' && val.trim() === 'false')
-            val = false;
-        if (typeof val === 'string' && val.trim() === 'true')
-            val = true;
+        let fieldValue = val;
+        if (typeof fieldValue === 'string' && fieldValue.trim() === 'null')
+            fieldValue = null;
+        if (typeof fieldValue === 'string' && fieldValue.trim() === 'false')
+            fieldValue = false;
+        if (typeof fieldValue === 'string' && fieldValue.trim() === 'true')
+            fieldValue = true;
         if (fieldname === 'storage') {
             disk = val;
         }
-        payload[fieldname] = val;
+        payload[fieldname] = fieldValue;
     });
     busboy.on('file', async (fieldname, fileStream, filename, encoding, mimetype) => {
         fileCount++;

package/dist/controllers/not-found.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const database_1 = __importDefault(require("../database"));
 const emitter_1 = __importDefault(require("../emitter"));
 const exceptions_1 = require("../exceptions");
 /**
@@ -17,9 +18,14 @@ const exceptions_1 = require("../exceptions");
  * @param next
  */
 const notFound = async (req, res, next) => {
+    var _a;
     try {
-        const hooksResult = await emitter_1.default.emitAsync('request.not_found', req, res);
-        if (hooksResult.reduce((prev, current) => current || prev, false)) {
+        const hooksResult = await emitter_1.default.emitFilter('request.not_found', false, { request: req, response: res }, {
+            database: (0, database_1.default)(),
+            schema: req.schema,
+            accountability: (_a = req.accountability) !== null && _a !== void 0 ? _a : null,
+        });
+        if (hooksResult) {
             return next();
         }
         next(new exceptions_1.RouteNotFoundException(req.path));

package/dist/controllers/notifications.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/controllers/notifications.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const exceptions_1 = require("../exceptions");
+const respond_1 = require("../middleware/respond");
+const use_collection_1 = __importDefault(require("../middleware/use-collection"));
+const validate_batch_1 = require("../middleware/validate-batch");
+const services_1 = require("../services");
+const async_handler_1 = __importDefault(require("../utils/async-handler"));
+const router = express_1.default.Router();
+router.use((0, use_collection_1.default)('directus_notifications'));
+router.post('/', (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.NotificationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const savedKeys = [];
+    if (Array.isArray(req.body)) {
+        const keys = await service.createMany(req.body);
+        savedKeys.push(...keys);
+    }
+    else {
+        const key = await service.createOne(req.body);
+        savedKeys.push(key);
+    }
+    try {
+        if (Array.isArray(req.body)) {
+            const records = await service.readMany(savedKeys, req.sanitizedQuery);
+            res.locals.payload = { data: records };
+        }
+        else {
+            const record = await service.readOne(savedKeys[0], req.sanitizedQuery);
+            res.locals.payload = { data: record };
+        }
+    }
+    catch (error) {
+        if (error instanceof exceptions_1.ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond_1.respond);
+const readHandler = (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.NotificationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const metaService = new services_1.MetaService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    let result;
+    if (req.singleton) {
+        result = await service.readSingleton(req.sanitizedQuery);
+    }
+    else if (req.body.keys) {
+        result = await service.readMany(req.body.keys, req.sanitizedQuery);
+    }
+    else {
+        result = await service.readByQuery(req.sanitizedQuery);
+    }
+    const meta = await metaService.getMetaForQuery('directus_presets', req.sanitizedQuery);
+    res.locals.payload = { data: result, meta };
+    return next();
+});
+router.get('/', (0, validate_batch_1.validateBatch)('read'), readHandler, respond_1.respond);
+router.search('/', (0, validate_batch_1.validateBatch)('read'), readHandler, respond_1.respond);
+router.get('/:pk', (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.NotificationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const record = await service.readOne(req.params.pk, req.sanitizedQuery);
+    res.locals.payload = { data: record || null };
+    return next();
+}), respond_1.respond);
+router.patch('/', (0, validate_batch_1.validateBatch)('update'), (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.NotificationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    let keys = [];
+    if (req.body.keys) {
+        keys = await service.updateMany(req.body.keys, req.body.data);
+    }
+    else {
+        keys = await service.updateByQuery(req.body.query, req.body.data);
+    }
+    try {
+        const result = await service.readMany(keys, req.sanitizedQuery);
+        res.locals.payload = { data: result };
+    }
+    catch (error) {
+        if (error instanceof exceptions_1.ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond_1.respond);
+router.patch('/:pk', (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.NotificationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const primaryKey = await service.updateOne(req.params.pk, req.body);
+    try {
+        const record = await service.readOne(primaryKey, req.sanitizedQuery);
+        res.locals.payload = { data: record };
+    }
+    catch (error) {
+        if (error instanceof exceptions_1.ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond_1.respond);
+router.delete('/', (0, validate_batch_1.validateBatch)('delete'), (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.NotificationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    if (Array.isArray(req.body)) {
+        await service.deleteMany(req.body);
+    }
+    else if (req.body.keys) {
+        await service.deleteMany(req.body.keys);
+    }
+    else {
+        await service.deleteByQuery(req.body.query);
+    }
+    return next();
+}), respond_1.respond);
+router.delete('/:pk', (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.NotificationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    await service.deleteOne(req.params.pk);
+    return next();
+}), respond_1.respond);
+exports.default = router;

package/dist/controllers/utils.js

@@ -70,7 +70,17 @@ router.post('/import/:collection', collection_exists_1.default, (0, async_handle
         accountability: req.accountability,
         schema: req.schema,
     });
-    const busboy = new busboy_1.default({ headers: req.headers });
+    let headers;
+    if (req.headers['content-type']) {
+        headers = req.headers;
+    }
+    else {
+        headers = {
+            ...req.headers,
+            'content-type': 'application/octet-stream',
+        };
+    }
+    const busboy = new busboy_1.default({ headers });
     busboy.on('file', async (fieldname, fileStream, filename, encoding, mimetype) => {
         try {
             await service.import(req.params.collection, mimetype, fileStream);

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

@@ -0,0 +1,8 @@
+import { Knex } from 'knex';
+export declare function getDateHelper(): KnexDate;
+declare class KnexDate {
+    protected knex: Knex;
+    constructor(knex: Knex);
+    parseDate(date: string): string;
+}
+export {};

package/dist/database/helpers/date.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDateHelper = void 0;
+const __1 = __importDefault(require(".."));
+let dateHelper;
+function getDateHelper() {
+    if (!dateHelper) {
+        const db = (0, __1.default)();
+        const client = db.client.config.client;
+        const constructor = {
+            mysql: KnexDate,
+            mariadb: KnexDate,
+            sqlite3: KnexDate_SQLITE,
+            pg: KnexDate,
+            postgres: KnexDate,
+            redshift: KnexDate,
+            mssql: KnexDate,
+            oracledb: KnexDate,
+        }[client];
+        if (!constructor) {
+            throw new Error(`Geometry helper not implemented on ${client}.`);
+        }
+        dateHelper = new constructor(db);
+    }
+    return dateHelper;
+}
+exports.getDateHelper = getDateHelper;
+class KnexDate {
+    constructor(knex) {
+        this.knex = knex;
+    }
+    parseDate(date) {
+        return date;
+    }
+}
+class KnexDate_SQLITE extends KnexDate {
+    parseDate(date) {
+        const newDate = new Date(date);
+        return (newDate.getTime() - newDate.getTimezoneOffset() * 60 * 1000).toString();
+    }
+}

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

@@ -1,14 +1,16 @@
 import { Field, RawField } from '@directus/shared/types';
 import { Knex } from 'knex';
 import { GeoJSONGeometry } from 'wellknown';
-export declare function getGeometryHelper(): KnexSpatial;
-declare class KnexSpatial {
+export declare function getGeometryHelper(database?: Knex): KnexSpatial;
+declare abstract class KnexSpatial {
     protected knex: Knex;
     constructor(knex: Knex);
+    supported(): boolean | Promise<boolean>;
     isTrue(expression: Knex.Raw): Knex.Raw<any>;
     isFalse(expression: Knex.Raw): Knex.Raw<any>;
     createColumn(table: Knex.CreateTableBuilder, field: RawField | Field): Knex.ColumnBuilder;
     asText(table: string, column: string): Knex.Raw;
+    asGeoJSON?(table: string, column: string): Knex.Raw;
     fromText(text: string): Knex.Raw;
     fromGeoJSON(geojson: GeoJSONGeometry): Knex.Raw;
     _intersects(key: string, geojson: GeoJSONGeometry): Knex.Raw;