directus 9.23.4 → 9.25.0

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

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaHelperDefault = void 0;
-const types_1 = require("../types");
-class SchemaHelperDefault extends types_1.SchemaHelper {
-}
-exports.SchemaHelperDefault = SchemaHelperDefault;

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

@@ -1,7 +0,0 @@
-import type { Knex } from 'knex';
-import { SchemaHelper } from '../types';
-export declare class SchemaHelperMSSQL extends SchemaHelper {
-    applyLimit(rootQuery: Knex.QueryBuilder, limit: number): void;
-    applyOffset(rootQuery: Knex.QueryBuilder, offset: number): void;
-    formatUUID(uuid: string): string;
-}

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

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaHelperMSSQL = void 0;
-const types_1 = require("../types");
-class SchemaHelperMSSQL extends types_1.SchemaHelper {
-    applyLimit(rootQuery, limit) {
-        // The ORDER BY clause is invalid in views, inline functions, derived tables, subqueries,
-        // and common table expressions, unless TOP, OFFSET or FOR XML is also specified.
-        if (limit === -1) {
-            rootQuery.limit(Number.MAX_SAFE_INTEGER);
-        }
-        else {
-            rootQuery.limit(limit);
-        }
-    }
-    applyOffset(rootQuery, offset) {
-        rootQuery.offset(offset);
-        rootQuery.orderBy(1);
-    }
-    formatUUID(uuid) {
-        return uuid.toUpperCase();
-    }
-}
-exports.SchemaHelperMSSQL = SchemaHelperMSSQL;

package/dist/database/helpers/schema/dialects/mysql.d.ts

@@ -1,5 +0,0 @@
-import type { Knex } from 'knex';
-import { SchemaHelper } from '../types';
-export declare class SchemaHelperMySQL extends SchemaHelper {
-    applyMultiRelationalSort(knex: Knex, dbQuery: Knex.QueryBuilder, table: string, primaryKey: string, orderByString: string, orderByFields: Knex.Raw[]): Knex.QueryBuilder;
-}

package/dist/database/helpers/schema/dialects/mysql.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaHelperMySQL = void 0;
-const database_1 = require("../../../../database");
-const types_1 = require("../types");
-class SchemaHelperMySQL extends types_1.SchemaHelper {
-    applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields) {
-        if ((0, database_1.getDatabaseVersion)()?.startsWith('5.7')) {
-            dbQuery.orderByRaw(`?? asc, ${orderByString}`, [`${table}.${primaryKey}`, ...orderByFields]);
-            dbQuery = knex
-                .select(knex.raw(`??, ( @rank := IF ( @cur_id = deep.${primaryKey}, @rank + 1, 1 ) ) AS directus_row_number, ( @cur_id := deep.${primaryKey} ) AS current_id`, 'deep.*'))
-                .from(knex.raw('? as ??, (SELECT @rank := 0,  @cur_id := null) vars', [dbQuery, 'deep']));
-            return dbQuery;
-        }
-        return super.applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields);
-    }
-}
-exports.SchemaHelperMySQL = SchemaHelperMySQL;

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

