@mikro-orm/mariadb 7.0.3-dev.9 → 7.0.3

package/MariaDbDriver.d.ts

@@ -1,13 +1,29 @@
-import { type AnyEntity, type Configuration, type ConnectionType, type LoggingOptions, type Transaction, type Constructor, type EntityName } from '@mikro-orm/core';
+import {
+  type AnyEntity,
+  type Configuration,
+  type ConnectionType,
+  type LoggingOptions,
+  type Transaction,
+  type Constructor,
+  type EntityName,
+} from '@mikro-orm/core';
 import { MySqlDriver, type SqlEntityManager } from '@mikro-orm/mysql';
 import { MariaDbPlatform } from './MariaDbPlatform.js';
 import { MariaDbQueryBuilder } from './MariaDbQueryBuilder.js';
 import { MariaDbMikroORM } from './MariaDbMikroORM.js';
 /** Database driver for MariaDB, extending the MySQL driver with MariaDB-specific behavior. */
 export declare class MariaDbDriver extends MySqlDriver {
-    readonly platform: MariaDbPlatform;
-    constructor(config: Configuration);
-    createQueryBuilder<T extends AnyEntity<T>>(entityName: EntityName<T>, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): MariaDbQueryBuilder<T, any, any, any>;
-    /** @inheritDoc */
-    getORMClass(): Constructor<MariaDbMikroORM>;
+  readonly platform: MariaDbPlatform;
+  constructor(config: Configuration);
+  createQueryBuilder<T extends AnyEntity<T>>(
+    entityName: EntityName<T>,
+    ctx?: Transaction,
+    preferredConnectionType?: ConnectionType,
+    convertCustomTypes?: boolean,
+    loggerContext?: LoggingOptions,
+    alias?: string,
+    em?: SqlEntityManager,
+  ): MariaDbQueryBuilder<T, any, any, any>;
+  /** @inheritDoc */
+  getORMClass(): Constructor<MariaDbMikroORM>;
 }

package/MariaDbDriver.js

@@ -1,27 +1,27 @@
-import { QueryFlag, } from '@mikro-orm/core';
+import { QueryFlag } from '@mikro-orm/core';
 import { MySqlDriver } from '@mikro-orm/mysql';
 import { MariaDbPlatform } from './MariaDbPlatform.js';
 import { MariaDbQueryBuilder } from './MariaDbQueryBuilder.js';
 import { MariaDbMikroORM } from './MariaDbMikroORM.js';
 /** Database driver for MariaDB, extending the MySQL driver with MariaDB-specific behavior. */
 export class MariaDbDriver extends MySqlDriver {
-    constructor(config) {
-        super(config);
-        this.platform = new MariaDbPlatform();
-    }
-    createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext, alias, em) {
-        // do not compute the connectionType if EM is provided as it will be computed from it in the QB later on
-        const connectionType = em
-            ? preferredConnectionType
-            : this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
-        const qb = new MariaDbQueryBuilder(entityName, this.metadata, this, ctx, alias, connectionType, em, loggerContext);
-        if (!convertCustomTypes) {
-            qb.unsetFlag(QueryFlag.CONVERT_CUSTOM_TYPES);
-        }
-        return qb;
-    }
-    /** @inheritDoc */
-    getORMClass() {
-        return MariaDbMikroORM;
+  constructor(config) {
+    super(config);
+    this.platform = new MariaDbPlatform();
+  }
+  createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext, alias, em) {
+    // do not compute the connectionType if EM is provided as it will be computed from it in the QB later on
+    const connectionType = em
+      ? preferredConnectionType
+      : this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
+    const qb = new MariaDbQueryBuilder(entityName, this.metadata, this, ctx, alias, connectionType, em, loggerContext);
+    if (!convertCustomTypes) {
+      qb.unsetFlag(QueryFlag.CONVERT_CUSTOM_TYPES);
     }
+    return qb;
+  }
+  /** @inheritDoc */
+  getORMClass() {
+    return MariaDbMikroORM;
+  }
 }

package/MariaDbMikroORM.d.ts

@@ -1,20 +1,58 @@
-import { type AnyEntity, type EntityClass, type EntitySchema, MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
+import {
+  type AnyEntity,
+  type EntityClass,
+  type EntitySchema,
+  MikroORM,
+  type Options,
+  type IDatabaseDriver,
+  type EntityManager,
+  type EntityManagerType,
+} from '@mikro-orm/core';
 import type { SqlEntityManager } from '@mikro-orm/mysql';
 import { MariaDbDriver } from './MariaDbDriver.js';
 /** Configuration options for the MariaDB driver. */
-export type MariaDbOptions<EM extends SqlEntityManager<MariaDbDriver> = SqlEntityManager<MariaDbDriver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Partial<Options<MariaDbDriver, EM, Entities>>;
+export type MariaDbOptions<
+  EM extends SqlEntityManager<MariaDbDriver> = SqlEntityManager<MariaDbDriver>,
+  Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (
+    | string
+    | EntityClass<AnyEntity>
+    | EntitySchema
+  )[],
+> = Partial<Options<MariaDbDriver, EM, Entities>>;
 /** Creates a type-safe configuration object for the MariaDB driver. */
-export declare function defineMariaDbConfig<EM extends SqlEntityManager<MariaDbDriver> = SqlEntityManager<MariaDbDriver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<MariaDbDriver, EM, Entities>>): Partial<Options<MariaDbDriver, EM, Entities>>;
+export declare function defineMariaDbConfig<
+  EM extends SqlEntityManager<MariaDbDriver> = SqlEntityManager<MariaDbDriver>,
+  Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (
+    | string
+    | EntityClass<AnyEntity>
+    | EntitySchema
+  )[],
+>(options: Partial<Options<MariaDbDriver, EM, Entities>>): Partial<Options<MariaDbDriver, EM, Entities>>;
 /**
  * @inheritDoc
  */
