@directus/api 9.25.0

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

@@ -0,0 +1,65 @@
+import path from 'path';
+const filename = ({ filepath }) => ({
+    type: 'input',
+    name: 'filename',
+    message: 'Database File Path:',
+    default: path.join(filepath, 'data.db'),
+});
+const host = () => ({
+    type: 'input',
+    name: 'host',
+    message: 'Database Host:',
+    default: '127.0.0.1',
+});
+const port = ({ client }) => ({
+    type: 'input',
+    name: 'port',
+    message: 'Port:',
+    default() {
+        const ports = {
+            pg: 5432,
+            cockroachdb: 26257,
+            mysql: 3306,
+            oracledb: 1521,
+            mssql: 1433,
+        };
+        return ports[client];
+    },
+});
+const database = () => ({
+    type: 'input',
+    name: 'database',
+    message: 'Database Name:',
+    default: 'directus',
+});
+const user = () => ({
+    type: 'input',
+    name: 'user',
+    message: 'Database User:',
+});
+const password = () => ({
+    type: 'password',
+    name: 'password',
+    message: 'Database Password:',
+    mask: '*',
+});
+const encrypt = () => ({
+    type: 'confirm',
+    name: 'options__encrypt',
+    message: 'Encrypt Connection:',
+    default: false,
+});
+const ssl = () => ({
+    type: 'confirm',
+    name: 'ssl',
+    message: 'Enable SSL:',
+    default: false,
+});
+export const databaseQuestions = {
+    sqlite3: [filename],
+    mysql: [host, port, database, user, password],
+    pg: [host, port, database, user, password, ssl],
+    cockroachdb: [host, port, database, user, password, ssl],
+    oracledb: [host, port, database, user, password],
+    mssql: [host, port, database, user, password, encrypt],
+};

package/dist/cli/commands/roles/create.d.ts

@@ -0,0 +1,4 @@
+export default function rolesCreate({ role: name, admin }: {
+    role: string;
+    admin: boolean;
+}): Promise<void>;

package/dist/cli/commands/roles/create.js

@@ -0,0 +1,23 @@
+import { getSchema } from '../../../utils/get-schema.js';
+import { RolesService } from '../../../services/roles.js';
+import getDatabase from '../../../database/index.js';
+import logger from '../../../logger.js';
+export default async function rolesCreate({ role: name, admin }) {
+    const database = getDatabase();
+    if (!name) {
+        logger.error('Name is required');
+        process.exit(1);
+    }
+    try {
+        const schema = await getSchema();
+        const service = new RolesService({ schema: schema, knex: database });
+        const id = await service.createOne(admin ? { name, admin_access: admin } : { name });
+        process.stdout.write(`${String(id)}\n`);
+        database.destroy();
+        process.exit(0);
+    }
+    catch (err) {
+        logger.error(err);
+        process.exit(1);
+    }
+}

package/dist/cli/commands/schema/apply.d.ts

@@ -0,0 +1,4 @@
+export declare function apply(snapshotPath: string, options?: {
+    yes: boolean;
+    dryRun: boolean;
+}): Promise<void>;

package/dist/cli/commands/schema/apply.js

