@directus/api 9.25.0

package/dist/auth/drivers/saml.js

@@ -0,0 +1,145 @@
+import * as validator from '@authenio/samlify-node-xmllint';
+import { BaseException } from '@directus/exceptions';
+import express, { Router } from 'express';
+import * as samlify from 'samlify';
+import { getAuthProvider } from '../../auth.js';
+import { COOKIE_OPTIONS } from '../../constants.js';
+import getDatabase from '../../database/index.js';
+import emitter from '../../emitter.js';
+import env from '../../env.js';
+import { RecordNotUniqueException } from '../../exceptions/database/record-not-unique.js';
+import { InvalidCredentialsException, InvalidProviderException } from '../../exceptions/index.js';
+import logger from '../../logger.js';
+import { respond } from '../../middleware/respond.js';
+import { AuthenticationService } from '../../services/authentication.js';
+import { UsersService } from '../../services/users.js';
+import asyncHandler from '../../utils/async-handler.js';
+import { getConfigFromEnv } from '../../utils/get-config-from-env.js';
+import { LocalAuthDriver } from './local.js';
+// Register the samlify schema validator
+samlify.setSchemaValidator(validator);
+export class SAMLAuthDriver extends LocalAuthDriver {
+    sp;
+    idp;
+    usersService;
+    config;
+    constructor(options, config) {
+        super(options, config);
+        this.config = config;
+        this.usersService = new UsersService({ knex: this.knex, schema: this.schema });
+        this.sp = samlify.ServiceProvider(getConfigFromEnv(`AUTH_${config['provider'].toUpperCase()}_SP`));
+        this.idp = samlify.IdentityProvider(getConfigFromEnv(`AUTH_${config['provider'].toUpperCase()}_IDP`));
+    }
+    async fetchUserID(identifier) {
+        const user = await this.knex
+            .select('id')
+            .from('directus_users')
+            .whereRaw('LOWER(??) = ?', ['external_identifier', identifier.toLowerCase()])
+            .first();
+        return user?.id;
+    }
+    async getUserID(payload) {
+        const { provider, emailKey, identifierKey, givenNameKey, familyNameKey, allowPublicRegistration } = this.config;
+        const email = payload[emailKey ?? 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress'];
+        const identifier = payload[identifierKey ?? 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier'];
+        const userID = await this.fetchUserID(identifier);
+        if (userID)
+            return userID;
+        if (!allowPublicRegistration) {
+            logger.trace(`[SAML] User doesn't exist, and public registration not allowed for provider "${provider}"`);
+            throw new InvalidCredentialsException();
+        }
+        const firstName = payload[givenNameKey ?? 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname'];
+        const lastName = payload[familyNameKey ?? 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/surname'];
+        const userPayload = {
+            provider,
+            first_name: firstName,
+            last_name: lastName,
+            email: email,
+            external_identifier: identifier.toLowerCase(),
+            role: this.config['defaultRoleId'],
+        };
+        // Run hook so the end user has the chance to augment the
+        // user that is about to be created
+        const updatedUserPayload = await emitter.emitFilter(`auth.create`, userPayload, { identifier: identifier.toLowerCase(), provider: this.config['provider'], providerPayload: { ...payload } }, { database: getDatabase(), schema: this.schema, accountability: null });
+        try {
+            return await this.usersService.createOne(updatedUserPayload);
+        }
+        catch (error) {
+            if (error instanceof RecordNotUniqueException) {
+                logger.warn(error, '[SAML] Failed to register user. User not unique');
+                throw new InvalidProviderException();
+            }
+            throw error;
+        }
+    }
+    // There's no local checks to be done when the user is authenticated in the IdP
+    async login(_user) {
+        return;
+    }
+}
+export function createSAMLAuthRouter(providerName) {
+    const router = Router();
+    router.get('/metadata', asyncHandler(async (_req, res) => {
+        const { sp } = getAuthProvider(providerName);
+        return res.header('Content-Type', 'text/xml').send(sp.getMetadata());
+    }));
+    router.get('/', asyncHandler(async (req, res) => {
+        const { sp, idp } = getAuthProvider(providerName);
+        const { context: url } = sp.createLoginRequest(idp, 'redirect');
+        const parsedUrl = new URL(url);
+        if (req.query['redirect']) {
+            parsedUrl.searchParams.append('RelayState', req.query['redirect']);
+        }
+        return res.redirect(parsedUrl.toString());
+    }));
+    router.post('/logout', asyncHandler(async (req, res) => {
+        const { sp, idp } = getAuthProvider(providerName);
+        const { context } = sp.createLogoutRequest(idp, 'redirect', req.body);
+        const authService = new AuthenticationService({ accountability: req.accountability, schema: req.schema });
+        if (req.cookies[env['REFRESH_TOKEN_COOKIE_NAME']]) {
+            const currentRefreshToken = req.cookies[env['REFRESH_TOKEN_COOKIE_NAME']];
+            if (currentRefreshToken) {
+                await authService.logout(currentRefreshToken);
+                res.clearCookie(env['REFRESH_TOKEN_COOKIE_NAME'], COOKIE_OPTIONS);
+            }
+        }
+        return res.redirect(context);
+    }));
+    router.post('/acs', express.urlencoded({ extended: false }), asyncHandler(async (req, res, next) => {
+        const relayState = req.body?.RelayState;
+        try {
+            const { sp, idp } = getAuthProvider(providerName);
+            const { extract } = await sp.parseLoginResponse(idp, 'post', req);
+            const authService = new AuthenticationService({ accountability: req.accountability, schema: req.schema });
+            const { accessToken, refreshToken, expires } = await authService.login(providerName, extract.attributes);
+            res.locals['payload'] = {
+                data: {
+                    access_token: accessToken,
+                    refresh_token: refreshToken,
+                    expires,
+                },
+            };
+            if (relayState) {
+                res.cookie(env['REFRESH_TOKEN_COOKIE_NAME'], refreshToken, COOKIE_OPTIONS);
+                return res.redirect(relayState);
+            }
+            return next();
+        }
+        catch (error) {
+            if (relayState) {
+                let reason = 'UNKNOWN_EXCEPTION';
+                if (error instanceof BaseException) {
+                    reason = error.code;
+                }
+                else {
+                    logger.warn(error, `[SAML] Unexpected error during SAML login`);
+                }
+                return res.redirect(`${relayState.split('?')[0]}?reason=${reason}`);
+            }
+            logger.warn(error, `[SAML] Unexpected error during SAML login`);
+            throw error;
+        }
+    }), respond);
+    return router;
+}

package/dist/auth.d.ts

@@ -0,0 +1,3 @@
+import type { AuthDriver } from './auth/auth.js';
+export declare function getAuthProvider(provider: string): AuthDriver;
+export declare function registerAuthProviders(): Promise<void>;

package/dist/auth.js

@@ -0,0 +1,62 @@
+import { toArray } from '@directus/utils';
+import { LDAPAuthDriver, LocalAuthDriver, OAuth2AuthDriver, OpenIDAuthDriver, SAMLAuthDriver, } from './auth/drivers/index.js';
+import { DEFAULT_AUTH_PROVIDER } from './constants.js';
+import getDatabase from './database/index.js';
+import env from './env.js';
+import { InvalidConfigException } from './exceptions/invalid-config.js';
+import logger from './logger.js';
+import { getConfigFromEnv } from './utils/get-config-from-env.js';
+import { getSchema } from './utils/get-schema.js';
+const providerNames = toArray(env['AUTH_PROVIDERS']);
+const providers = new Map();
+export function getAuthProvider(provider) {
+    if (!providers.has(provider)) {
+        throw new InvalidConfigException('Auth provider not configured', { provider });
+    }
+    return providers.get(provider);
+}
+export async function registerAuthProviders() {
+    const options = { knex: getDatabase(), schema: await getSchema() };
+    // Register default provider if not disabled
+    if (!env['AUTH_DISABLE_DEFAULT']) {
+        const defaultProvider = getProviderInstance('local', options);
+        providers.set(DEFAULT_AUTH_PROVIDER, defaultProvider);
+    }
+    if (!env['AUTH_PROVIDERS']) {
+        return;
+    }
+    // Register configured providers
+    providerNames.forEach((name) => {
+        name = name.trim();
+        if (name === DEFAULT_AUTH_PROVIDER) {
+            logger.error(`Cannot override "${DEFAULT_AUTH_PROVIDER}" auth provider.`);
+            process.exit(1);
+        }
+        const { driver, ...config } = getConfigFromEnv(`AUTH_${name.toUpperCase()}_`);
+        if (!driver) {
+            logger.warn(`Missing driver definition for "${name}" auth provider.`);
+            return;
+        }
+        const provider = getProviderInstance(driver, options, { provider: name, ...config });
+        if (!provider) {
+            logger.warn(`Invalid "${driver}" auth driver.`);
+            return;
+        }
+        providers.set(name, provider);
+    });
+}
+function getProviderInstance(driver, options, config = {}) {
+    switch (driver) {
+        case 'local':
+            return new LocalAuthDriver(options, config);
+        case 'oauth2':
+            return new OAuth2AuthDriver(options, config);
+        case 'openid':
+            return new OpenIDAuthDriver(options, config);
+        case 'ldap':
+            return new LDAPAuthDriver(options, config);
+        case 'saml':
+            return new SAMLAuthDriver(options, config);
+    }
+    return undefined;
+}

package/dist/cache.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaOverview } from '@directus/types';
+import Keyv from 'keyv';
+export declare function getCache(): {
+    cache: Keyv | null;
+    systemCache: Keyv;
+    sharedSchemaCache: Keyv;
+    localSchemaCache: Keyv;
+    lockCache: Keyv;
+};
+export declare function flushCaches(forced?: boolean): Promise<void>;
+export declare function clearSystemCache(opts?: {
+    forced?: boolean | undefined;
+    autoPurgeCache?: false | undefined;
+}): Promise<void>;
+export declare function setSystemCache(key: string, value: any, ttl?: number): Promise<void>;
+export declare function getSystemCache(key: string): Promise<Record<string, any>>;
+export declare function setSchemaCache(schema: SchemaOverview): Promise<void>;
+export declare function getSchemaCache(): Promise<SchemaOverview | undefined>;
+export declare function setCacheValue(cache: Keyv, key: string, value: Record<string, any> | Record<string, any>[], ttl?: number): Promise<void>;
+export declare function getCacheValue(cache: Keyv, key: string): Promise<any>;

package/dist/cache.js

@@ -0,0 +1,138 @@
+import { getSimpleHash } from '@directus/utils';
+import Keyv from 'keyv';
+import env from './env.js';
+import logger from './logger.js';
+import { getMessenger } from './messenger.js';
+import { compress, decompress } from './utils/compress.js';
+import { getConfigFromEnv } from './utils/get-config-from-env.js';
+import { getMilliseconds } from './utils/get-milliseconds.js';
+import { validateEnv } from './utils/validate-env.js';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+let cache = null;
+let systemCache = null;
+let localSchemaCache = null;
+let sharedSchemaCache = null;
+let lockCache = null;
+let messengerSubscribed = false;
+const messenger = getMessenger();
+if (env['MESSENGER_STORE'] === 'redis' &&
+    env['CACHE_STORE'] === 'memory' &&
+    env['CACHE_AUTO_PURGE'] &&
+    !messengerSubscribed) {
+    messengerSubscribed = true;
+    messenger.subscribe('schemaChanged', async (opts) => {
+        if (cache && opts?.['autoPurgeCache'] !== false) {
+            await cache.clear();
+        }
+    });
+}
+export function getCache() {
+    if (env['CACHE_ENABLED'] === true && cache === null) {
+        validateEnv(['CACHE_NAMESPACE', 'CACHE_TTL', 'CACHE_STORE']);
+        cache = getKeyvInstance(env['CACHE_STORE'], getMilliseconds(env['CACHE_TTL']));
+        cache.on('error', (err) => logger.warn(err, `[cache] ${err}`));
+    }
+    if (systemCache === null) {
+        systemCache = getKeyvInstance(env['CACHE_STORE'], getMilliseconds(env['CACHE_SYSTEM_TTL']), '_system');
+        systemCache.on('error', (err) => logger.warn(err, `[system-cache] ${err}`));
+    }
+    if (sharedSchemaCache === null) {
+        sharedSchemaCache = getKeyvInstance(env['CACHE_STORE'], getMilliseconds(env['CACHE_SYSTEM_TTL']), '_schema_shared');
+        sharedSchemaCache.on('error', (err) => logger.warn(err, `[shared-schema-cache] ${err}`));
+    }
+    if (localSchemaCache === null) {
+        localSchemaCache = getKeyvInstance('memory', getMilliseconds(env['CACHE_SYSTEM_TTL']), '_schema');
+        localSchemaCache.on('error', (err) => logger.warn(err, `[schema-cache] ${err}`));
+    }
+    if (lockCache === null) {
+        lockCache = getKeyvInstance(env['CACHE_STORE'], undefined, '_lock');
+        lockCache.on('error', (err) => logger.warn(err, `[lock-cache] ${err}`));
+    }
+    return { cache, systemCache, sharedSchemaCache, localSchemaCache, lockCache };
+}
+export async function flushCaches(forced) {
+    const { cache } = getCache();
+    await clearSystemCache({ forced });
+    await cache?.clear();
+}
+export async function clearSystemCache(opts) {
+    const { systemCache, localSchemaCache, lockCache } = getCache();
+    // Flush system cache when forced or when system cache lock not set
+    if (opts?.forced || !(await lockCache.get('system-cache-lock'))) {
+        await lockCache.set('system-cache-lock', true, 10000);
+        await systemCache.clear();
+        await lockCache.delete('system-cache-lock');
+    }
+    await localSchemaCache.clear();
+    messenger.publish('schemaChanged', { autoPurgeCache: opts?.autoPurgeCache });
+}
+export async function setSystemCache(key, value, ttl) {
+    const { systemCache, lockCache } = getCache();
+    if (!(await lockCache.get('system-cache-lock'))) {
+        await setCacheValue(systemCache, key, value, ttl);
+    }
+}
+export async function getSystemCache(key) {
+    const { systemCache } = getCache();
+    return await getCacheValue(systemCache, key);
+}
+export async function setSchemaCache(schema) {
+    const { localSchemaCache, sharedSchemaCache } = getCache();
+    const schemaHash = await getSimpleHash(JSON.stringify(schema));
+    await sharedSchemaCache.set('hash', schemaHash);
+    await localSchemaCache.set('schema', schema);
+    await localSchemaCache.set('hash', schemaHash);
+}
+export async function getSchemaCache() {
+    const { localSchemaCache, sharedSchemaCache } = getCache();
+    const sharedSchemaHash = await sharedSchemaCache.get('hash');
+    if (!sharedSchemaHash)
+        return;
+    const localSchemaHash = await localSchemaCache.get('hash');
+    if (!localSchemaHash || localSchemaHash !== sharedSchemaHash)
+        return;
+    return await localSchemaCache.get('schema');
+}
+export async function setCacheValue(cache, key, value, ttl) {
+    const compressed = await compress(value);
+    await cache.set(key, compressed, ttl);
+}
+export async function getCacheValue(cache, key) {
+    const value = await cache.get(key);
+    if (!value)
+        return undefined;
+    const decompressed = await decompress(value);
+    return decompressed;
+}
+function getKeyvInstance(store, ttl, namespaceSuffix) {
+    switch (store) {
+        case 'redis':
+            return new Keyv(getConfig('redis', ttl, namespaceSuffix));
+        case 'memcache':
+            return new Keyv(getConfig('memcache', ttl, namespaceSuffix));
+        case 'memory':
+        default:
+            return new Keyv(getConfig('memory', ttl, namespaceSuffix));
+    }
+}
+function getConfig(store = 'memory', ttl, namespaceSuffix = '') {
+    const config = {
+        namespace: `${env['CACHE_NAMESPACE']}${namespaceSuffix}`,
+        ttl,
+    };
+    if (store === 'redis') {
+        const KeyvRedis = require('@keyv/redis');
+        config.store = new KeyvRedis(env['CACHE_REDIS'] || getConfigFromEnv('CACHE_REDIS_'));
+    }
+    if (store === 'memcache') {
+        const KeyvMemcache = require('keyv-memcache');
+        // keyv-memcache uses memjs which only accepts a comma separated string instead of an array,
+        // so we need to join array into a string when applicable. See #7986
+        const cacheMemcache = Array.isArray(env['CACHE_MEMCACHE'])
+            ? env['CACHE_MEMCACHE'].join(',')
+            : env['CACHE_MEMCACHE'];
+        config.store = new KeyvMemcache(cacheMemcache);
+    }
+    return config;
+}

package/dist/cli/commands/bootstrap/index.d.ts

@@ -0,0 +1,3 @@
+export default function bootstrap({ skipAdminInit }: {
+    skipAdminInit?: boolean;
+}): Promise<void>;

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

@@ -0,0 +1,71 @@
+import getDatabase, { hasDatabaseConnection, isInstalled, validateDatabaseConnection, } from '../../../database/index.js';
+import runMigrations from '../../../database/migrations/run.js';
+import installDatabase from '../../../database/seeds/run.js';
+import env from '../../../env.js';
+import logger from '../../../logger.js';
+import { RolesService } from '../../../services/roles.js';
+import { SettingsService } from '../../../services/settings.js';
+import { UsersService } from '../../../services/users.js';
+import { getSchema } from '../../../utils/get-schema.js';
+import { defaultAdminRole, defaultAdminUser } from '../../utils/defaults.js';
+export default async function bootstrap({ skipAdminInit }) {
+    logger.info('Initializing bootstrap...');
+    const database = getDatabase();
+    await waitForDatabase(database);
+    if ((await isInstalled()) === false) {
+        logger.info('Installing Directus system tables...');
+        await installDatabase(database);
+        logger.info('Running migrations...');
+        await runMigrations(database, 'latest');
+        const schema = await getSchema();
+        if (skipAdminInit == null) {
+            await createDefaultAdmin(schema);
+        }
+        else {
+            logger.info('Skipping creation of default Admin user and role...');
+        }
+        if (env['PROJECT_NAME'] && typeof env['PROJECT_NAME'] === 'string' && env['PROJECT_NAME'].length > 0) {
+            const settingsService = new SettingsService({ schema });
+            await settingsService.upsertSingleton({ project_name: env['PROJECT_NAME'] });
+        }
+    }
+    else {
+        logger.info('Database already initialized, skipping install');
+        logger.info('Running migrations...');
+        await runMigrations(database, 'latest');
+    }
+    logger.info('Done');
+    process.exit(0);
+}
+async function waitForDatabase(database) {
+    const tries = 5;
+    const secondsBetweenTries = 5;
+    for (let i = 0; i < tries; i++) {
+        if (await hasDatabaseConnection(database)) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, secondsBetweenTries * 1000));
+    }
+    // This will throw and exit the process if the database is not available
+    await validateDatabaseConnection(database);
+    return database;
+}
+async function createDefaultAdmin(schema) {
+    const { nanoid } = await import('nanoid');
+    logger.info('Setting up first admin role...');
+    const rolesService = new RolesService({ schema });
+    const role = await rolesService.createOne(defaultAdminRole);
+    logger.info('Adding first admin user...');
+    const usersService = new UsersService({ schema });
+    let adminEmail = env['ADMIN_EMAIL'];
+    if (!adminEmail) {
+        logger.info('No admin email provided. Defaulting to "admin@example.com"');
+        adminEmail = 'admin@example.com';
+    }
+    let adminPassword = env['ADMIN_PASSWORD'];
+    if (!adminPassword) {
+        adminPassword = nanoid(12);
+        logger.info(`No admin password provided. Defaulting to "${adminPassword}"`);
+    }
+    await usersService.createOne({ email: adminEmail, password: adminPassword, role, ...defaultAdminUser });
+}

package/dist/cli/commands/count/index.d.ts

@@ -0,0 +1 @@
+export default function count(collection: string): Promise<void>;

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

@@ -0,0 +1,21 @@
+import getDatabase from '../../../database/index.js';
+import logger from '../../../logger.js';
+export default async function count(collection) {
+    const database = getDatabase();
+    if (!collection) {
+        logger.error('Collection is required');
+        process.exit(1);
+    }
+    try {
+        const records = await database(collection).count('*', { as: 'count' });
+        const count = Number(records[0].count);
+        process.stdout.write(`${count}\n`);
+        database.destroy();
+        process.exit(0);
+    }
+    catch (err) {
+        logger.error(err);
+        database.destroy();
+        process.exit(1);
+    }
+}

package/dist/cli/commands/database/install.d.ts

@@ -0,0 +1 @@
+export default function start(): Promise<void>;

package/dist/cli/commands/database/install.js

@@ -0,0 +1,16 @@
+import installSeeds from '../../../database/seeds/run.js';
+import getDatabase from '../../../database/index.js';
+import logger from '../../../logger.js';
+export default async function start() {
+    const database = getDatabase();
+    try {
+        await installSeeds(database);
+        database.destroy();
+        process.exit(0);
+    }
+    catch (err) {
+        logger.error(err);
+        database.destroy();
+        process.exit(1);
+    }
+}

package/dist/cli/commands/database/migrate.d.ts

@@ -0,0 +1 @@
+export default function migrate(direction: 'latest' | 'up' | 'down'): Promise<void>;

package/dist/cli/commands/database/migrate.js

@@ -0,0 +1,23 @@
+import run from '../../../database/migrations/run.js';
+import getDatabase from '../../../database/index.js';
+import logger from '../../../logger.js';
+export default async function migrate(direction) {
+    const database = getDatabase();
+    try {
+        logger.info('Running migrations...');
+        await run(database, direction);
+        if (direction === 'down') {
+            logger.info('Downgrade successful');
+        }
+        else {
+            logger.info('Database up to date');
+        }
+        database.destroy();
+        process.exit();
+    }
+    catch (err) {
+        logger.error(err);
+        database.destroy();
+        process.exit(1);
+    }
+}

package/dist/cli/commands/init/index.d.ts

@@ -0,0 +1 @@
+export default function init(): Promise<void>;

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

@@ -0,0 +1,102 @@
+import chalk from 'chalk';
+import execa from 'execa';
+import inquirer from 'inquirer';
+import Joi from 'joi';
+import ora from 'ora';
+import { v4 as uuid } from 'uuid';
+import runMigrations from '../../../database/migrations/run.js';
+import runSeed from '../../../database/seeds/run.js';
+import { generateHash } from '../../../utils/generate-hash.js';
+import createDBConnection from '../../utils/create-db-connection.js';
+import createEnv from '../../utils/create-env/index.js';
+import { defaultAdminRole, defaultAdminUser } from '../../utils/defaults.js';
+import { drivers, getDriverForClient } from '../../utils/drivers.js';
+import { databaseQuestions } from './questions.js';
+export default async function init() {
+    const rootPath = process.cwd();
+    const { client } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'client',
+            message: 'Choose your database client',
+            choices: Object.values(drivers),
+        },
+    ]);
+    const dbClient = getDriverForClient(client);
+    const spinnerDriver = ora('Installing Database Driver...').start();
+    await execa('npm', ['install', dbClient, '--production']);
+    spinnerDriver.stop();
+    let attemptsRemaining = 5;
+    const { credentials, db } = await trySeed();
+    async function trySeed() {
+        const credentials = await inquirer.prompt(databaseQuestions[dbClient].map((question) => question({ client: dbClient, filepath: rootPath })));
+        const db = createDBConnection(dbClient, credentials);
+        try {
+            await runSeed(db);
+            await runMigrations(db, 'latest', false);
+        }
+        catch (err) {
+            process.stdout.write('\nSomething went wrong while seeding the database:\n');
+            process.stdout.write(`\n${chalk.red(`[${err.code || 'Error'}]`)} ${err.message}\n`);
+            process.stdout.write('\nPlease try again\n\n');
+            attemptsRemaining--;
+            if (attemptsRemaining > 0) {
+                return await trySeed();
+            }
+            else {
+                process.stdout.write("Couldn't seed the database. Exiting.\n");
+                process.exit(1);
+            }
+        }
+        return { credentials, db };
+    }
+    await createEnv(dbClient, credentials, rootPath);
+    process.stdout.write('\nCreate your first admin user:\n\n');
+    const firstUser = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'email',
+            message: 'Email',
+            default: 'admin@example.com',
+            validate: (input) => {
+                const emailSchema = Joi.string().email().required();
+                const { error } = emailSchema.validate(input);
+                if (error)
+                    throw new Error('The email entered is not a valid email address!');
+                return true;
+            },
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Password',
+            mask: '*',
+            validate: (input) => {
+                if (input === null || input === '')
+                    throw new Error('The password cannot be empty!');
+                return true;
+            },
+        },
+    ]);
+    firstUser.password = await generateHash(firstUser.password);
+    const userID = uuid();
+    const roleID = uuid();
+    await db('directus_roles').insert({
+        id: roleID,
+        ...defaultAdminRole,
+    });
+    await db('directus_users').insert({
+        id: userID,
+        email: firstUser.email,
+        password: firstUser.password,
+        role: roleID,
+        ...defaultAdminUser,
+    });
+    await db.destroy();
+    process.stdout.write(`\nYour project has been created at ${chalk.green(rootPath)}.\n`);
+    process.stdout.write(`\nThe configuration can be found in ${chalk.green(rootPath + '/.env')}\n`);
+    process.stdout.write(`\nStart Directus by running:\n`);
+    process.stdout.write(`  ${chalk.blue('cd')} ${rootPath}\n`);
+    process.stdout.write(`  ${chalk.blue('npx directus')} start\n`);
+    process.exit(0);
+}

package/dist/cli/commands/init/questions.d.ts

@@ -0,0 +1,20 @@
+export declare const databaseQuestions: {
+    sqlite3: (({ filepath }: {
+        filepath: string;
+    }) => Record<string, string>)[];
+    mysql: (({ client }: {
+        client: string;
+    }) => Record<string, any>)[];
+    pg: (({ client }: {
+        client: string;
+    }) => Record<string, any>)[];
+    cockroachdb: (({ client }: {
+        client: string;
+    }) => Record<string, any>)[];
+    oracledb: (({ client }: {
+        client: string;
+    }) => Record<string, any>)[];
+    mssql: (({ client }: {
+        client: string;
+    }) => Record<string, any>)[];
+};