-export declare class MariaDbMikroORM<EM extends SqlEntityManager<MariaDbDriver> = SqlEntityManager<MariaDbDriver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<MariaDbDriver, EM, Entities> {
-    /**
-     * @inheritDoc
-     */
-    static init<D extends IDatabaseDriver = MariaDbDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Promise<MikroORM<D, EM, Entities>>;
-    /**
-     * @inheritDoc
-     */
-    constructor(options: Partial<Options<MariaDbDriver, EM, Entities>>);
+export declare class MariaDbMikroORM<
+  EM extends SqlEntityManager<MariaDbDriver> = SqlEntityManager<MariaDbDriver>,
+  Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (
+    | string
+    | EntityClass<AnyEntity>
+    | EntitySchema
+  )[],
+> extends MikroORM<MariaDbDriver, EM, Entities> {
+  /**
+   * @inheritDoc
+   */
+  static init<
+    D extends IDatabaseDriver = MariaDbDriver,
+    EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>,
+    Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (
+      | string
+      | EntityClass<AnyEntity>
+      | EntitySchema
+    )[],
+  >(options: Partial<Options<D, EM, Entities>>): Promise<MikroORM<D, EM, Entities>>;
+  /**
+   * @inheritDoc
+   */
+  constructor(options: Partial<Options<MariaDbDriver, EM, Entities>>);
 }

package/MariaDbMikroORM.js

@@ -1,23 +1,23 @@
-import { defineConfig, MikroORM, } from '@mikro-orm/core';
+import { defineConfig, MikroORM } from '@mikro-orm/core';
 import { MariaDbDriver } from './MariaDbDriver.js';
 /** Creates a type-safe configuration object for the MariaDB driver. */
 export function defineMariaDbConfig(options) {
-    return defineConfig({ driver: MariaDbDriver, ...options });
+  return defineConfig({ driver: MariaDbDriver, ...options });
 }
 /**
  * @inheritDoc
  */
 export class MariaDbMikroORM extends MikroORM {
-    /**
-     * @inheritDoc
-     */
-    static async init(options) {
-        return super.init(defineMariaDbConfig(options));
-    }
-    /**
-     * @inheritDoc
-     */
-    constructor(options) {
-        super(defineMariaDbConfig(options));
-    }
+  /**
+   * @inheritDoc
+   */
+  static async init(options) {
+    return super.init(defineMariaDbConfig(options));
+  }
+  /**
+   * @inheritDoc
+   */
+  constructor(options) {
+    super(defineMariaDbConfig(options));
+  }
 }

package/MariaDbPlatform.d.ts

@@ -2,7 +2,7 @@ import { MySqlPlatform, type TransformContext } from '@mikro-orm/mysql';
 import { MariaDbSchemaHelper } from './MariaDbSchemaHelper.js';
 /** Platform implementation for MariaDB. */
 export declare class MariaDbPlatform extends MySqlPlatform {
-    protected readonly schemaHelper: MariaDbSchemaHelper;
-    convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
-    convertsJsonAutomatically(): boolean;
+  protected readonly schemaHelper: MariaDbSchemaHelper;
+  convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
+  convertsJsonAutomatically(): boolean;
 }

package/MariaDbPlatform.js

@@ -2,14 +2,14 @@ import { MySqlPlatform } from '@mikro-orm/mysql';
 import { MariaDbSchemaHelper } from './MariaDbSchemaHelper.js';
 /** Platform implementation for MariaDB. */
 export class MariaDbPlatform extends MySqlPlatform {
-    schemaHelper = new MariaDbSchemaHelper(this);
-    convertJsonToDatabaseValue(value, context) {
-        if (context?.mode === 'hydration') {
-            return value;
-        }
-        return JSON.stringify(value);
-    }
-    convertsJsonAutomatically() {
-        return false;
+  schemaHelper = new MariaDbSchemaHelper(this);
+  convertJsonToDatabaseValue(value, context) {
+    if (context?.mode === 'hydration') {
+      return value;
     }
+    return JSON.stringify(value);
+  }
+  convertsJsonAutomatically() {
+    return false;
+  }
 }

package/MariaDbQueryBuilder.d.ts

@@ -3,6 +3,11 @@ import { QueryBuilder } from '@mikro-orm/mysql';
 /**
  * @inheritDoc
  */
-export declare class MariaDbQueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never> extends QueryBuilder<Entity, RootAlias, Hint, Context> {
-    protected wrapPaginateSubQuery(meta: EntityMetadata): void;
+export declare class MariaDbQueryBuilder<
+  Entity extends object = AnyEntity,
+  RootAlias extends string = never,
+  Hint extends string = never,
+  Context extends object = never,
+> extends QueryBuilder<Entity, RootAlias, Hint, Context> {
+  protected wrapPaginateSubQuery(meta: EntityMetadata): void;
 }

package/MariaDbQueryBuilder.js

@@ -4,83 +4,80 @@ import { QueryBuilder } from '@mikro-orm/mysql';
  * @inheritDoc
  */
 export class MariaDbQueryBuilder extends QueryBuilder {
-    wrapPaginateSubQuery(meta) {
-        const pks = this.prepareFields(meta.primaryKeys, 'sub-query');
-        const quotedPKs = pks.map(pk => this.platform.quoteIdentifier(pk));
-        const subQuery = this.clone(['orderBy', 'fields'])
-            .select(pks)
-            .groupBy(pks)
-            .limit(this.state.limit);
-        // revert the on conditions added via populateWhere, we want to apply those only once
-        Object.values(subQuery.state.joins).forEach(join => (join.cond = join.cond_ ?? {}));
-        if (this.state.offset) {
-            subQuery.offset(this.state.offset);
-        }
-        const addToSelect = [];
-        if (this.state.orderBy.length > 0) {
-            const orderBy = [];
-            for (const orderMap of this.state.orderBy) {
-                for (const field of Utils.getObjectQueryKeys(orderMap)) {
-                    const direction = orderMap[field];
-                    if (RawQueryFragment.isKnownFragmentSymbol(field)) {
-                        orderBy.push({ [field]: direction });
-                        continue;
-                    }
-                    const [a, f] = this.helper.splitField(field);
-                    const prop = this.helper.getProperty(f, a);
-                    const type = this.platform.castColumn(prop);
-                    const fieldName = this.helper.mapper(field, this.type, undefined, null);
-                    if (!prop?.persist && !prop?.formula && !pks.includes(fieldName)) {
-                        addToSelect.push(fieldName);
-                    }
-                    const key = raw(`min(${this.platform.quoteIdentifier(fieldName)}${type})`);
-                    orderBy.push({ [key]: direction });
-                }
-            }
-            subQuery.orderBy(orderBy);
+  wrapPaginateSubQuery(meta) {
+    const pks = this.prepareFields(meta.primaryKeys, 'sub-query');
+    const quotedPKs = pks.map(pk => this.platform.quoteIdentifier(pk));
+    const subQuery = this.clone(['orderBy', 'fields']).select(pks).groupBy(pks).limit(this.state.limit);
+    // revert the on conditions added via populateWhere, we want to apply those only once
+    Object.values(subQuery.state.joins).forEach(join => (join.cond = join.cond_ ?? {}));
+    if (this.state.offset) {
+      subQuery.offset(this.state.offset);
+    }
+    const addToSelect = [];
+    if (this.state.orderBy.length > 0) {
+      const orderBy = [];
+      for (const orderMap of this.state.orderBy) {
+        for (const field of Utils.getObjectQueryKeys(orderMap)) {
+          const direction = orderMap[field];
+          if (RawQueryFragment.isKnownFragmentSymbol(field)) {
+            orderBy.push({ [field]: direction });
+            continue;
+          }
+          const [a, f] = this.helper.splitField(field);
+          const prop = this.helper.getProperty(f, a);
+          const type = this.platform.castColumn(prop);
+          const fieldName = this.helper.mapper(field, this.type, undefined, null);
+          if (!prop?.persist && !prop?.formula && !pks.includes(fieldName)) {
+            addToSelect.push(fieldName);
+          }
+          const key = raw(`min(${this.platform.quoteIdentifier(fieldName)}${type})`);
+          orderBy.push({ [key]: direction });
         }
-        subQuery.state.finalized = true;
-        const innerQuery = subQuery.as(this.mainAlias.aliasName).clear('select').select(pks);
-        /* v8 ignore next */
-        if (addToSelect.length > 0) {
-            addToSelect.forEach(prop => {
-                const field = this.state.fields.find(field => {
-                    if (typeof field === 'object' && field && '__as' in field) {
-                        return field.__as === prop;
-                    }
-                    if (field instanceof RawQueryFragment) {
-                        // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
-                        return field.sql.includes(prop);
-                    }
-                    return false;
-                });
-                if (field instanceof RawQueryFragment) {
-                    innerQuery.select(this.platform.formatQuery(field.sql, field.params));
-                }
-                else if (field) {
-                    innerQuery.select(field);
-                }
-            });
+      }
+      subQuery.orderBy(orderBy);
+    }
+    subQuery.state.finalized = true;
+    const innerQuery = subQuery.as(this.mainAlias.aliasName).clear('select').select(pks);
+    /* v8 ignore next */
+    if (addToSelect.length > 0) {
+      addToSelect.forEach(prop => {
+        const field = this.state.fields.find(field => {
+          if (typeof field === 'object' && field && '__as' in field) {
+            return field.__as === prop;
+          }
+          if (field instanceof RawQueryFragment) {
+            // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
+            return field.sql.includes(prop);
+          }
+          return false;
+        });
+        if (field instanceof RawQueryFragment) {
+          innerQuery.select(this.platform.formatQuery(field.sql, field.params));
+        } else if (field) {
+          innerQuery.select(field);
         }
-        // multiple sub-queries are needed to get around mysql limitations with order by + limit + where in + group by (o.O)
-        // https://stackoverflow.com/questions/17892762/mysql-this-version-of-mysql-doesnt-yet-support-limit-in-all-any-some-subqu
-        const subSubQuery = this.platform.createNativeQueryBuilder();
-        subSubQuery.select(raw(`json_arrayagg(${quotedPKs.join(', ')})`)).from(innerQuery);
-        this.state.limit = undefined;
-        this.state.offset = undefined;
-        // Save the original WHERE conditions before pruning joins
-        const originalCond = this.state.cond;
-        const populatePaths = this.getPopulatePaths();
-        // Remove joins that are not used for population or ordering
-        this.pruneJoinsForPagination(meta, populatePaths);
-        // Transfer WHERE conditions to ORDER BY joins (GH #6160)
-        this.transferConditionsForOrderByJoins(meta, originalCond, populatePaths);
-        const subquerySql = subSubQuery.toString();
-        const key = meta.getPrimaryProps()[0].runtimeType === 'string'
-            ? `concat('"', ${quotedPKs.join(', ')}, '"')`
-            : quotedPKs.join(', ');
-        const sql = `json_contains((${subquerySql}), ${key})`;
-        this.state.cond = {};
-        this.select(this.state.fields).where(sql);
+      });
     }
+    // multiple sub-queries are needed to get around mysql limitations with order by + limit + where in + group by (o.O)
+    // https://stackoverflow.com/questions/17892762/mysql-this-version-of-mysql-doesnt-yet-support-limit-in-all-any-some-subqu
+    const subSubQuery = this.platform.createNativeQueryBuilder();
+    subSubQuery.select(raw(`json_arrayagg(${quotedPKs.join(', ')})`)).from(innerQuery);
+    this.state.limit = undefined;
+    this.state.offset = undefined;
+    // Save the original WHERE conditions before pruning joins
+    const originalCond = this.state.cond;
+    const populatePaths = this.getPopulatePaths();
+    // Remove joins that are not used for population or ordering
+    this.pruneJoinsForPagination(meta, populatePaths);
+    // Transfer WHERE conditions to ORDER BY joins (GH #6160)
+    this.transferConditionsForOrderByJoins(meta, originalCond, populatePaths);
+    const subquerySql = subSubQuery.toString();
+    const key =
+      meta.getPrimaryProps()[0].runtimeType === 'string'
+        ? `concat('"', ${quotedPKs.join(', ')}, '"')`
+        : quotedPKs.join(', ');
+    const sql = `json_contains((${subquerySql}), ${key})`;
+    this.state.cond = {};
+    this.select(this.state.fields).where(sql);
+  }
 }

package/MariaDbSchemaHelper.d.ts

@@ -1,12 +1,24 @@
-import { type AbstractSqlConnection, type CheckDef, type Column, type IndexDef, type DatabaseSchema, type Table, MySqlSchemaHelper } from '@mikro-orm/mysql';
+import {
+  type AbstractSqlConnection,
+  type CheckDef,
+  type Column,
+  type IndexDef,
+  type DatabaseSchema,
+  type Table,
+  MySqlSchemaHelper,
+} from '@mikro-orm/mysql';
 import { type Dictionary, type Type } from '@mikro-orm/core';
 /** Schema introspection helper for MariaDB. */
 export declare class MariaDbSchemaHelper extends MySqlSchemaHelper {
-    protected appendMySqlIndexSuffix(sql: string, index: IndexDef): 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[], columns?: Dictionary<Column[]>): Promise<Dictionary<CheckDef[]>>;
-    protected getChecksSQL(tables: Table[]): string;
-    protected wrap(val: string | undefined | null, type: Type<unknown>): string | undefined | null;
+  protected appendMySqlIndexSuffix(sql: string, index: IndexDef): 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[],
+    columns?: Dictionary<Column[]>,
+  ): Promise<Dictionary<CheckDef[]>>;
+  protected getChecksSQL(tables: Table[]): string;
+  protected wrap(val: string | undefined | null, type: Type<unknown>): string | undefined | null;
 }

package/MariaDbSchemaHelper.js

@@ -1,85 +1,84 @@
-import { MySqlSchemaHelper, } from '@mikro-orm/mysql';
+import { MySqlSchemaHelper } from '@mikro-orm/mysql';
 /** Schema introspection helper for MariaDB. */
 export class MariaDbSchemaHelper extends MySqlSchemaHelper {
-    appendMySqlIndexSuffix(sql, index) {
-        // MariaDB uses IGNORED instead of MySQL's INVISIBLE keyword
-        if (index.invisible) {
-            sql += ' ignored';
-        }
-        // MariaDB supports CLUSTERING=YES only with the Aria storage engine.
-        // Using this option with InnoDB tables will have no effect (silently ignored).
-        // See: https://mariadb.com/kb/en/create-index/#clustering-yes
-        if (index.clustered) {
-            sql += ' clustering=yes';
-        }
-        return sql;
+  appendMySqlIndexSuffix(sql, index) {
+    // MariaDB uses IGNORED instead of MySQL's INVISIBLE keyword
+    if (index.invisible) {
+      sql += ' ignored';
     }
-    async loadInformationSchema(schema, connection, tables) {
-        /* v8 ignore next */
-        if (tables.length === 0) {
-            return;
-        }
-        const columns = await this.getAllColumns(connection, tables);
-        const indexes = await this.getAllIndexes(connection, tables);
-        const checks = await this.getAllChecks(connection, tables, columns);
-        const fks = await this.getAllForeignKeys(connection, tables);
-        const enums = await this.getAllEnumDefinitions(connection, tables);
-        for (const t of tables) {
-            const key = this.getTableKey(t);
-            const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
-            const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
-            table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums[key]);
-        }
+    // MariaDB supports CLUSTERING=YES only with the Aria storage engine.
+    // Using this option with InnoDB tables will have no effect (silently ignored).
+    // See: https://mariadb.com/kb/en/create-index/#clustering-yes
+    if (index.clustered) {
+      sql += ' clustering=yes';
+    }
+    return sql;
+  }
+  async loadInformationSchema(schema, connection, tables) {
+    /* v8 ignore next */
+    if (tables.length === 0) {
+      return;
     }
-    async getAllIndexes(connection, tables) {
-        const sql = `select table_name as table_name, nullif(table_schema, schema()) as schema_name, index_name as index_name, non_unique as non_unique, column_name as column_name, index_type as index_type, sub_part as sub_part, collation as sort_order /*M!100600 , ignored as ignored */
+    const columns = await this.getAllColumns(connection, tables);
+    const indexes = await this.getAllIndexes(connection, tables);
+    const checks = await this.getAllChecks(connection, tables, columns);
+    const fks = await this.getAllForeignKeys(connection, tables);
+    const enums = await this.getAllEnumDefinitions(connection, tables);
+    for (const t of tables) {
+      const key = this.getTableKey(t);
+      const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+      const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
+      table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums[key]);
+    }
+  }
+  async getAllIndexes(connection, tables) {
+    const sql = `select table_name as table_name, nullif(table_schema, schema()) as schema_name, index_name as index_name, non_unique as non_unique, column_name as column_name, index_type as index_type, sub_part as sub_part, collation as sort_order /*M!100600 , ignored as ignored */
         from information_schema.statistics where table_schema = database()
         and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')})
         order by schema_name, table_name, index_name, seq_in_index`;
-        const allIndexes = await connection.execute(sql);
-        const ret = {};
-        for (const index of allIndexes) {
-            const key = this.getTableKey(index);
-            const indexDef = {
-                columnNames: [index.column_name],
-                keyName: index.index_name,
-                unique: !index.non_unique,
-                primary: index.index_name === 'PRIMARY',
-                constraint: !index.non_unique,
-            };
-            // Capture column options (prefix length, sort order)
-            if (index.sub_part != null || index.sort_order === 'D') {
-                indexDef.columns = [
-                    {
-                        name: index.column_name,
-                        ...(index.sub_part != null && { length: index.sub_part }),
-                        ...(index.sort_order === 'D' && { sort: 'DESC' }),
-                    },
-                ];
-            }
-            // Capture index type for fulltext and spatial indexes
-            if (index.index_type === 'FULLTEXT') {
-                indexDef.type = 'fulltext';
-            }
-            else if (index.index_type === 'SPATIAL') {
-                /* v8 ignore next */
-                indexDef.type = 'spatial';
-            }
-            // Capture ignored flag (MariaDB 10.6+, equivalent to MySQL's INVISIBLE)
-            /* v8 ignore next */
-            if (index.ignored === 'YES') {
-                indexDef.invisible = true;
-            }
-            ret[key] ??= [];
-            ret[key].push(indexDef);
-        }
-        for (const key of Object.keys(ret)) {
-            ret[key] = await this.mapIndexes(ret[key]);
-        }
-        return ret;
+    const allIndexes = await connection.execute(sql);
+    const ret = {};
+    for (const index of allIndexes) {
+      const key = this.getTableKey(index);
+      const indexDef = {
+        columnNames: [index.column_name],
+        keyName: index.index_name,
+        unique: !index.non_unique,
+        primary: index.index_name === 'PRIMARY',
+        constraint: !index.non_unique,
+      };
+      // Capture column options (prefix length, sort order)
+      if (index.sub_part != null || index.sort_order === 'D') {
+        indexDef.columns = [
+          {
+            name: index.column_name,
+            ...(index.sub_part != null && { length: index.sub_part }),
+            ...(index.sort_order === 'D' && { sort: 'DESC' }),
+          },
+        ];
+      }
+      // Capture index type for fulltext and spatial indexes
+      if (index.index_type === 'FULLTEXT') {
+        indexDef.type = 'fulltext';
+      } else if (index.index_type === 'SPATIAL') {
+        /* v8 ignore next */
+        indexDef.type = 'spatial';
+      }
+      // Capture ignored flag (MariaDB 10.6+, equivalent to MySQL's INVISIBLE)
+      /* v8 ignore next */
+      if (index.ignored === 'YES') {
+        indexDef.invisible = true;
+      }
+      ret[key] ??= [];
+      ret[key].push(indexDef);
     }
-    async getAllColumns(connection, tables) {
-        const sql = `select table_name as table_name,
+    for (const key of Object.keys(ret)) {
+      ret[key] = await this.mapIndexes(ret[key]);
+    }
+    return ret;
+  }
+  async getAllColumns(connection, tables) {
+    const sql = `select table_name as table_name,
       nullif(table_schema, schema()) as schema_name,
       column_name as column_name,
       column_default as column_default,
@@ -95,69 +94,73 @@ export class MariaDbSchemaHelper extends MySqlSchemaHelper {
       ifnull(datetime_precision, character_maximum_length) length
       from information_schema.columns where table_schema = database() and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')})
       order by ordinal_position`;
-        const allColumns = await connection.execute(sql);
-        const str = (val) => (val != null ? '' + val : val);
-        const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim() || undefined;
-        const ret = {};
-        for (const col of allColumns) {
-            const mappedType = this.platform.getMappedType(col.column_type);
-            const tmp = this.normalizeDefaultValue(mappedType.compareAsType() === 'boolean' && ['0', '1'].includes(col.column_default)
-                ? ['false', 'true'][+col.column_default]
-                : col.column_default, col.length);
-            const defaultValue = str(tmp === 'NULL' && col.is_nullable === 'YES' ? null : tmp);
-            const key = this.getTableKey(col);
-            const generated = col.generation_expression
-                ? `${col.generation_expression.replaceAll(`\\'`, `'`)} ${col.extra.match(/stored generated/i) ? 'stored' : 'virtual'}`
-                : undefined;
-            ret[key] ??= [];
-            ret[key].push({
-                name: col.column_name,
-                type: this.platform.isNumericColumn(mappedType)
-                    ? col.column_type.replace(/ unsigned$/, '').replace(/\(\d+\)$/, '')
-                    : col.column_type,
-                mappedType,
-                unsigned: col.column_type.endsWith(' unsigned'),
-                length: col.length,
-                default: this.wrap(defaultValue, mappedType),
-                nullable: col.is_nullable === 'YES',
-                primary: col.column_key === 'PRI',
-                unique: col.column_key === 'UNI',
-                autoincrement: col.extra === 'auto_increment',
-                precision: col.numeric_precision,
-                scale: col.numeric_scale,
-                comment: col.column_comment,
-                extra: extra(col.extra),
-                generated,
-            });
-        }
-        return ret;
+    const allColumns = await connection.execute(sql);
+    const str = val => (val != null ? '' + val : val);
+    const extra = val =>
+      val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim() || undefined;
+    const ret = {};
+    for (const col of allColumns) {
+      const mappedType = this.platform.getMappedType(col.column_type);
+      const tmp = this.normalizeDefaultValue(
+        mappedType.compareAsType() === 'boolean' && ['0', '1'].includes(col.column_default)
+          ? ['false', 'true'][+col.column_default]
+          : col.column_default,
+        col.length,
+      );
+      const defaultValue = str(tmp === 'NULL' && col.is_nullable === 'YES' ? null : tmp);
+      const key = this.getTableKey(col);
+      const generated = col.generation_expression
+        ? `${col.generation_expression.replaceAll(`\\'`, `'`)} ${col.extra.match(/stored generated/i) ? 'stored' : 'virtual'}`
+        : undefined;
+      ret[key] ??= [];
+      ret[key].push({
+        name: col.column_name,
+        type: this.platform.isNumericColumn(mappedType)
+          ? col.column_type.replace(/ unsigned$/, '').replace(/\(\d+\)$/, '')
+          : col.column_type,
+        mappedType,
+        unsigned: col.column_type.endsWith(' unsigned'),
+        length: col.length,
+        default: this.wrap(defaultValue, mappedType),
+        nullable: col.is_nullable === 'YES',
+        primary: col.column_key === 'PRI',
+        unique: col.column_key === 'UNI',
+        autoincrement: col.extra === 'auto_increment',
+        precision: col.numeric_precision,
+        scale: col.numeric_scale,
+        comment: col.column_comment,
+        extra: extra(col.extra),
+        generated,
+      });
     }
-    async getAllChecks(connection, tables, columns) {
-        const sql = this.getChecksSQL(tables);
-        const allChecks = await connection.execute(sql);
-        const ret = {};
-        for (const check of allChecks) {
-            const key = this.getTableKey(check);
-            const match = /^json_valid\(`(.*)`\)$/i.exec(check.expression);
-            const col = columns?.[key]?.find(col => col.name === match?.[1]);
-            if (col && match) {
-                col.type = 'json';
-                col.mappedType = this.platform.getMappedType('json');
-                delete col.length;
-                continue;
-            }
-            ret[key] ??= [];
-            ret[key].push({
-                name: check.name,
-                columnName: check.column_name,
-                definition: `check ${check.expression}`,
-                expression: check.expression.replace(/^\((.*)\)$/, '$1'),
-            });
-        }
-        return ret;
+    return ret;
+  }
+  async getAllChecks(connection, tables, columns) {
+    const sql = this.getChecksSQL(tables);
+    const allChecks = await connection.execute(sql);
+    const ret = {};
+    for (const check of allChecks) {
+      const key = this.getTableKey(check);
+      const match = /^json_valid\(`(.*)`\)$/i.exec(check.expression);
+      const col = columns?.[key]?.find(col => col.name === match?.[1]);
+      if (col && match) {
+        col.type = 'json';
+        col.mappedType = this.platform.getMappedType('json');
+        delete col.length;
+        continue;
+      }
+      ret[key] ??= [];
+      ret[key].push({
+        name: check.name,
+        columnName: check.column_name,
+        definition: `check ${check.expression}`,
+        expression: check.expression.replace(/^\((.*)\)$/, '$1'),
+      });
     }
-    getChecksSQL(tables) {
-        return `select
+    return ret;
+  }
+  getChecksSQL(tables) {
+    return `select
               tc.constraint_schema as table_schema,
               tc.table_name as table_name,
               tc.constraint_name as name,
@@ -166,8 +169,8 @@ export class MariaDbSchemaHelper extends MySqlSchemaHelper {
             from information_schema.check_constraints tc
             where tc.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')}) and tc.constraint_schema = database()
             order by tc.constraint_name`;
-    }
-    wrap(val, type) {
-        return val;
-    }
+  }
+  wrap(val, type) {
+    return val;
+  }
 }

package/README.md

@@ -64,7 +64,7 @@ export class Book extends BookSchema.class {}
 BookSchema.setClass(Book);
 ```
 
-You can also define entities using [decorators](https://mikro-orm.io/docs/defining-entities) or [`EntitySchema`](https://mikro-orm.io/docs/entity-schema). See the [defining entities guide](https://mikro-orm.io/docs/defining-entities) for all options.
+You can also define entities using [decorators](https://mikro-orm.io/docs/using-decorators) or [`EntitySchema`](https://mikro-orm.io/docs/define-entity#entityschema-low-level-api). See the [defining entities guide](https://mikro-orm.io/docs/defining-entities) for all options.
 
 ### Initialize and Use
 
@@ -133,7 +133,7 @@ const author = await em.findOneOrFail(Author, 1, {
   populate: ['books'],
 });
 author.name = 'Jon Snow II';
-author.books.getItems().forEach(book => book.title += ' (2nd ed.)');
+author.books.getItems().forEach(book => (book.title += ' (2nd ed.)'));
 author.books.add(orm.em.create(Book, { title: 'New Book', author }));
 
 // Flush computes change sets and executes them in a single transaction

package/index.d.ts

@@ -2,4 +2,8 @@ export * from '@mikro-orm/mysql';
 export * from './MariaDbSchemaHelper.js';
 export * from './MariaDbPlatform.js';
 export * from './MariaDbDriver.js';
-export { MariaDbMikroORM as MikroORM, type MariaDbOptions as Options, defineMariaDbConfig as defineConfig, } from './MariaDbMikroORM.js';
+export {
+  MariaDbMikroORM as MikroORM,
+  type MariaDbOptions as Options,
+  defineMariaDbConfig as defineConfig,
+} from './MariaDbMikroORM.js';

package/index.js

@@ -2,4 +2,4 @@ export * from '@mikro-orm/mysql';
 export * from './MariaDbSchemaHelper.js';
 export * from './MariaDbPlatform.js';
 export * from './MariaDbDriver.js';
-export { MariaDbMikroORM as MikroORM, defineMariaDbConfig as defineConfig, } from './MariaDbMikroORM.js';
+export { MariaDbMikroORM as MikroORM, defineMariaDbConfig as defineConfig } from './MariaDbMikroORM.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/mariadb",
-  "version": "7.0.3-dev.9",
+  "version": "7.0.3",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -47,14 +47,14 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/mysql": "7.0.3-dev.9",
+    "@mikro-orm/mysql": "7.0.3",
     "kysely": "0.28.12"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.2"
+    "@mikro-orm/core": "^7.0.3"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.3-dev.9"
+    "@mikro-orm/core": "7.0.3"
   },
   "engines": {
     "node": ">= 22.17.0"