@yandjin-mikro-orm/knex 6.1.4-rc-sti-changes-1

package/schema/SchemaHelper.d.ts

@@ -0,0 +1,56 @@
+import type { Knex } from "knex";
+import { type Connection, type Dictionary } from "@yandjin-mikro-orm/core";
+import type { AbstractSqlConnection } from "../AbstractSqlConnection";
+import type { AbstractSqlPlatform } from "../AbstractSqlPlatform";
+import type { CheckDef, Column, IndexDef, Table, TableDifference } from "../typings";
+import type { DatabaseTable } from "./DatabaseTable";
+import type { DatabaseSchema } from "./DatabaseSchema";
+export declare abstract class SchemaHelper {
+    protected readonly platform: AbstractSqlPlatform;
+    constructor(platform: AbstractSqlPlatform);
+    getSchemaBeginning(charset: string): string;
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    getSchemaEnd(): string;
+    finalizeTable(table: Knex.TableBuilder, charset: string, collate?: string): void;
+    supportsSchemaConstraints(): boolean;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;
+    getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Dictionary>;
+    protected getTableKey(t: Table): string;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    getDropNativeEnumSQL(name: string, schema?: string): string;
+    getAlterNativeEnumSQL(name: string, schema?: string, value?: string): string;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
+    getListTablesSQL(schemaName?: string): string;
+    getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
+    getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
+    getDropIndexSQL(tableName: string, index: IndexDef): string;
+    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
+    hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
+    createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>, alter?: boolean): Knex.ColumnBuilder;
+    configureColumn(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
+    configureColumnDefault(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
+    getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
+    getPostAlterTable(tableDiff: TableDifference, safe: boolean): string;
+    getAlterColumnAutoincrement(tableName: string, column: Column, schemaName?: string): string;
+    getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
+    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
+    getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Column[]>;
+    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
+    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string, columns?: Column[]): Promise<CheckDef[]>;
+    protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
+    getForeignKeysSQL(tableName: string, schemaName?: string): string;
+    mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
+    normalizeDefaultValue(defaultValue: string, length?: number, defaultValues?: Dictionary<string[]>): string | number;
+    getCreateDatabaseSQL(name: string): string;
+    getDropDatabaseSQL(name: string): string;
+    getDatabaseExistsSQL(name: string): string;
+    getDatabaseNotExistsError(dbName: string): string;
+    getManagementDbName(): string;
+    getDefaultEmptyString(): string;
+    databaseExists(connection: Connection, name: string): Promise<boolean>;
+    /**
+     * Uses `raw` method injected in `AbstractSqlConnection` to allow adding custom queries inside alter statements.
+     */
+    pushTableQuery(table: Knex.TableBuilder, expression: string, grouping?: string): void;
+}