@@ -1,9 +0,0 @@
-import type { KNEX_TYPES } from '@directus/shared/constants';
-import type { Field, Relation, Type } from '@directus/shared/types';
-import { Options, SchemaHelper } from '../types';
-export declare class SchemaHelperOracle extends SchemaHelper {
-    changeToType(table: string, column: string, type: (typeof KNEX_TYPES)[number], options?: Options): Promise<void>;
-    castA2oPrimaryKey(): string;
-    preRelationChange(relation: Partial<Relation>): void;
-    processFieldType(field: Field): Type;
-}

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

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaHelperOracle = void 0;
-const types_1 = require("../types");
-class SchemaHelperOracle extends types_1.SchemaHelper {
-    async changeToType(table, column, type, options = {}) {
-        await this.changeToTypeByCopy(table, column, type, options);
-    }
-    castA2oPrimaryKey() {
-        return 'CAST(?? AS VARCHAR2(255))';
-    }
-    preRelationChange(relation) {
-        if (relation.collection === relation.related_collection) {
-            // Constraints are not allowed on self referencing relationships
-            // Setting NO ACTION throws - ORA-00905: missing keyword
-            if (relation.schema?.on_delete) {
-                relation.schema.on_delete = null;
-            }
-        }
-    }
-    processFieldType(field) {
-        if (field.type === 'integer') {
-            if (field.schema?.numeric_precision === 20) {
-                return 'bigInteger';
-            }
-            else if (field.schema?.numeric_precision === 1) {
-                return 'boolean';
-            }
-            else if (field.schema?.numeric_precision || field.schema?.numeric_scale) {
-                return 'decimal';
-            }
-        }
-        return field.type;
-    }
-}
-exports.SchemaHelperOracle = SchemaHelperOracle;

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

@@ -1,5 +0,0 @@
-import { SchemaHelper } from '../types';
-export declare class SchemaHelperSQLite extends SchemaHelper {
-    preColumnChange(): Promise<boolean>;
-    postColumnChange(): Promise<void>;
-}

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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaHelperSQLite = void 0;
-const types_1 = require("../types");
-class SchemaHelperSQLite extends types_1.SchemaHelper {
-    async preColumnChange() {
-        const foreignCheckStatus = (await this.knex.raw('PRAGMA foreign_keys'))[0].foreign_keys === 1;
-        if (foreignCheckStatus) {
-            await this.knex.raw('PRAGMA foreign_keys = OFF');
-        }
-        return foreignCheckStatus;
-    }
-    async postColumnChange() {
-        await this.knex.raw('PRAGMA foreign_keys = ON');
-    }
-}
-exports.SchemaHelperSQLite = SchemaHelperSQLite;

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

@@ -1,7 +0,0 @@
-export { SchemaHelperDefault as postgres } from './dialects/default';
-export { SchemaHelperCockroachDb as cockroachdb } from './dialects/cockroachdb';
-export { SchemaHelperDefault as redshift } from './dialects/default';
-export { SchemaHelperOracle as oracle } from './dialects/oracle';
-export { SchemaHelperSQLite as sqlite } from './dialects/sqlite';
-export { SchemaHelperMySQL as mysql } from './dialects/mysql';
-export { SchemaHelperMSSQL as mssql } from './dialects/mssql';

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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mssql = exports.mysql = exports.sqlite = exports.oracle = exports.redshift = exports.cockroachdb = exports.postgres = void 0;
-var default_1 = require("./dialects/default");
-Object.defineProperty(exports, "postgres", { enumerable: true, get: function () { return default_1.SchemaHelperDefault; } });
-var cockroachdb_1 = require("./dialects/cockroachdb");
-Object.defineProperty(exports, "cockroachdb", { enumerable: true, get: function () { return cockroachdb_1.SchemaHelperCockroachDb; } });
-var default_2 = require("./dialects/default");
-Object.defineProperty(exports, "redshift", { enumerable: true, get: function () { return default_2.SchemaHelperDefault; } });
-var oracle_1 = require("./dialects/oracle");
-Object.defineProperty(exports, "oracle", { enumerable: true, get: function () { return oracle_1.SchemaHelperOracle; } });
-var sqlite_1 = require("./dialects/sqlite");
-Object.defineProperty(exports, "sqlite", { enumerable: true, get: function () { return sqlite_1.SchemaHelperSQLite; } });
-var mysql_1 = require("./dialects/mysql");
-Object.defineProperty(exports, "mysql", { enumerable: true, get: function () { return mysql_1.SchemaHelperMySQL; } });
-var mssql_1 = require("./dialects/mssql");
-Object.defineProperty(exports, "mssql", { enumerable: true, get: function () { return mssql_1.SchemaHelperMSSQL; } });

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

@@ -1,26 +0,0 @@
-import type { KNEX_TYPES } from '@directus/shared/constants';
-import type { Field, Relation, Type } from '@directus/shared/types';
-import type { Knex } from 'knex';
-import type { DatabaseClient } from '../../../types';
-import { DatabaseHelper } from '../types';
-export type Options = {
-    nullable?: boolean;
-    default?: any;
-    length?: number;
-};
-export declare abstract class SchemaHelper extends DatabaseHelper {
-    isOneOfClients(clients: DatabaseClient[]): boolean;
-    changeNullable(table: string, column: string, nullable: boolean): Promise<void>;
-    changeToType(table: string, column: string, type: (typeof KNEX_TYPES)[number], options?: Options): Promise<void>;
-    protected changeToTypeByCopy(table: string, column: string, type: (typeof KNEX_TYPES)[number], options: Options): Promise<void>;
-    preColumnChange(): Promise<boolean>;
-    postColumnChange(): Promise<void>;
-    preRelationChange(_relation: Partial<Relation>): void;
-    processFieldType(field: Field): Type;
-    constraintName(existingName: string): string;
-    applyLimit(rootQuery: Knex.QueryBuilder, limit: number): void;
-    applyOffset(rootQuery: Knex.QueryBuilder, offset: number): void;
-    castA2oPrimaryKey(): string;
-    applyMultiRelationalSort(knex: Knex, dbQuery: Knex.QueryBuilder, table: string, primaryKey: string, orderByString: string, orderByFields: Knex.Raw[]): Knex.QueryBuilder;
-    formatUUID(uuid: string): string;
-}

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

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaHelper = void 0;
-const index_1 = require("../../index");
-const types_1 = require("../types");
-class SchemaHelper extends types_1.DatabaseHelper {
-    isOneOfClients(clients) {
-        return clients.includes((0, index_1.getDatabaseClient)(this.knex));
-    }
-    async changeNullable(table, column, nullable) {
-        await this.knex.schema.alterTable(table, (builder) => {
-            if (nullable) {
-                builder.setNullable(column);
-            }
-            else {
-                builder.dropNullable(column);
-            }
-        });
-    }
-    async changeToType(table, column, type, options = {}) {
-        await this.knex.schema.alterTable(table, (builder) => {
-            const b = type === 'string' ? builder.string(column, options.length) : builder[type](column);
-            if (options.nullable === true) {
-                b.nullable();
-            }
-            if (options.nullable === false) {
-                b.notNullable();
-            }
-            if (options.default !== undefined) {
-                b.defaultTo(options.default);
-            }
-            b.alter();
-        });
-    }
-    async changeToTypeByCopy(table, column, type, options) {
-        const tempName = `${column}__temp`;
-        await this.knex.schema.alterTable(table, (builder) => {
-            const col = type === 'string' ? builder.string(tempName, options.length) : builder[type](tempName);
-            if (options.default !== undefined) {
-                col.defaultTo(options.default);
-            }
-            // Force new temporary column to be nullable (required, as there will already be rows in
-            // the table)
-            col.nullable();
-        });
-        await this.knex(table).update(tempName, this.knex.ref(column));
-        await this.knex.schema.alterTable(table, (builder) => {
-            builder.dropColumn(column);
-        });
-        await this.knex.schema.alterTable(table, (builder) => {
-            builder.renameColumn(tempName, column);
-        });
-        // We're altering the temporary column here. That starts nullable, so we only want to set it
-        // to NOT NULL when applicable
-        if (options.nullable === false) {
-            await this.changeNullable(table, column, options.nullable);
-        }
-    }
-    async preColumnChange() {
-        return false;
-    }
-    async postColumnChange() {
-        return;
-    }
-    preRelationChange(_relation) {
-        return;
-    }
-    processFieldType(field) {
-        return field.type;
-    }
-    constraintName(existingName) {
-        // most vendors allow for dropping/creating constraints with the same name
-        // reference issue #14873
-        return existingName;
-    }
-    applyLimit(rootQuery, limit) {
-        if (limit !== -1) {
-            rootQuery.limit(limit);
-        }
-    }
-    applyOffset(rootQuery, offset) {
-        rootQuery.offset(offset);
-    }
-    castA2oPrimaryKey() {
-        return 'CAST(?? AS CHAR(255))';
-    }
-    applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields) {
-        dbQuery.rowNumber(knex.ref('directus_row_number').toQuery(), knex.raw(`partition by ?? order by ${orderByString}`, [`${table}.${primaryKey}`, ...orderByFields]));
-        return dbQuery;
-    }
-    formatUUID(uuid) {
-        return uuid; // no-op by default
-    }
-}
-exports.SchemaHelper = SchemaHelper;

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