@@ -0,0 +1,153 @@
+import { parseJSON } from '@directus/utils';
+import chalk from 'chalk';
+import { promises as fs } from 'fs';
+import inquirer from 'inquirer';
+import { load as loadYaml } from 'js-yaml';
+import path from 'path';
+import getDatabase, { isInstalled, validateDatabaseConnection } from '../../../database/index.js';
+import logger from '../../../logger.js';
+import { DiffKind } from '../../../types/index.js';
+import { isNestedMetaUpdate } from '../../../utils/apply-diff.js';
+import { applySnapshot } from '../../../utils/apply-snapshot.js';
+import { getSnapshot } from '../../../utils/get-snapshot.js';
+import { getSnapshotDiff } from '../../../utils/get-snapshot-diff.js';
+export async function apply(snapshotPath, options) {
+    const filename = path.resolve(process.cwd(), snapshotPath);
+    const database = getDatabase();
+    await validateDatabaseConnection(database);
+    if ((await isInstalled()) === false) {
+        logger.error(`Directus isn't installed on this database. Please run "directus bootstrap" first.`);
+        database.destroy();
+        process.exit(0);
+    }
+    let snapshot;
+    try {
+        const fileContents = await fs.readFile(filename, 'utf8');
+        if (filename.endsWith('.yaml') || filename.endsWith('.yml')) {
+            snapshot = (await loadYaml(fileContents));
+        }
+        else {
+            snapshot = parseJSON(fileContents);
+        }
+        const currentSnapshot = await getSnapshot({ database });
+        const snapshotDiff = getSnapshotDiff(currentSnapshot, snapshot);
+        if (snapshotDiff.collections.length === 0 &&
+            snapshotDiff.fields.length === 0 &&
+            snapshotDiff.relations.length === 0) {
+            logger.info('No changes to apply.');
+            database.destroy();
+            process.exit(0);
+        }
+        const dryRun = options?.dryRun === true;
+        const promptForChanges = !dryRun && options?.yes !== true;
+        if (dryRun || promptForChanges) {
+            let message = '';
+            if (snapshotDiff.collections.length > 0) {
+                message += chalk.black.underline.bold('Collections:');
+                for (const { collection, diff } of snapshotDiff.collections) {
+                    if (diff[0]?.kind === DiffKind.EDIT) {
+                        message += `\n  - ${chalk.blue('Update')} ${collection}`;
+                        for (const change of diff) {
+                            if (change.kind === DiffKind.EDIT) {
+                                const path = change.path.slice(1).join('.');
+                                message += `\n    - Set ${path} to ${change.rhs}`;
+                            }
+                        }
+                    }
+                    else if (diff[0]?.kind === DiffKind.DELETE) {
+                        message += `\n  - ${chalk.red('Delete')} ${collection}`;
+                    }
+                    else if (diff[0]?.kind === DiffKind.NEW) {
+                        message += `\n  - ${chalk.green('Create')} ${collection}`;
+                    }
+                    else if (diff[0]?.kind === DiffKind.ARRAY) {
+                        message += `\n  - ${chalk.blue('Update')} ${collection}`;
+                    }
+                }
+            }
+            if (snapshotDiff.fields.length > 0) {
+                message += '\n\n' + chalk.black.underline.bold('Fields:');
+                for (const { collection, field, diff } of snapshotDiff.fields) {
+                    if (diff[0]?.kind === DiffKind.EDIT || isNestedMetaUpdate(diff[0])) {
+                        message += `\n  - ${chalk.blue('Update')} ${collection}.${field}`;
+                        for (const change of diff) {
+                            const path = change.path.slice(1).join('.');
+                            if (change.kind === DiffKind.EDIT) {
+                                message += `\n    - Set ${path} to ${change.rhs}`;
+                            }
+                            else if (change.kind === DiffKind.DELETE) {
+                                message += `\n    - Remove ${path}`;
+                            }
+                            else if (change.kind === DiffKind.NEW) {
+                                message += `\n    - Add ${path} and set it to ${change.rhs}`;
+                            }
+                        }
+                    }
+                    else if (diff[0]?.kind === DiffKind.DELETE) {
+                        message += `\n  - ${chalk.red('Delete')} ${collection}.${field}`;
+                    }
+                    else if (diff[0]?.kind === DiffKind.NEW) {
+                        message += `\n  - ${chalk.green('Create')} ${collection}.${field}`;
+                    }
+                    else if (diff[0]?.kind === DiffKind.ARRAY) {
+                        message += `\n  - ${chalk.blue('Update')} ${collection}.${field}`;
+                    }
+                }
+            }
+            if (snapshotDiff.relations.length > 0) {
+                message += '\n\n' + chalk.black.underline.bold('Relations:');
+                for (const { collection, field, related_collection, diff } of snapshotDiff.relations) {
+                    if (diff[0]?.kind === DiffKind.EDIT) {
+                        message += `\n  - ${chalk.blue('Update')} ${collection}.${field}`;
+                        for (const change of diff) {
+                            if (change.kind === DiffKind.EDIT) {
+                                const path = change.path.slice(1).join('.');
+                                message += `\n    - Set ${path} to ${change.rhs}`;
+                            }
+                        }
+                    }
+                    else if (diff[0]?.kind === DiffKind.DELETE) {
+                        message += `\n  - ${chalk.red('Delete')} ${collection}.${field}`;
+                    }
+                    else if (diff[0]?.kind === DiffKind.NEW) {
+                        message += `\n  - ${chalk.green('Create')} ${collection}.${field}`;
+                    }
+                    else if (diff[0]?.kind === DiffKind.ARRAY) {
+                        message += `\n  - ${chalk.blue('Update')} ${collection}.${field}`;
+                    }
+                    else {
+                        continue;
+                    }
+                    // Related collection doesn't exist for a2o relationship types
+                    if (related_collection) {
+                        message += `-> ${related_collection}`;
+                    }
+                }
+            }
+            message = 'The following changes will be applied:\n\n' + chalk.black(message);
+            if (dryRun) {
+                logger.info(message);
+                process.exit(0);
+            }
+            const { proceed } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'proceed',
+                    message: message + '\n\n' + 'Would you like to continue?',
+                },
+            ]);
+            if (proceed === false) {
+                process.exit(0);
+            }
+        }
+        await applySnapshot(snapshot, { current: currentSnapshot, diff: snapshotDiff, database });
+        logger.info(`Snapshot applied successfully`);
+        database.destroy();
+        process.exit(0);
+    }
+    catch (err) {
+        logger.error(err);
+        database.destroy();
+        process.exit(1);
+    }
+}