package/schema/SchemaHelper.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaHelper = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+class SchemaHelper {
+    platform;
+    constructor(platform) {
+        this.platform = platform;
+    }
+    getSchemaBeginning(charset) {
+        return `${this.disableForeignKeysSQL()}\n\n`;
+    }
+    disableForeignKeysSQL() {
+        return "";
+    }
+    enableForeignKeysSQL() {
+        return "";
+    }
+    getSchemaEnd() {
+        return `${this.enableForeignKeysSQL()}\n`;
+    }
+    finalizeTable(table, charset, collate) {
+        //
+    }
+    supportsSchemaConstraints() {
+        return true;
+    }
+    async getPrimaryKeys(connection, indexes = [], tableName, schemaName) {
+        const pks = indexes.filter((i) => i.primary).map((pk) => pk.columnNames);
+        return core_1.Utils.flatten(pks);
+    }
+    async getForeignKeys(connection, tableName, schemaName) {
+        const fks = await connection.execute(this.getForeignKeysSQL(tableName, schemaName));
+        return this.mapForeignKeys(fks, tableName, schemaName);
+    }
+    getTableKey(t) {
+        const unquote = (str) => str.replace(/['"`]/g, "");
+        const parts = t.table_name.split(".");
+        if (parts.length > 1) {
+            return `${unquote(parts[0])}.${unquote(parts[1])}`;
+        }
+        if (t.schema_name) {
+            return `${unquote(t.schema_name)}.${unquote(t.table_name)}`;
+        }
+        return unquote(t.table_name);
+    }
+    async getEnumDefinitions(connection, checks, tableName, schemaName) {
+        return {};
+    }
+    getDropNativeEnumSQL(name, schema) {
+        throw new Error("Not supported by given driver");
+    }
+    getAlterNativeEnumSQL(name, schema, value) {
+        throw new Error("Not supported by given driver");
+    }
+    async loadInformationSchema(schema, connection, tables, schemas) {
+        for (const t of tables) {
+            const table = schema.addTable(t.table_name, t.schema_name);
+            table.comment = t.table_comment;
+            const cols = await this.getColumns(connection, table.name, table.schema);
+            const indexes = await this.getIndexes(connection, table.name, table.schema);
+            const checks = await this.getChecks(connection, table.name, table.schema, cols);
+            const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema);
+            const fks = await this.getForeignKeys(connection, table.name, table.schema);
+            const enums = await this.getEnumDefinitions(connection, checks, table.name, table.schema);
+            table.init(cols, indexes, checks, pks, fks, enums);
+        }
+    }
+    getListTablesSQL(schemaName) {
+        throw new Error("Not supported by given driver");
+    }
+    getRenameColumnSQL(tableName, oldColumnName, to, schemaName) {
+        tableName = this.platform.quoteIdentifier(tableName);
+        oldColumnName = this.platform.quoteIdentifier(oldColumnName);
+        const columnName = this.platform.quoteIdentifier(to.name);
+        const schemaReference = schemaName !== undefined && schemaName !== "public"
+            ? '"' + schemaName + '".'
+            : "";
+        const tableReference = schemaReference + tableName;
+        return `alter table ${tableReference} rename column ${oldColumnName} to ${columnName}`;
+    }
+    getCreateIndexSQL(tableName, index, partialExpression = false) {
+        /* istanbul ignore next */
+        if (index.expression && !partialExpression) {
+            return index.expression;
+        }
+        tableName = this.platform.quoteIdentifier(tableName);
+        const keyName = this.platform.quoteIdentifier(index.keyName);
+        const sql = `create ${index.unique ? "unique " : ""}index ${keyName} on ${tableName} `;
+        if (index.expression && partialExpression) {
+            return `${sql}(${index.expression})`;
+        }
+        return `${sql}(${index.columnNames.map((c) => this.platform.quoteIdentifier(c)).join(", ")})`;
+    }
+    getDropIndexSQL(tableName, index) {
+        return `drop index ${this.platform.quoteIdentifier(index.keyName)}`;
+    }
+    getRenameIndexSQL(tableName, index, oldIndexName) {
+        return [
+            this.getDropIndexSQL(tableName, { ...index, keyName: oldIndexName }),
+            this.getCreateIndexSQL(tableName, index),
+        ].join(";\n");
+    }
+    hasNonDefaultPrimaryKeyName(table) {
+        const pkIndex = table.getPrimaryKey();
+        if (!pkIndex || !this.platform.supportsCustomPrimaryKeyNames()) {
+            return false;
+        }
+        const defaultName = this.platform.getDefaultPrimaryName(table.name, pkIndex.columnNames);
+        return pkIndex?.keyName !== defaultName;
+    }
+    createTableColumn(table, column, fromTable, changedProperties, alter) {
+        const compositePK = fromTable.getPrimaryKey()?.composite;
+        if (column.autoincrement &&
+            !column.generated &&
+            !compositePK &&
+            (!changedProperties ||
+                changedProperties.has("autoincrement") ||
+                changedProperties.has("type"))) {
+            const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(fromTable);
+            if (column.mappedType instanceof core_1.BigIntType) {
+                return table.bigIncrements(column.name, { primaryKey });
+            }
+            return table.increments(column.name, { primaryKey });
+        }
+        if (column.mappedType instanceof core_1.EnumType &&
+            column.enumItems?.every((item) => core_1.Utils.isString(item))) {
+            return table.enum(column.name, column.enumItems);
+        }
+        let columnType = column.type;
+        if (column.generated) {
+            columnType += ` generated always as ${column.generated}`;
+        }
+        return table.specificType(column.name, columnType);
+    }
+    configureColumn(column, col, knex, changedProperties) {
+        const guard = (key) => !changedProperties || changedProperties.has(key);
+        core_1.Utils.runIfNotEmpty(() => col.nullable(), column.nullable && guard("nullable"));
+        core_1.Utils.runIfNotEmpty(() => col.notNullable(), !column.nullable && !column.generated);
+        core_1.Utils.runIfNotEmpty(() => col.unsigned(), column.unsigned);
+        core_1.Utils.runIfNotEmpty(() => col.comment(column.comment), column.comment);
+        this.configureColumnDefault(column, col, knex, changedProperties);
+        return col;
+    }
+    configureColumnDefault(column, col, knex, changedProperties) {
+        const guard = (key) => !changedProperties || changedProperties.has(key);
+        if (changedProperties) {
+            core_1.Utils.runIfNotEmpty(() => col.defaultTo(column.default == null ? null : knex.raw(column.default)), guard("default"));
+        }
+        else {
+            core_1.Utils.runIfNotEmpty(() => col.defaultTo(knex.raw(column.default)), column.default != null && column.default !== "null");
+        }
+        return col;
+    }
+    getPreAlterTable(tableDiff, safe) {
+        return "";
+    }
+    getPostAlterTable(tableDiff, safe) {
+        return "";
+    }
+    getAlterColumnAutoincrement(tableName, column, schemaName) {
+        return "";
+    }
+    getChangeColumnCommentSQL(tableName, to, schemaName) {
+        return "";
+    }
+    async getNamespaces(connection) {
+        return [];
+    }
+    async getColumns(connection, tableName, schemaName) {
+        throw new Error("Not supported by given driver");
+    }
+    async getIndexes(connection, tableName, schemaName) {
+        throw new Error("Not supported by given driver");
+    }
+    async getChecks(connection, tableName, schemaName, columns) {
+        throw new Error("Not supported by given driver");
+    }
+    async mapIndexes(indexes) {
+        const map = {};
+        indexes.forEach((index) => {
+            if (map[index.keyName]) {
+                map[index.keyName].composite = true;
+                map[index.keyName].columnNames.push(index.columnNames[0]);
+            }
+            else {
+                map[index.keyName] = index;
+            }
+        });
+        return Object.values(map);
+    }
+    getForeignKeysSQL(tableName, schemaName) {
+        throw new Error("Not supported by given driver");
+    }
+    mapForeignKeys(fks, tableName, schemaName) {
+        return fks.reduce((ret, fk) => {
+            if (ret[fk.constraint_name]) {
+                ret[fk.constraint_name].columnNames.push(fk.column_name);
+                ret[fk.constraint_name].referencedColumnNames.push(fk.referenced_column_name);
+            }
+            else {
+                ret[fk.constraint_name] = {
+                    columnNames: [fk.column_name],
+                    constraintName: fk.constraint_name,
+                    localTableName: schemaName ? `${schemaName}.${tableName}` : tableName,
+                    referencedTableName: fk.referenced_schema_name
+                        ? `${fk.referenced_schema_name}.${fk.referenced_table_name}`
+                        : fk.referenced_table_name,
+                    referencedColumnNames: [fk.referenced_column_name],
+                    updateRule: fk.update_rule.toLowerCase(),
+                    deleteRule: fk.delete_rule.toLowerCase(),
+                };
+            }
+            return ret;
+        }, {});
+    }
+    normalizeDefaultValue(defaultValue, length, defaultValues = {}) {
+        if (defaultValue == null) {
+            return defaultValue;
+        }
+        const raw = core_1.RawQueryFragment.getKnownFragment(defaultValue);
+        if (raw) {
+            return this.platform.formatQuery(raw.sql, raw.params);
+        }
+        const genericValue = defaultValue.replace(/\(\d+\)/, "(?)").toLowerCase();
+        const norm = defaultValues[genericValue];
+        if (!norm) {
+            return defaultValue;
+        }
+        return norm[0].replace("(?)", length != null ? `(${length})` : "");
+    }
+    getCreateDatabaseSQL(name) {
+        return `create database ${name}`;
+    }
+    getDropDatabaseSQL(name) {
+        return `drop database if exists ${name}`;
+    }
+    getDatabaseExistsSQL(name) {
+        return `select 1 from information_schema.schemata where schema_name = '${name}'`;
+    }
+    getDatabaseNotExistsError(dbName) {
+        return `Unknown database '${dbName}'`;
+    }
+    getManagementDbName() {
+        return "information_schema";
+    }
+    getDefaultEmptyString() {
+        return "''";
+    }
+    async databaseExists(connection, name) {
+        try {
+            const res = await connection.execute(this.getDatabaseExistsSQL(name));
+            return res.length > 0;
+        }
+        catch (e) {
+            if (e instanceof Error &&
+                e.message.includes(this.getDatabaseNotExistsError(name))) {
+                return false;
+            }
+            throw e;
+        }
+    }
+    /**
+     * Uses `raw` method injected in `AbstractSqlConnection` to allow adding custom queries inside alter statements.
+     */
+    pushTableQuery(table, expression, grouping = "alterTable") {
+        table._statements.push({
+            grouping,
+            method: "raw",
+            args: [expression],
+        });
+    }
+}
+exports.SchemaHelper = SchemaHelper;

package/schema/SqlSchemaGenerator.d.ts

@@ -0,0 +1,63 @@
+import { AbstractSchemaGenerator, type MikroORM, type ISchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type EnsureDatabaseOptions, type DropSchemaOptions, type UpdateSchemaOptions } from "@yandjin-mikro-orm/core";
+import type { SchemaDifference } from "../typings";
+import { DatabaseSchema } from "./DatabaseSchema";
+import type { AbstractSqlDriver } from "../AbstractSqlDriver";
+export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
+    private readonly helper;
+    private readonly options;
+    protected lastEnsuredDatabase?: string;
+    static register(orm: MikroORM): void;
+    createSchema(options?: CreateSchemaOptions): Promise<void>;
+    /**
+     * Returns true if the database was created.
+     */
+    ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
+    getTargetSchema(schema?: string): DatabaseSchema;
+    getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
+    dropSchema(options?: DropSchemaOptions): Promise<void>;
+    clearDatabase(options?: ClearDatabaseOptions): Promise<void>;
+    getDropSchemaSQL(options?: Omit<DropSchemaOptions, "dropDb">): Promise<string>;
+    private getSchemaName;
+    updateSchema(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<void>;
+    getUpdateSchemaSQL(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<string>;
+    getUpdateSchemaMigrationSQL(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<{
+        up: string;
+        down: string;
+    }>;
+    private prepareSchemaForComparison;
+    diffToSQL(schemaDiff: SchemaDifference, options: {
+        wrap?: boolean;
+        safe?: boolean;
+        dropTables?: boolean;
+        schema?: string;
+    }): Promise<string>;
+    private getReferencedTableName;
+    private createForeignKey;
+    /**
+     * We need to drop foreign keys first for all tables to allow dropping PK constraints.
+     */
+    private preAlterTable;
+    private postAlterTable;
+    private splitTableName;
+    private alterTable;
+    /**
+     * creates new database and connects to it
+     */
+    createDatabase(name: string): Promise<void>;
+    dropDatabase(name?: string): Promise<void>;
+    execute(sql: string, options?: {
+        wrap?: boolean;
+    }): Promise<void>;
+    private wrapSchema;
+    private createSchemaBuilder;
+    private createTable;
+    private createIndex;
+    private dropIndex;
+    private createCheck;
+    private dropCheck;
+    private dropTable;
+    private createForeignKeys;
+    private dump;
+    private get knex();
+}
+export { SqlSchemaGenerator as SchemaGenerator };