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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Martin Adámek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MySqlConnection.d.ts

@@ -0,0 +1,8 @@
+import { AbstractSqlConnection, type Knex } from "@yandjin-mikro-orm/knex";
+export declare class MySqlConnection extends AbstractSqlConnection {
+    createKnex(): void;
+    private patchKnex;
+    getDefaultClientUrl(): string;
+    getConnectionOptions(): Knex.MySqlConnectionConfig;
+    protected transformRawResult<T>(res: any, method: "all" | "get" | "run"): T;
+}

package/MySqlConnection.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlConnection = void 0;
+const knex_1 = require("@yandjin-mikro-orm/knex");
+class MySqlConnection extends knex_1.AbstractSqlConnection {
+    createKnex() {
+        this.patchKnex();
+        this.client = this.createKnexClient("mysql2");
+        this.connected = true;
+    }
+    patchKnex() {
+        const { MySqlColumnCompiler, MySqlQueryCompiler } = knex_1.MonkeyPatchable;
+        // we need the old behaviour to be able to add auto_increment to a column that is already PK
+        MySqlColumnCompiler.prototype.increments = function (options = { primaryKey: true }) {
+            return ("int unsigned not null auto_increment" +
+                (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : ""));
+        };
+        /* istanbul ignore next */
+        MySqlColumnCompiler.prototype.bigincrements = function (options = { primaryKey: true }) {
+            return ("bigint unsigned not null auto_increment" +
+                (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : ""));
+        };
+        // mysql dialect disallows query non scalar params, but we dont use it to execute the query, it always goes through the `platform.formatQuery()`
+        delete MySqlQueryCompiler.prototype.whereBasic;
+        delete MySqlQueryCompiler.prototype.whereRaw;
+    }
+    getDefaultClientUrl() {
+        return "mysql://root@127.0.0.1:3306";
+    }
+    getConnectionOptions() {
+        const ret = super.getConnectionOptions();
+        if (this.config.get("multipleStatements")) {
+            ret.multipleStatements = this.config.get("multipleStatements");
+        }
+        if (this.config.get("forceUtcTimezone")) {
+            ret.timezone = "Z";
+        }
+        if (this.config.get("timezone")) {
+            ret.timezone = this.config.get("timezone");
+        }
+        ret.supportBigNumbers = true;
+        ret.dateStrings = true;
+        return ret;
+    }
+    transformRawResult(res, method) {
+        if (method === "run" &&
+            ["OkPacket", "ResultSetHeader"].includes(res[0].constructor.name)) {
+            return {
+                insertId: res[0].insertId,
+                affectedRows: res[0].affectedRows,
+                rows: [],
+            };
+        }
+        if (method === "get") {
+            return res[0][0];
+        }
+        return res[0];
+    }
+}
+exports.MySqlConnection = MySqlConnection;

package/MySqlDriver.d.ts

@@ -0,0 +1,10 @@
+import type { Configuration, EntityDictionary, NativeInsertUpdateManyOptions, QueryResult } from "@yandjin-mikro-orm/core";
+import { AbstractSqlDriver } from "@yandjin-mikro-orm/knex";
+import { MySqlConnection } from "./MySqlConnection";
+import { MySqlPlatform } from "./MySqlPlatform";
+export declare class MySqlDriver extends AbstractSqlDriver<MySqlConnection, MySqlPlatform> {
+    protected autoIncrementIncrement?: number;
+    constructor(config: Configuration);
+    private getAutoIncrementIncrement;
+    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+}

package/MySqlDriver.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlDriver = void 0;
+const knex_1 = require("@yandjin-mikro-orm/knex");
+const MySqlConnection_1 = require("./MySqlConnection");
+const MySqlPlatform_1 = require("./MySqlPlatform");
+class MySqlDriver extends knex_1.AbstractSqlDriver {
+    autoIncrementIncrement;
+    constructor(config) {
+        super(config, new MySqlPlatform_1.MySqlPlatform(), MySqlConnection_1.MySqlConnection, ["knex", "mysql2"]);
+    }
+    async getAutoIncrementIncrement() {
+        if (this.autoIncrementIncrement == null) {
+            // the increment step may differ when running a cluster, see https://github.com/mikro-orm/mikro-orm/issues/3828
+            const res = await this.connection.execute(`show variables like 'auto_increment_increment'`, [], "get", undefined, { enabled: false });
+            /* istanbul ignore next */
+            this.autoIncrementIncrement = res?.auto_increment_increment
+                ? +res?.auto_increment_increment
+                : 1;
+        }
+        return this.autoIncrementIncrement;
+    }
+    async nativeInsertMany(entityName, data, options = {}) {
+        options.processCollections ??= true;
+        const res = await super.nativeInsertMany(entityName, data, options);
+        const pks = this.getPrimaryKeyFields(entityName);
+        const autoIncrementIncrement = await this.getAutoIncrementIncrement();
+        data.forEach((item, idx) => (res.rows[idx] = {
+            [pks[0]]: item[pks[0]] ??
+                res.insertId + idx * autoIncrementIncrement,
+        }));
+        res.row = res.rows[0];
+        return res;
+    }
+}
+exports.MySqlDriver = MySqlDriver;

package/MySqlExceptionConverter.d.ts

@@ -0,0 +1,9 @@
+import { ExceptionConverter, type Dictionary, type DriverException } from "@yandjin-mikro-orm/core";
+export declare class MySqlExceptionConverter extends ExceptionConverter {
+    /**
+     * @link http://dev.mysql.com/doc/refman/5.7/en/error-messages-client.html
+     * @link http://dev.mysql.com/doc/refman/5.7/en/error-messages-server.html
+     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractMySQLDriver.php
+     */
+    convertException(exception: Error & Dictionary): DriverException;
+}

package/MySqlExceptionConverter.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlExceptionConverter = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+class MySqlExceptionConverter extends core_1.ExceptionConverter {
+    /* istanbul ignore next */
+    /**
+     * @link http://dev.mysql.com/doc/refman/5.7/en/error-messages-client.html
+     * @link http://dev.mysql.com/doc/refman/5.7/en/error-messages-server.html
+     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractMySQLDriver.php
+     */
+    convertException(exception) {
+        switch (exception.errno) {
+            case 1213:
+                return new core_1.DeadlockException(exception);
+            case 1205:
+                return new core_1.LockWaitTimeoutException(exception);
+            case 1050:
+                return new core_1.TableExistsException(exception);
+            case 1051:
+            case 1146:
+                return new core_1.TableNotFoundException(exception);
+            case 1216:
+            case 1217:
+            case 1451:
+            case 1452:
+            case 1701:
+                return new core_1.ForeignKeyConstraintViolationException(exception);
+            case 3819:
+                return new core_1.CheckConstraintViolationException(exception);
+            case 1062:
+            case 1557:
+            case 1569:
+            case 1586:
+                return new core_1.UniqueConstraintViolationException(exception);
+            case 1054:
+            case 1166:
+            case 1611:
+                return new core_1.InvalidFieldNameException(exception);
+            case 1052:
+            case 1060:
+            case 1110:
+                return new core_1.NonUniqueFieldNameException(exception);
+            case 1064:
+            case 1149:
+            case 1287:
+            case 1341:
+            case 1342:
+            case 1343:
+            case 1344:
+            case 1382:
+            case 1479:
+            case 1541:
+            case 1554:
+            case 1626:
+                return new core_1.SyntaxErrorException(exception);
+            case 1044:
+            case 1045:
+            case 1046:
+            case 1049:
+            case 1095:
+            case 1142:
+            case 1143:
+            case 1227:
+            case 1370:
+            case 1429:
+            case 2002:
+            case 2005:
+                return new core_1.ConnectionException(exception);
+            case 1048:
+            case 1121:
+            case 1138:
+            case 1171:
+            case 1252:
+            case 1263:
+            case 1364:
+            case 1566:
+                return new core_1.NotNullConstraintViolationException(exception);
+        }
+        return super.convertException(exception);
+    }
+}
+exports.MySqlExceptionConverter = MySqlExceptionConverter;

package/MySqlMikroORM.d.ts

@@ -0,0 +1,19 @@
+import { MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from "@yandjin-mikro-orm/core";
+import { MySqlDriver } from "./MySqlDriver";
+import type { SqlEntityManager } from "@yandjin-mikro-orm/knex";
+/**
+ * @inheritDoc
+ */
+export declare class MySqlMikroORM<EM extends EntityManager = SqlEntityManager> extends MikroORM<MySqlDriver, EM> {
+    private static DRIVER;
+    /**
+     * @inheritDoc
+     */
+    static init<D extends IDatabaseDriver = MySqlDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    /**
+     * @inheritDoc
+     */
+    static initSync<D extends IDatabaseDriver = MySqlDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
+}
+export type MySqlOptions = Options<MySqlDriver>;
+export declare function defineMySqlConfig(options: MySqlOptions): Options<MySqlDriver, SqlEntityManager<MySqlDriver> & EntityManager<IDatabaseDriver<import("@yandjin-mikro-orm/core").Connection>>>;

package/MySqlMikroORM.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineMySqlConfig = exports.MySqlMikroORM = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const MySqlDriver_1 = require("./MySqlDriver");
+/**
+ * @inheritDoc
+ */
+class MySqlMikroORM extends core_1.MikroORM {
+    static DRIVER = MySqlDriver_1.MySqlDriver;
+    /**
+     * @inheritDoc
+     */
+    static async init(options) {
+        return super.init(options);
+    }
+    /**
+     * @inheritDoc
+     */
+    static initSync(options) {
+        return super.initSync(options);
+    }
+}
+exports.MySqlMikroORM = MySqlMikroORM;
+/* istanbul ignore next */
+function defineMySqlConfig(options) {
+    return (0, core_1.defineConfig)({ driver: MySqlDriver_1.MySqlDriver, ...options });
+}
+exports.defineMySqlConfig = defineMySqlConfig;

package/MySqlPlatform.d.ts

@@ -0,0 +1,25 @@
+import { AbstractSqlPlatform, type IndexDef } from "@yandjin-mikro-orm/knex";
+import { MySqlSchemaHelper } from "./MySqlSchemaHelper";
+import { MySqlExceptionConverter } from "./MySqlExceptionConverter";
+import { type SimpleColumnMeta, type Type, type TransformContext } from "@yandjin-mikro-orm/core";
+export declare class MySqlPlatform extends AbstractSqlPlatform {
+    protected readonly schemaHelper: MySqlSchemaHelper;
+    protected readonly exceptionConverter: MySqlExceptionConverter;
+    getDefaultCharset(): string;
+    convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
+    getJsonIndexDefinition(index: IndexDef): string[];
+    getBooleanTypeDeclarationSQL(): string;
+    getDefaultMappedType(type: string): Type<unknown>;
+    supportsUnsigned(): boolean;
+    /**
+     * Returns the default name of index for the given columns
+     * cannot go past 64 character length for identifiers in MySQL
+     */
+    getIndexName(tableName: string, columns: string[], type: "index" | "unique" | "foreign" | "primary" | "sequence"): string;
+    getDefaultPrimaryName(tableName: string, columns: string[]): string;
+    supportsCreatingFullTextIndex(): boolean;
+    getFullTextWhereClause(): string;
+    getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
+    private readonly ORDER_BY_NULLS_TRANSLATE;
+    getOrderByExpression(column: string, direction: string): string[];
+}

package/MySqlPlatform.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlPlatform = void 0;
+const knex_1 = require("@yandjin-mikro-orm/knex");
+const MySqlSchemaHelper_1 = require("./MySqlSchemaHelper");
+const MySqlExceptionConverter_1 = require("./MySqlExceptionConverter");
+const core_1 = require("@yandjin-mikro-orm/core");
+class MySqlPlatform extends knex_1.AbstractSqlPlatform {
+    schemaHelper = new MySqlSchemaHelper_1.MySqlSchemaHelper(this);
+    exceptionConverter = new MySqlExceptionConverter_1.MySqlExceptionConverter();
+    getDefaultCharset() {
+        return "utf8mb4";
+    }
+    convertJsonToDatabaseValue(value, context) {
+        if (context?.mode === "query") {
+            return value;
+        }
+        return JSON.stringify(value);
+    }
+    getJsonIndexDefinition(index) {
+        return index.columnNames.map((column) => {
+            const [root, ...path] = column.split(".");
+            return `json_value(${this.quoteIdentifier(root)}, '$.${path.join(".")}' returning ${index.options?.returning ?? "char(255)"})`;
+        });
+    }
+    getBooleanTypeDeclarationSQL() {
+        return "tinyint(1)";
+    }
+    getDefaultMappedType(type) {
+        if (type === "tinyint(1)") {
+            return super.getDefaultMappedType("boolean");
+        }
+        const normalizedType = this.extractSimpleType(type);
+        const map = {
+            int: "integer",
+            timestamp: "datetime",
+        };
+        return super.getDefaultMappedType(map[normalizedType] ?? type);
+    }
+    supportsUnsigned() {
+        return true;
+    }
+    /**
+     * Returns the default name of index for the given columns
+     * cannot go past 64 character length for identifiers in MySQL
+     */
+    getIndexName(tableName, columns, type) {
+        if (type === "primary") {
+            return this.getDefaultPrimaryName(tableName, columns);
+        }
+        const indexName = super.getIndexName(tableName, columns, type);
+        if (indexName.length > 64) {
+            return `${indexName.substring(0, 56 - type.length)}_${core_1.Utils.hash(indexName, 5)}_${type}`;
+        }
+        return indexName;
+    }
+    getDefaultPrimaryName(tableName, columns) {
+        return "PRIMARY"; // https://dev.mysql.com/doc/refman/8.0/en/create-table.html#create-table-indexes-keys
+    }
+    supportsCreatingFullTextIndex() {
+        return true;
+    }
+    getFullTextWhereClause() {
+        return `match(:column:) against (:query in boolean mode)`;
+    }
+    getFullTextIndexExpression(indexName, schemaName, tableName, columns) {
+        /* istanbul ignore next */
+        const quotedTableName = this.quoteIdentifier(schemaName ? `${schemaName}.${tableName}` : tableName);
+        const quotedColumnNames = columns.map((c) => this.quoteIdentifier(c.name));
+        const quotedIndexName = this.quoteIdentifier(indexName);
+        return `alter table ${quotedTableName} add fulltext index ${quotedIndexName}(${quotedColumnNames.join(",")})`;
+    }
+    ORDER_BY_NULLS_TRANSLATE = {
+        [knex_1.QueryOrder.asc_nulls_first]: "is not null",
+        [knex_1.QueryOrder.asc_nulls_last]: "is null",
+        [knex_1.QueryOrder.desc_nulls_first]: "is not null",
+        [knex_1.QueryOrder.desc_nulls_last]: "is null",
+    };
+    getOrderByExpression(column, direction) {
+        const ret = [];
+        const dir = direction.toLowerCase();
+        if (dir in this.ORDER_BY_NULLS_TRANSLATE) {
+            ret.push(`${column} ${this.ORDER_BY_NULLS_TRANSLATE[dir]}`);
+        }
+        ret.push(`${column} ${dir.replace(/(\s|nulls|first|last)*/gi, "")}`);
+        return ret;
+    }
+}
+exports.MySqlPlatform = MySqlPlatform;

package/MySqlSchemaHelper.d.ts

@@ -0,0 +1,38 @@
+import { SchemaHelper, type AbstractSqlConnection, type CheckDef, type Column, type IndexDef, type Knex, type TableDifference, type DatabaseTable, type DatabaseSchema, type Table, type ForeignKey } from "@yandjin-mikro-orm/knex";
+import { type Dictionary, type Type } from "@yandjin-mikro-orm/core";
+export declare class MySqlSchemaHelper extends SchemaHelper {
+    private readonly _cache;
+    static readonly DEFAULT_VALUES: {
+        "now()": string[];
+        "current_timestamp(?)": string[];
+        "0": string[];
+    };
+    getSchemaBeginning(charset: string): string;
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    finalizeTable(table: Knex.CreateTableBuilder, charset: string, collate?: string): void;
+    getListTablesSQL(): string;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
+    getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
+    getAllColumns(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Column[]>>;
+    getAllChecks(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<CheckDef[]>>;
+    getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<ForeignKey>>>;
+    getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
+    configureColumnDefault(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
+    getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;
+    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
+    getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
+    createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>): Knex.ColumnBuilder;
+    configureColumn(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
+    private getColumnDeclarationSQL;
+    getForeignKeysSQL(tableName: string, schemaName?: string): string;
+    getAllEnumDefinitions(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<string[]>>>;
+    private supportsCheckConstraints;
+    private getChecksSQL;
+    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName: string, columns?: Column[]): Promise<CheckDef[]>;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Column[]>;
+    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
+    normalizeDefaultValue(defaultValue: string, length: number): string | number;
+    protected wrap(val: string | undefined, type: Type<unknown>): string | undefined;
+}