package/dist/cli/commands/schema/snapshot.d.ts

@@ -0,0 +1,4 @@
+export declare function snapshot(snapshotPath?: string, options?: {
+    yes: boolean;
+    format: 'json' | 'yaml';
+}): Promise<void>;

package/dist/cli/commands/schema/snapshot.js

@@ -0,0 +1,56 @@
+import getDatabase from '../../../database/index.js';
+import logger from '../../../logger.js';
+import { getSnapshot } from '../../../utils/get-snapshot.js';
+import { constants as fsConstants, promises as fs } from 'fs';
+import path from 'path';
+import inquirer from 'inquirer';
+import { dump as toYaml } from 'js-yaml';
+export async function snapshot(snapshotPath, options) {
+    const database = getDatabase();
+    try {
+        const snapshot = await getSnapshot({ database });
+        let snapshotString;
+        if (options?.format === 'yaml') {
+            snapshotString = toYaml(snapshot);
+        }
+        else {
+            snapshotString = JSON.stringify(snapshot);
+        }
+        if (snapshotPath) {
+            const filename = path.resolve(process.cwd(), snapshotPath);
+            let snapshotExists;
+            try {
+                await fs.access(filename, fsConstants.F_OK);
+                snapshotExists = true;
+            }
+            catch {
+                snapshotExists = false;
+            }
+            if (snapshotExists && options?.yes === false) {
+                const { overwrite } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'overwrite',
+                        message: 'Snapshot already exists. Do you want to overwrite the file?',
+                    },
+                ]);
+                if (overwrite === false) {
+                    database.destroy();
+                    process.exit(0);
+                }
+            }
+            await fs.writeFile(filename, snapshotString);
+            logger.info(`Snapshot saved to ${filename}`);
+        }
+        else {
+            process.stdout.write(snapshotString);
+        }
+        database.destroy();
+        process.exit(0);
+    }
+    catch (err) {
+        logger.error(err);
+        database.destroy();
+        process.exit(1);
+    }
+}

package/dist/cli/commands/security/key.d.ts

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

package/dist/cli/commands/security/key.js

@@ -0,0 +1,5 @@
+import { v4 as uuidv4 } from 'uuid';
+export default async function generateKey() {
+    process.stdout.write(uuidv4());
+    process.exit(0);
+}

package/dist/cli/commands/security/secret.d.ts

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

package/dist/cli/commands/security/secret.js

@@ -0,0 +1,5 @@
+export default async function generateSecret() {
+    const { nanoid } = await import('nanoid');
+    process.stdout.write(nanoid(32));
+    process.exit(0);
+}

package/dist/cli/commands/users/create.d.ts

@@ -0,0 +1,5 @@
+export default function usersCreate({ email, password, role, }: {
+    email?: string;
+    password?: string;
+    role?: string;
+}): Promise<void>;

