@mikro-orm/mariadb 7.0.3 → 7.0.4-dev.1

package/MariaDbDriver.d.ts

@@ -1,29 +1,13 @@
-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);
+    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;
     }
-    return qb;
-  }
-  /** @inheritDoc */
-  getORMClass() {
-    return MariaDbMikroORM;
-  }
 }

package/MariaDbMikroORM.d.ts

@@ -1,58 +1,20 @@
-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;
+    schemaHelper = new MariaDbSchemaHelper(this);
+    convertJsonToDatabaseValue(value, context) {
+        if (context?.mode === 'hydration') {
+            return value;
+        }
+        return JSON.stringify(value);
+    }
+    convertsJsonAutomatically() {
+        return false;
     }
-    return JSON.stringify(value);
-  }
-  convertsJsonAutomatically() {
-    return false;
-  }
 }

package/MariaDbQueryBuilder.d.ts

@@ -3,11 +3,6 @@ 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,80 +4,83 @@ 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 });
+    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);
         }
-      }
-      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);
+        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);
+        }
+        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,24 +1,12 @@
-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,84 +1,85 @@
-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';
+    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;
     }
-    // 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;
-    }
-    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 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]);
+        }
     }
-  }
-  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 */
+    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);
+        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;
     }
-    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,
+    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,
@@ -94,73 +95,69 @@ 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,
-      });
+        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;
     }
-    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'),
-      });
+    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;
-  }
-  getChecksSQL(tables) {
-    return `select
+    getChecksSQL(tables) {
+        return `select
               tc.constraint_schema as table_schema,
               tc.table_name as table_name,
               tc.constraint_name as name,
@@ -169,8 +166,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

@@ -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,8 +2,4 @@ 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",
+  "version": "7.0.4-dev.1",
   "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",
@@ -42,19 +42,19 @@
   },
   "scripts": {
     "build": "yarn compile && yarn copy",
-    "clean": "yarn run -T rimraf ./dist",
+    "clean": "yarn run -T rimraf ./dist ./tsconfig.build.tsbuildinfo",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/mysql": "7.0.3",
+    "@mikro-orm/mysql": "7.0.4-dev.1",
     "kysely": "0.28.12"
   },
   "devDependencies": {
     "@mikro-orm/core": "^7.0.3"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.3"
+    "@mikro-orm/core": "7.0.4-dev.1"
   },
   "engines": {
     "node": ">= 22.17.0"