@@ -1,5 +0,0 @@
-import type { Knex } from 'knex';
-export declare abstract class DatabaseHelper {
-    protected knex: Knex;
-    constructor(knex: Knex);
-}

package/dist/database/helpers/types.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseHelper = void 0;
-class DatabaseHelper {
-    knex;
-    constructor(knex) {
-        this.knex = knex;
-    }
-}
-exports.DatabaseHelper = DatabaseHelper;

package/dist/database/index.d.ts

@@ -1,20 +0,0 @@
-import SchemaInspector from '@directus/schema';
-import { Knex } from 'knex';
-import type { DatabaseClient } from '../types';
-export default function getDatabase(): Knex;
-export declare function getSchemaInspector(): ReturnType<typeof SchemaInspector>;
-/**
- * Get database version. Value currently exists for MySQL only.
- *
- * @returns Cached database version
- */
-export declare function getDatabaseVersion(): string | null;
-export declare function hasDatabaseConnection(database?: Knex): Promise<boolean>;
-export declare function validateDatabaseConnection(database?: Knex): Promise<void>;
-export declare function getDatabaseClient(database?: Knex): DatabaseClient;
-export declare function isInstalled(): Promise<boolean>;
-export declare function validateMigrations(): Promise<boolean>;
-/**
- * These database extensions should be optional, so we don't throw or return any problem states when they don't
- */
-export declare function validateDatabaseExtensions(): Promise<void>;

package/dist/database/index.js

