@mikro-orm/mariadb 7.0.2-dev.8 → 7.0.2

package/MariaDbDriver.d.ts

@@ -1,12 +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,26 +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,18 +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';
-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 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>>;
+/** 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>>;
+/** 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>>;
 /**
  * @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,22 +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

@@ -1,7 +1,8 @@
 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

@@ -1,14 +1,15 @@
 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,11 +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;
 }