package/dist/cli/commands/users/create.js

@@ -0,0 +1,23 @@
+import { getSchema } from '../../../utils/get-schema.js';
+import { UsersService } from '../../../services/users.js';
+import getDatabase from '../../../database/index.js';
+import logger from '../../../logger.js';
+export default async function usersCreate({ email, password, role, }) {
+    const database = getDatabase();
+    if (!email || !password || !role) {
+        logger.error('Email, password, role are required');
+        process.exit(1);
+    }
+    try {
+        const schema = await getSchema();
+        const service = new UsersService({ schema, knex: database });
+        const id = await service.createOne({ email, password, role, status: 'active' });
+        process.stdout.write(`${String(id)}\n`);
+        database.destroy();
+        process.exit(0);
+    }
+    catch (err) {
+        logger.error(err);
+        process.exit(1);
+    }
+}

package/dist/cli/commands/users/passwd.d.ts

@@ -0,0 +1,4 @@
+export default function usersPasswd({ email, password }: {
+    email?: string;
+    password?: string;
+}): Promise<void>;

package/dist/cli/commands/users/passwd.js

@@ -0,0 +1,35 @@
+import { getSchema } from '../../../utils/get-schema.js';
+import { generateHash } from '../../../utils/generate-hash.js';
+import { UsersService } from '../../../services/users.js';
+import getDatabase from '../../../database/index.js';
+import logger from '../../../logger.js';
+export default async function usersPasswd({ email, password }) {
+    const database = getDatabase();
+    if (!email || !password) {
+        logger.error('Email and password are required');
+        process.exit(1);
+    }
+    try {
+        const passwordHashed = await generateHash(password);
+        const schema = await getSchema();
+        const service = new UsersService({ schema, knex: database });
+        const user = await service.knex
+            .select('id')
+            .from('directus_users')
+            .whereRaw('LOWER(??) = ?', ['email', email.toLowerCase()])
+            .first();
+        if (user) {
+            await service.knex('directus_users').update({ password: passwordHashed }).where({ id: user.id });
+            logger.info(`Password is updated for user ${user.id}`);
+        }
+        else {
+            logger.error('No such user by this email');
+        }
+        await database.destroy();
+        process.exit(user ? 0 : 1);
+    }
+    catch (err) {
+        logger.error(err);
+        process.exit(1);
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createCli(): Promise<Command>;

package/dist/cli/index.js

@@ -0,0 +1,89 @@
+import { Command, Option } from 'commander';
+import emitter from '../emitter.js';
+import { getExtensionManager } from '../extensions.js';
+import { startServer } from '../server.js';
+import bootstrap from './commands/bootstrap/index.js';
+import count from './commands/count/index.js';
+import dbInstall from './commands/database/install.js';
+import dbMigrate from './commands/database/migrate.js';
+import init from './commands/init/index.js';
+import rolesCreate from './commands/roles/create.js';
+import { apply } from './commands/schema/apply.js';
+import { snapshot } from './commands/schema/snapshot.js';
+import keyGenerate from './commands/security/key.js';
+import secretGenerate from './commands/security/secret.js';
+import usersCreate from './commands/users/create.js';
+import usersPasswd from './commands/users/passwd.js';
+import * as pkg from '../utils/package.js';
+export async function createCli() {
+    const program = new Command();
+    const extensionManager = getExtensionManager();
+    await extensionManager.initialize({ schedule: false, watch: false });
+    await emitter.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(startServer);
+    program.command('init').description('Create a new Directus Project').action(init);
+    // Security
+    const securityCommand = program.command('security');
+    securityCommand.command('key:generate').description('Generate the app key').action(keyGenerate);
+    securityCommand.command('secret:generate').description('Generate the app secret').action(secretGenerate);
+    const dbCommand = program.command('database');
+    dbCommand.command('install').description('Install the database').action(dbInstall);
+    dbCommand
+        .command('migrate:latest')
+        .description('Upgrade the database')
+        .action(() => dbMigrate('latest'));
+    dbCommand
+        .command('migrate:up')
+        .description('Upgrade the database')
+        .action(() => dbMigrate('up'));
+    dbCommand
+        .command('migrate:down')
+        .description('Downgrade the database')
+        .action(() => dbMigrate('down'));
+    const usersCommand = program.command('users');
+    usersCommand
+        .command('create')
+        .description('Create a new user')
+        .option('--email <value>', `user's email`)
+        .option('--password <value>', `user's password`)
+        .option('--role <value>', `user's role`)
+        .action(usersCreate);
+    usersCommand
+        .command('passwd')
+        .description('Set user password')
+        .option('--email <value>', `user's email`)
+        .option('--password <value>', `user's new password`)
+        .action(usersPasswd);
+    const rolesCommand = program.command('roles');
+    rolesCommand
+        .command('create')
+        .description('Create a new role')
+        .option('--role <value>', `name for the role`)
+        .option('--admin', `whether or not the role has admin access`)
+        .action(rolesCreate);
+    program.command('count <collection>').description('Count the amount of items in a given collection').action(count);
+    program
+        .command('bootstrap')
+        .description('Initialize or update the database')
+        .option('--skipAdminInit', 'Skips the creation of the default Admin Role and User')
+        .action(bootstrap);
+    const schemaCommands = program.command('schema');
+    schemaCommands
+        .command('snapshot')
+        .description('Create a new Schema Snapshot')
+        .option('-y, --yes', `Assume "yes" as answer to all prompts and run non-interactively`, false)
+        .addOption(new Option('--format <format>', 'JSON or YAML format').choices(['json', 'yaml']).default('yaml'))
+        .argument('[path]', 'Path to snapshot file')
+        .action(snapshot);
+    schemaCommands
+        .command('apply')
+        .description('Apply a snapshot file to the current database')
+        .option('-y, --yes', `Assume "yes" as answer to all prompts and run non-interactively`)
+        .option('-d, --dry-run', 'Plan and log changes to be applied', false)
+        .argument('<path>', 'Path to snapshot file')
+        .action(apply);
+    await emitter.emitInit('cli.after', { program });
+    return program;
+}

package/dist/cli/run.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/run.js

@@ -0,0 +1,8 @@
+import { createCli } from './index.js';
+createCli()
+    .then((program) => program.parseAsync(process.argv))
+    .catch((err) => {
+    // eslint-disable-next-line no-console
+    console.error(err);
+    process.exit(1);
+});

package/dist/cli/utils/create-db-connection.d.ts

@@ -0,0 +1,13 @@
+import type { Knex } from 'knex';
+import type { Driver } from '../../types/index.js';
+export type Credentials = {
+    filename?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    ssl?: boolean;
+    options__encrypt?: boolean;
+};
+export default function createDBConnection(client: Driver, credentials: Credentials): Knex<any, unknown[]>;

package/dist/cli/utils/create-db-connection.js

@@ -0,0 +1,58 @@
+import knex from 'knex';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import path from 'path';
+import { promisify } from 'util';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export default function createDBConnection(client, credentials) {
+    let connection = {};
+    if (client === 'sqlite3') {
+        const { filename } = credentials;
+        connection = {
+            filename: filename,
+        };
+    }
+    else {
+        const { host, port, database, user, password } = credentials;
+        connection = {
+            host: host,
+            port: Number(port),
+            database: database,
+            user: user,
+            password: password,
+        };
+        if (client === 'pg' || client === 'cockroachdb') {
+            const { ssl } = credentials;
+            connection.ssl = ssl;
+        }
+        if (client === 'mssql') {
+            const { options__encrypt } = credentials;
+            connection = {
+                ...connection,
+                encrypt: options__encrypt,
+            };
+        }
+    }
+    const knexConfig = {
+        client: client,
+        connection: connection,
+        seeds: {
+            extension: 'js',
+            directory: path.resolve(__dirname, '../../database/seeds/'),
+        },
+        pool: {},
+    };
+    if (client === 'sqlite3') {
+        knexConfig.useNullAsDefault = true;
+    }
+    if (client === 'cockroachdb') {
+        knexConfig.pool.afterCreate = async (conn, callback) => {
+            const run = promisify(conn.query.bind(conn));
+            await run('SET serial_normalization = "sql_sequence"');
+            await run('SET default_int_size = 4');
+            callback(null, conn);
+        };
+    }
+    const db = knex.default(knexConfig);
+    return db;
+}