@@ -1,279 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDatabaseExtensions = exports.validateMigrations = exports.isInstalled = exports.getDatabaseClient = exports.validateDatabaseConnection = exports.hasDatabaseConnection = exports.getDatabaseVersion = exports.getSchemaInspector = void 0;
-const schema_1 = __importDefault(require("@directus/schema"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const knex_1 = require("knex");
-const lodash_1 = require("lodash");
-const path_1 = __importDefault(require("path"));
-const perf_hooks_1 = require("perf_hooks");
-const util_1 = require("util");
-const env_1 = __importDefault(require("../env"));
-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");
-const helpers_1 = require("./helpers");
-let database = null;
-let inspector = null;
-let databaseVersion = null;
-function getDatabase() {
-    if (database) {
-        return database;
-    }
-    const { client, version, searchPath, connectionString, pool: poolConfig = {}, ...connectionConfig } = (0, get_config_from_env_1.getConfigFromEnv)('DB_', ['DB_EXCLUDE_TABLES']);
-    const requiredEnvVars = ['DB_CLIENT'];
-    switch (client) {
-        case 'sqlite3':
-            requiredEnvVars.push('DB_FILENAME');
-            break;
-        case 'oracledb':
-            if (!env_1.default['DB_CONNECT_STRING']) {
-                requiredEnvVars.push('DB_HOST', 'DB_PORT', 'DB_DATABASE', 'DB_USER', 'DB_PASSWORD');
-            }
-            else {
-                requiredEnvVars.push('DB_USER', 'DB_PASSWORD', 'DB_CONNECT_STRING');
-            }
-            break;
-        case 'cockroachdb':
-        case 'pg':
-            if (!connectionString) {
-                requiredEnvVars.push('DB_HOST', 'DB_PORT', 'DB_DATABASE', 'DB_USER');
-            }
-            else {
-                requiredEnvVars.push('DB_CONNECTION_STRING');
-            }
-            break;
-        case 'mssql':
-            if (!env_1.default['DB_TYPE'] || env_1.default['DB_TYPE'] === 'default') {
-                requiredEnvVars.push('DB_HOST', 'DB_PORT', 'DB_DATABASE', 'DB_USER', 'DB_PASSWORD');
-            }
-            break;
-        default:
-            requiredEnvVars.push('DB_HOST', 'DB_PORT', 'DB_DATABASE', 'DB_USER', 'DB_PASSWORD');
-    }
-    (0, validate_env_1.validateEnv)(requiredEnvVars);
-    const knexConfig = {
-        client,
-        version,
-        searchPath,
-        connection: connectionString || connectionConfig,
-        log: {
-            warn: (msg) => {
-                // Ignore warnings about returning not being supported in some DBs
-                if (msg.startsWith('.returning()'))
-                    return;
-                if (msg.endsWith('does not currently support RETURNING clause'))
-                    return;
-                // Ignore warning about MySQL not supporting TRX for DDL
-                if (msg.startsWith('Transaction was implicitly committed, do not mix transactions and DDL with MySQL'))
-                    return;
-                return logger_1.default.warn(msg);
-            },
-            error: (msg) => logger_1.default.error(msg),
-            deprecate: (msg) => logger_1.default.info(msg),
-            debug: (msg) => logger_1.default.debug(msg),
-        },
-        pool: poolConfig,
-    };
-    if (client === 'sqlite3') {
-        knexConfig.useNullAsDefault = true;
-        poolConfig.afterCreate = async (conn, callback) => {
-            logger_1.default.trace('Enabling SQLite Foreign Keys support...');
-            const run = (0, util_1.promisify)(conn.run.bind(conn));
-            await run('PRAGMA foreign_keys = ON');
-            callback(null, conn);
-        };
-    }
-    if (client === 'cockroachdb') {
-        poolConfig.afterCreate = async (conn, callback) => {
-            logger_1.default.trace('Setting CRDB serial_normalization and default_int_size');
-            const run = (0, util_1.promisify)(conn.query.bind(conn));
-            await run('SET serial_normalization = "sql_sequence"');
-            await run('SET default_int_size = 4');
-            callback(null, conn);
-        };
-    }
-    if (client === 'mysql') {
-        poolConfig.afterCreate = async (conn, callback) => {
-            logger_1.default.trace('Retrieving database version');
-            const run = (0, util_1.promisify)(conn.query.bind(conn));
-            const version = await run('SELECT @@version;');
-            databaseVersion = version[0]['@@version'];
-            callback(null, conn);
-        };
-    }
-    if (client === 'mssql') {
-        // This brings MS SQL in line with the other DB vendors. We shouldn't do any automatic
-        // timezone conversion on the database level, especially not when other database vendors don't
-        // act the same
-        (0, lodash_1.merge)(knexConfig, { connection: { options: { useUTC: false } } });
-    }
-    database = (0, knex_1.knex)(knexConfig);
-    validateDatabaseCharset(database);
-    const times = {};
-    database
-        .on('query', (queryInfo) => {
-        times[queryInfo.__knexUid] = perf_hooks_1.performance.now();
-    })
-        .on('query-response', (_response, queryInfo) => {
-        const delta = perf_hooks_1.performance.now() - times[queryInfo.__knexUid];
-        logger_1.default.trace(`[${delta.toFixed(3)}ms] ${queryInfo.sql} [${queryInfo.bindings.join(', ')}]`);
-        delete times[queryInfo.__knexUid];
-    });
-    return database;
-}
-exports.default = getDatabase;
-function getSchemaInspector() {
-    if (inspector) {
-        return inspector;
-    }
-    const database = getDatabase();
-    inspector = (0, schema_1.default)(database);
-    return inspector;
-}
-exports.getSchemaInspector = getSchemaInspector;
-/**
- * Get database version. Value currently exists for MySQL only.
- *
- * @returns Cached database version
- */
-function getDatabaseVersion() {
-    return databaseVersion;
-}
-exports.getDatabaseVersion = getDatabaseVersion;
-async function hasDatabaseConnection(database) {
-    database = database ?? getDatabase();
-    try {
-        if (getDatabaseClient(database) === 'oracle') {
-            await database.raw('select 1 from DUAL');
-        }
-        else {
-            await database.raw('SELECT 1');
-        }
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-exports.hasDatabaseConnection = hasDatabaseConnection;
-async function validateDatabaseConnection(database) {
-    database = database ?? getDatabase();
-    try {
-        if (getDatabaseClient(database) === 'oracle') {
-            await database.raw('select 1 from DUAL');
-        }
-        else {
-            await database.raw('SELECT 1');
-        }
-    }
-    catch (error) {
-        logger_1.default.error(`Can't connect to the database.`);
-        logger_1.default.error(error);
-        process.exit(1);
-    }
-}
-exports.validateDatabaseConnection = validateDatabaseConnection;
-function getDatabaseClient(database) {
-    database = database ?? getDatabase();
-    switch (database.client.constructor.name) {
-        case 'Client_MySQL':
-            return 'mysql';
-        case 'Client_PG':
-            return 'postgres';
-        case 'Client_CockroachDB':
-            return 'cockroachdb';
-        case 'Client_SQLite3':
-            return 'sqlite';
-        case 'Client_Oracledb':
-        case 'Client_Oracle':
-            return 'oracle';
-        case 'Client_MSSQL':
-            return 'mssql';
-        case 'Client_Redshift':
-            return 'redshift';
-    }
-    throw new Error(`Couldn't extract database client`);
-}
-exports.getDatabaseClient = getDatabaseClient;
-async function isInstalled() {
-    const inspector = getSchemaInspector();
-    // The existence of a directus_collections table alone isn't a "proper" check to see if everything
-    // is installed correctly of course, but it's safe enough to assume that this collection only
-    // exists when Directus is properly installed.
-    return await inspector.hasTable('directus_collections');
-}
-exports.isInstalled = isInstalled;
-async function validateMigrations() {
-    const database = getDatabase();
-    try {
-        let migrationFiles = await fs_extra_1.default.readdir(path_1.default.join(__dirname, 'migrations'));
-        const customMigrationsPath = path_1.default.resolve(env_1.default['EXTENSIONS_PATH'], 'migrations');
-        let customMigrationFiles = ((await fs_extra_1.default.pathExists(customMigrationsPath)) && (await fs_extra_1.default.readdir(customMigrationsPath))) || [];
-        migrationFiles = migrationFiles.filter((file) => file.startsWith('run') === false && file.endsWith('.d.ts') === false);
-        customMigrationFiles = customMigrationFiles.filter((file) => file.endsWith('.js'));
-        migrationFiles.push(...customMigrationFiles);
-        const requiredVersions = migrationFiles.map((filePath) => filePath.split('-')[0]);
-        const completedVersions = (await database.select('version').from('directus_migrations')).map(({ version }) => version);
-        return requiredVersions.every((version) => completedVersions.includes(version));
-    }
-    catch (error) {
-        logger_1.default.error(`Database migrations cannot be found`);
-        logger_1.default.error(error);
-        throw process.exit(1);
-    }
-}
-exports.validateMigrations = validateMigrations;
-/**
- * These database extensions should be optional, so we don't throw or return any problem states when they don't
- */
-async function validateDatabaseExtensions() {
-    const database = getDatabase();
-    const client = getDatabaseClient(database);
-    const helpers = (0, helpers_1.getHelpers)(database);
-    const geometrySupport = await helpers.st.supported();
-    if (!geometrySupport) {
-        switch (client) {
-            case 'postgres':
-                logger_1.default.warn(`PostGIS isn't installed. Geometry type support will be limited.`);
-                break;
-            case 'sqlite':
-                logger_1.default.warn(`Spatialite isn't installed. Geometry type support will be limited.`);
-                break;
-            default:
-                logger_1.default.warn(`Geometry type not supported on ${client}`);
-        }
-    }
-}
-exports.validateDatabaseExtensions = validateDatabaseExtensions;
-async function validateDatabaseCharset(database) {
-    database = database ?? getDatabase();
-    if (getDatabaseClient(database) === 'mysql') {
-        const { collation } = await database.select(database.raw(`@@collation_database as collation`)).first();
-        const tables = await database('information_schema.tables')
-            .select({ name: 'TABLE_NAME', collation: 'TABLE_COLLATION' })
-            .where({ TABLE_SCHEMA: env_1.default['DB_DATABASE'] });
-        const columns = await database('information_schema.columns')
-            .select({ table_name: 'TABLE_NAME', name: 'COLUMN_NAME', collation: 'COLLATION_NAME' })
-            .where({ TABLE_SCHEMA: env_1.default['DB_DATABASE'] })
-            .whereNot({ COLLATION_NAME: collation });
-        let inconsistencies = '';
-        for (const table of tables) {
-            const tableColumns = columns.filter((column) => column.table_name === table.name);
-            const tableHasInvalidCollation = table.collation !== collation;
-            if (tableHasInvalidCollation || tableColumns.length > 0) {
-                inconsistencies += `\t\t- Table "${table.name}": "${table.collation}"\n`;
-                for (const column of tableColumns) {
-                    inconsistencies += `\t\t  - Column "${column.name}": "${column.collation}"\n`;
-                }
-            }
-        }
-        if (inconsistencies) {
-            logger_1.default.warn(`Some tables and columns do not match your database's default collation (${collation}):\n${inconsistencies}`);
-        }
-    }
-    return;
-}

package/dist/database/migrations/20201028A-remove-collection-foreign-keys.d.ts

@@ -1,3 +0,0 @@
-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/20201028A-remove-collection-foreign-keys.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.down = exports.up = void 0;
-async function up(knex) {
-    await knex.schema.alterTable('directus_fields', (table) => {
-        table.dropForeign(['collection']);
-    });
-    await knex.schema.alterTable('directus_activity', (table) => {
-        table.dropForeign(['collection']);
-    });
-    await knex.schema.alterTable('directus_permissions', (table) => {
-        table.dropForeign(['collection']);
-    });
-    await knex.schema.alterTable('directus_presets', (table) => {
-        table.dropForeign(['collection']);
-    });
-    await knex.schema.alterTable('directus_relations', (table) => {
-        table.dropForeign(['one_collection']);
-        table.dropForeign(['many_collection']);
-    });
-    await knex.schema.alterTable('directus_revisions', (table) => {
-        table.dropForeign(['collection']);
-    });
-}
-exports.up = up;
-async function down(knex) {
-    await knex.schema.alterTable('directus_fields', (table) => {
-        table.foreign('collection').references('directus_collections.collection');
-    });
-    await knex.schema.alterTable('directus_activity', (table) => {
-        table.foreign('collection').references('directus_collections.collection');
-    });
-    await knex.schema.alterTable('directus_permissions', (table) => {
-        table.foreign('collection').references('directus_collections.collection');
-    });
-    await knex.schema.alterTable('directus_presets', (table) => {
-        table.foreign('collection').references('directus_collections.collection');
-    });
-    await knex.schema.alterTable('directus_relations', (table) => {
-        table.foreign('one_collection').references('directus_collections.collection');
-        table.foreign('many_collection').references('directus_collections.collection');
-    });
-    await knex.schema.alterTable('directus_revisions', (table) => {
-        table.foreign('collection').references('directus_collections.collection');
-    });
-}
-exports.down = down;