@mikro-orm/mariadb 7.0.0-dev.33 → 7.0.0-dev.330

package/MariaDbDriver.d.ts

@@ -1,9 +1,12 @@
-import { type AnyEntity, type Configuration, type ConnectionType, type LoggingOptions, type Transaction } 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';
 export declare class MariaDbDriver extends MySqlDriver {
     readonly platform: MariaDbPlatform;
     constructor(config: Configuration);
-    createQueryBuilder<T extends AnyEntity<T>>(entityName: string, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): MariaDbQueryBuilder<T, any, any, any>;
+    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,7 +1,8 @@
-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';
 export class MariaDbDriver extends MySqlDriver {
     constructor(config) {
         super(config);
@@ -9,11 +10,17 @@ export class MariaDbDriver extends MySqlDriver {
     }
     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 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,19 +1,18 @@
-import { 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>>;
 /**
  * @inheritDoc
  */
-export declare class MariaDbMikroORM<EM extends EntityManager = SqlEntityManager> extends MikroORM<MariaDbDriver, EM> {
-    private static DRIVER;
+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[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    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
      */
-    static initSync<D extends IDatabaseDriver = MariaDbDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
+    constructor(options: Partial<Options<MariaDbDriver, EM, Entities>>);
 }
-export type MariaDbOptions = Options<MariaDbDriver>;
-export declare function defineMariaDbConfig(options: MariaDbOptions): Options<MariaDbDriver, SqlEntityManager<MariaDbDriver> & EntityManager<IDatabaseDriver<import("@mikro-orm/core").Connection>>>;

package/MariaDbMikroORM.js

@@ -1,24 +1,22 @@
 import { defineConfig, MikroORM, } from '@mikro-orm/core';
 import { MariaDbDriver } from './MariaDbDriver.js';
+export function defineMariaDbConfig(options) {
+    return defineConfig({ driver: MariaDbDriver, ...options });
+}
 /**
  * @inheritDoc
  */
 export class MariaDbMikroORM extends MikroORM {
-    static DRIVER = MariaDbDriver;
     /**
      * @inheritDoc
      */
     static async init(options) {
-        return super.init(options);
+        return super.init(defineMariaDbConfig(options));
     }
     /**
      * @inheritDoc
      */
-    static initSync(options) {
-        return super.initSync(options);
+    constructor(options) {
+        super(defineMariaDbConfig(options));
     }
 }
-/* v8 ignore next 3 */
-export function defineMariaDbConfig(options) {
-    return defineConfig({ driver: MariaDbDriver, ...options });
-}

package/MariaDbQueryBuilder.js

@@ -1,4 +1,4 @@
-import { raw, RawQueryFragment, } from '@mikro-orm/core';
+import { raw, RawQueryFragment, Utils } from '@mikro-orm/core';
 import { QueryBuilder } from '@mikro-orm/mysql';
 /**
  * @inheritDoc
@@ -7,22 +7,23 @@ 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._limit);
+        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
-        // @ts-ignore
-        Object.values(subQuery._joins).forEach(join => join.cond = join.cond_ ?? {});
-        if (this._offset) {
-            subQuery.offset(this._offset);
+        Object.values(subQuery.state.joins).forEach(join => (join.cond = join.cond_ ?? {}));
+        if (this.state.offset) {
+            subQuery.offset(this.state.offset);
         }
         const addToSelect = [];
-        if (this._orderBy.length > 0) {
+        if (this.state.orderBy.length > 0) {
             const orderBy = [];
-            for (const orderMap of this._orderBy) {
-                for (const [field, direction] of Object.entries(orderMap)) {
-                    if (RawQueryFragment.isKnownFragment(field)) {
-                        const rawField = RawQueryFragment.getKnownFragment(field, false);
-                        this.rawFragments.add(field);
-                        orderBy.push({ [rawField.clone()]: direction });
+            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);
@@ -38,13 +39,12 @@ export class MariaDbQueryBuilder extends QueryBuilder {
             }
             subQuery.orderBy(orderBy);
         }
-        // @ts-ignore
-        subQuery.finalized = true;
+        subQuery.state.finalized = true;
         const innerQuery = subQuery.as(this.mainAlias.aliasName).clear('select').select(pks);
-        /* v8 ignore start */
+        /* v8 ignore next */
         if (addToSelect.length > 0) {
             addToSelect.forEach(prop => {
-                const field = this._fields.find(field => {
+                const field = this.state.fields.find(field => {
                     if (typeof field === 'object' && field && '__as' in field) {
                         return field.__as === prop;
                     }
@@ -62,39 +62,25 @@ export class MariaDbQueryBuilder extends QueryBuilder {
                 }
             });
         }
-        /* v8 ignore stop */
         // 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._limit = undefined;
-        this._offset = undefined;
-        // remove joins that are not used for population or ordering to improve performance
-        const populate = new Set();
-        const orderByAliases = this._orderBy
-            .flatMap(hint => Object.keys(hint))
-            .map(k => k.split('.')[0]);
-        function addPath(hints, prefix = '') {
-            for (const hint of hints) {
-                const field = hint.field.split(':')[0];
-                populate.add((prefix ? prefix + '.' : '') + field);
-                if (hint.children) {
-                    addPath(hint.children, (prefix ? prefix + '.' : '') + field);
-                }
-            }
-        }
-        addPath(this._populate);
-        for (const [key, join] of Object.entries(this._joins)) {
-            const path = join.path?.replace(/\[populate]|\[pivot]|:ref/g, '').replace(new RegExp(`^${meta.className}.`), '');
-            /* v8 ignore next 3 */
-            if (!populate.has(path ?? '') && !orderByAliases.includes(join.alias)) {
-                delete this._joins[key];
-            }
-        }
+        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 key = meta.getPrimaryProps()[0].runtimeType === 'string'
+            ? `concat('"', ${quotedPKs.join(', ')}, '"')`
+            : quotedPKs.join(', ');
         const sql = `json_contains((${subquerySql}), ${key})`;
-        this._cond = {};
-        this.select(this._fields).where(sql);
+        this.state.cond = {};
+        this.select(this.state.fields).where(sql);
     }
 }

package/MariaDbSchemaHelper.d.ts

@@ -1,6 +1,7 @@
 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';
 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[]>>;

package/MariaDbSchemaHelper.js

@@ -1,5 +1,18 @@
 import { MySqlSchemaHelper, } from '@mikro-orm/mysql';
 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;
+    }
     async loadInformationSchema(schema, connection, tables) {
         /* v8 ignore next */
         if (tables.length === 0) {
@@ -18,7 +31,7 @@ export class MariaDbSchemaHelper extends MySqlSchemaHelper {
         }
     }
     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
+        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`;
@@ -26,14 +39,38 @@ export class MariaDbSchemaHelper extends MySqlSchemaHelper {
         const ret = {};
         for (const index of allIndexes) {
             const key = this.getTableKey(index);
-            ret[key] ??= [];
-            ret[key].push({
+            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]);
@@ -55,24 +92,28 @@ export class MariaDbSchemaHelper extends MySqlSchemaHelper {
       numeric_precision as numeric_precision,
       numeric_scale as numeric_scale,
       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))})
+      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 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))
+            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;
+            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,
+                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,
@@ -96,7 +137,7 @@ export class MariaDbSchemaHelper extends MySqlSchemaHelper {
         const ret = {};
         for (const check of allChecks) {
             const key = this.getTableKey(check);
-            const match = check.expression.match(/^json_valid\(`(.*)`\)$/i);
+            const match = /^json_valid\(`(.*)`\)$/i.exec(check.expression);
             const col = columns?.[key]?.find(col => col.name === match?.[1]);
             if (col && match) {
                 col.type = 'json';
@@ -122,7 +163,7 @@ export class MariaDbSchemaHelper extends MySqlSchemaHelper {
               tc.check_clause as expression,
               /*M!100510 case when tc.level = 'Column' then tc.constraint_name else */ null /*M!100510 end */ as column_name
             from information_schema.check_constraints tc
-            where tc.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))}) and tc.constraint_schema = database()
+            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) {

package/README.md

@@ -2,14 +2,14 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL and SQLite (including libSQL) databases. 
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases. 
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
-[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
-[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
+[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
-[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
@@ -181,6 +181,7 @@ yarn add @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 yarn add @mikro-orm/core @mikro-orm/mssql         # for mssql
+yarn add @mikro-orm/core @mikro-orm/oracledb      # for oracle
 yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
@@ -381,6 +382,8 @@ See also the list of contributors who [participated](https://github.com/mikro-or
 
 Please ⭐️ this repository if this project helped you!
 
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
 ## 📝 License
 
 Copyright © 2018 [Martin Adámek](https://github.com/b4nan).

package/index.d.ts

@@ -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, MariaDbOptions as Options, defineMariaDbConfig as defineConfig, } from './MariaDbMikroORM.js';
+export { MariaDbMikroORM as MikroORM, type MariaDbOptions as Options, defineMariaDbConfig as defineConfig, } from './MariaDbMikroORM.js';

package/package.json

@@ -1,63 +1,62 @@
 {
   "name": "@mikro-orm/mariadb",
-  "type": "module",
-  "version": "7.0.0-dev.33",
+  "version": "7.0.0-dev.330",
   "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.",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": "./index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
   "keywords": [
-    "orm",
+    "data-mapper",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
     "mongo",
     "mongodb",
     "mysql",
-    "mariadb",
+    "orm",
     "postgresql",
     "sqlite",
     "sqlite3",
     "ts",
     "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
+    "unit-of-work"
   ],
-  "author": "Martin Adámek",
-  "license": "MIT",
+  "homepage": "https://mikro-orm.io",
   "bugs": {
     "url": "https://github.com/mikro-orm/mikro-orm/issues"
   },
-  "homepage": "https://mikro-orm.io",
-  "engines": {
-    "node": ">= 22.11.0"
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
-    "@mikro-orm/mysql": "7.0.0-dev.33"
+    "@mikro-orm/mysql": "7.0.0-dev.330",
+    "kysely": "0.28.11"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.5.7",
-    "kysely": "0.28.7"
+    "@mikro-orm/core": "^6.6.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.33",
-    "kysely": "*"
+    "@mikro-orm/core": "7.0.0-dev.330"
+  },
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }