@mikro-orm/knex 7.0.0-dev.39 → 7.0.0-dev.40

package/AbstractSqlDriver.js

@@ -900,10 +900,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
      */
     joinedProps(meta, populate, options) {
         return populate.filter(hint => {
-            const [propName] = hint.field.split(':', 2);
+            const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName] || {};
             const strategy = getLoadingStrategy(hint.strategy || prop.strategy || options?.strategy || this.config.get('loadStrategy'), prop.kind);
-            if (hint.filter && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && !prop.nullable) {
+            if (ref && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
                 return true;
             }
             // skip redundant joins for 1:1 owner population hints when using `mapToPk`

package/README.md

@@ -381,6 +381,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/dialects/postgresql/PostgreSqlTableCompiler.d.ts

@@ -0,0 +1 @@
+export {};

package/dialects/postgresql/PostgreSqlTableCompiler.js

@@ -0,0 +1 @@
+export {};

package/index.d.ts

@@ -2,7 +2,6 @@
  * @packageDocumentation
  * @module knex
  */
-/** @ignore */
 export { Kysely } from 'kysely';
 export * from '@mikro-orm/core';
 export * from './AbstractSqlConnection.js';
@@ -11,6 +10,7 @@ export * from './AbstractSqlPlatform.js';
 export * from './SqlEntityManager.js';
 export * from './SqlEntityRepository.js';
 export * from './query/index.js';
+export { raw } from './query/index.js';
 export * from './schema/index.js';
 export * from './dialects/index.js';
 export * from './typings.js';

package/index.js

@@ -2,7 +2,6 @@
  * @packageDocumentation
  * @module knex
  */
-/** @ignore */
 export { Kysely } from 'kysely';
 export * from '@mikro-orm/core';
 export * from './AbstractSqlConnection.js';
@@ -11,6 +10,7 @@ export * from './AbstractSqlPlatform.js';
 export * from './SqlEntityManager.js';
 export * from './SqlEntityRepository.js';
 export * from './query/index.js';
+export { raw } from './query/index.js';
 export * from './schema/index.js';
 export * from './dialects/index.js';
 export * from './typings.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "7.0.0-dev.39",
+  "version": "7.0.0-dev.40",
   "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.",
   "type": "module",
   "exports": {
@@ -54,9 +54,9 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.5.8"
+    "@mikro-orm/core": "^6.6.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.39"
+    "@mikro-orm/core": "7.0.0-dev.40"
   }
 }

package/query/ArrayCriteriaNode.d.ts

@@ -7,4 +7,5 @@ export declare class ArrayCriteriaNode<T extends object> extends CriteriaNode<T>
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
     unwrap(): any;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): any;
+    isStrict(): boolean;
 }

package/query/ArrayCriteriaNode.js

@@ -18,4 +18,7 @@ export class ArrayCriteriaNode extends CriteriaNode {
             return node.willAutoJoin(qb, alias, options);
         });
     }
+    isStrict() {
+        return this.strict || this.payload.some((node) => node.isStrict());
+    }
 }

package/query/CriteriaNode.d.ts

@@ -11,10 +11,11 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     readonly entityName: string;
     readonly parent?: ICriteriaNode<T> | undefined;
     readonly key?: EntityKey<T> | undefined;
+    readonly strict: boolean;
     payload: any;
     prop?: EntityProperty<T>;
     index?: number;
-    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | undefined, validate?: boolean);
+    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | undefined, validate?: boolean, strict?: boolean);
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
     unwrap(): any;
     shouldInline(payload: any): boolean;
@@ -25,6 +26,7 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     private isPivotJoin;
     getPivotPath(path: string): string;
     aliased(field: string, alias?: string): string;
+    isStrict(): boolean;
     /** @ignore */
     [inspect.custom](): string;
 }

package/query/CriteriaNode.js

@@ -10,14 +10,16 @@ export class CriteriaNode {
     entityName;
     parent;
     key;
+    strict;
     payload;
     prop;
     index;
-    constructor(metadata, entityName, parent, key, validate = true) {
+    constructor(metadata, entityName, parent, key, validate = true, strict = false) {
         this.metadata = metadata;
         this.entityName = entityName;
         this.parent = parent;
         this.key = key;
+        this.strict = strict;
         const meta = parent && metadata.find(parent.entityName);
         if (meta && key) {
             const pks = Utils.splitPrimaryKeys(key);
@@ -106,6 +108,9 @@ export class CriteriaNode {
     aliased(field, alias) {
         return alias ? `${alias}.${field}` : field;
     }
+    isStrict() {
+        return this.strict;
+    }
     /** @ignore */
     [inspect.custom]() {
         const o = {};

package/query/CriteriaNodeFactory.js

@@ -36,7 +36,7 @@ export class CriteriaNodeFactory {
     }
     static createObjectNode(metadata, entityName, payload, parent, key) {
         const meta = metadata.find(entityName);
-        const node = new ObjectCriteriaNode(metadata, entityName, parent, key);
+        const node = new ObjectCriteriaNode(metadata, entityName, parent, key, true, payload.__strict);
         node.payload = {};
         for (const key of Object.keys(payload)) {
             node.payload[key] = this.createObjectItemNode(metadata, entityName, node, payload, key, meta);

package/query/ObjectCriteriaNode.d.ts

@@ -5,6 +5,7 @@ import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
  */
 export declare class ObjectCriteriaNode<T extends object> extends CriteriaNode<T> {
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    isStrict(): boolean;
     unwrap(): any;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
     shouldInline(payload: any): boolean;

package/query/ObjectCriteriaNode.js

@@ -58,6 +58,22 @@ export class ObjectCriteriaNode extends CriteriaNode {
             }
             alias = this.autoJoin(qb, ownerAlias, options);
         }
+        if (this.prop && nestedAlias) {
+            const toOneProperty = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
+            // if the property is nullable and the filter is strict, we need to use left join, so we mimic the inner join behaviour
+            // with an exclusive condition on the join columns:
+            // - if the owning column is null, the row is missing, we don't apply the filter
+            // - if the target column is not null, the row is matched, we apply the filter
+            if (toOneProperty && this.prop.nullable && this.isStrict()) {
+                const key = this.prop.owner ? this.prop.name : this.prop.referencedPKs;
+                qb.andWhere({
+                    $or: [
+                        { [ownerAlias + '.' + key]: null },
+                        { [nestedAlias + '.' + Utils.getPrimaryKeyHash(this.prop.referencedPKs)]: { $ne: null } },
+                    ],
+                });
+            }
+        }
         return keys.reduce((o, field) => {
             const childNode = this.payload[field];
             const payload = childNode.process(qb, { ...options, alias: this.prop ? alias : ownerAlias });
@@ -89,6 +105,11 @@ export class ObjectCriteriaNode extends CriteriaNode {
             return o;
         }, {});
     }
+    isStrict() {
+        return this.strict || Object.keys(this.payload).some(key => {
+            return this.payload[key].isStrict();
+        });
+    }
     unwrap() {
         return Object.keys(this.payload).reduce((o, field) => {
             o[field] = this.payload[field].unwrap();
@@ -213,24 +234,11 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 ? JoinType.innerJoin
                 : JoinType.leftJoin;
             qb[method](field, nestedAlias, undefined, joinType, path);
-            // if the property is nullable, we need to use left join, so we mimic the inner join behaviour
-            // with an exclusive condition on the join columns:
-            // - if the owning column is null, the row is missing, we don't apply the filter
-            // - if the target column is not null, the row is matched, we apply the filter
-            if (toOneProperty && this.prop.nullable && options?.filter) {
-                const key = this.prop.owner ? this.prop.name : this.prop.referencedPKs;
-                qb.andWhere({
-                    $or: [
-                        { [alias + '.' + key]: null },
-                        { [nestedAlias + '.' + Utils.getPrimaryKeyHash(this.prop.referencedPKs)]: { $ne: null } },
-                    ],
-                });
-            }
             if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
                 qb._fields = prev;
             }
         }
-        if (!options || options.type !== 'orderBy') {
+        if (options?.type !== 'orderBy') {
             qb.scheduleFilterCheck(path);
         }
         return nestedAlias;

package/query/QueryBuilder.d.ts

@@ -1,5 +1,5 @@
 import { inspect } from 'node:util';
-import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityKey, type EntityManager, type EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, RawQueryFragment, type RequiredEntityData, type Transaction } from '@mikro-orm/core';
+import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityKey, type EntityManager, type EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FilterOptions, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, RawQueryFragment, type RequiredEntityData, type Transaction } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
 import { type Alias, type OnConflictClause, QueryBuilderHelper } from './QueryBuilderHelper.js';
@@ -164,7 +164,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     /**
      * Apply filters to the QB where condition.
      */
-    applyFilters(filterOptions?: Dictionary<boolean | Dictionary> | string[] | boolean): Promise<void>;
+    applyFilters(filterOptions?: FilterOptions): Promise<void>;
     private readonly autoJoinedPaths;
     /**
      * @internal
@@ -173,7 +173,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     /**
      * @internal
      */
-    applyJoinedFilters(em: EntityManager, filterOptions?: Dictionary<boolean | Dictionary> | string[] | boolean): Promise<void>;
+    applyJoinedFilters(em: EntityManager, filterOptions: FilterOptions | undefined): Promise<void>;
     withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<Entity>, operator?: keyof typeof GroupOperator): this;
     where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;

package/query/QueryBuilder.js

@@ -270,12 +270,13 @@ export class QueryBuilder {
     /**
      * @internal
      */
-    async applyJoinedFilters(em, filterOptions = {}) {
+    async applyJoinedFilters(em, filterOptions) {
         for (const path of this.autoJoinedPaths) {
             const join = this.getJoinForPath(path);
             if (join.type === JoinType.pivotJoin) {
                 continue;
             }
+            filterOptions = QueryHelper.mergePropertyFilters(join.prop.filters, filterOptions);
             const cond = await em.applyFilters(join.prop.type, join.cond, filterOptions, 'read');
             if (Utils.hasObjectKeys(cond)) {
                 // remove nested filters, we only care about scalars here, nesting would require another join branch
@@ -476,7 +477,7 @@ export class QueryBuilder {
     }
     setLockMode(mode, tables) {
         this.ensureNotFinalized();
-        if (mode != null && mode !== LockMode.OPTIMISTIC && !this.context) {
+        if (mode != null && ![LockMode.OPTIMISTIC, LockMode.NONE].includes(mode) && !this.context) {
             throw ValidationError.transactionRequired();
         }
         this.lockMode = mode;
@@ -570,7 +571,7 @@ export class QueryBuilder {
         Utils.runIfNotEmpty(() => qb.hintComment(this._hintComments), this._hintComments);
         Utils.runIfNotEmpty(() => this.helper.appendOnConflictClause(QueryType.UPSERT, this._onConflict, qb), this._onConflict);
         if (this.lockMode) {
-            this.helper.getLockSQL(qb, this.lockMode, this.lockTables);
+            this.helper.getLockSQL(qb, this.lockMode, this.lockTables, this._joins);
         }
         this.helper.finalize(this.type, qb, this.mainAlias.metadata, this._data, this._returning);
         this.clearRawFragmentsCache();

package/query/QueryBuilderHelper.d.ts

@@ -49,7 +49,7 @@ export declare class QueryBuilderHelper {
     getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string[];
     finalize(type: QueryType, qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
     splitField<T>(field: EntityKey<T>, greedyAlias?: boolean): [string, EntityKey<T>, string | undefined];
-    getLockSQL(qb: NativeQueryBuilder, lockMode: LockMode, lockTables?: string[]): void;
+    getLockSQL(qb: NativeQueryBuilder, lockMode: LockMode, lockTables?: string[], joinsMap?: Dictionary<JoinOptions>): void;
     updateVersionProperty(qb: NativeQueryBuilder, data: Dictionary): void;
     private prefix;
     private appendGroupCondition;

package/query/QueryBuilderHelper.js

@@ -75,10 +75,10 @@ export class QueryBuilderHelper {
         if (prop?.name === a && prop.embeddedProps[f]) {
             return aliasPrefix + prop.fieldNames[fkIdx];
         }
-        if (prop?.embedded && a === prop.embedded[0]) {
+        if (a === prop?.embedded?.[0]) {
             return aliasPrefix + prop.fieldNames[fkIdx];
         }
-        const noPrefix = prop && prop.persist === false;
+        const noPrefix = prop?.persist === false;
         if (prop?.fieldNameRaw) {
             return raw(this.prefix(field, isTableNameAliasRequired));
         }
@@ -550,7 +550,7 @@ export class QueryBuilderHelper {
                 let [alias, field] = this.splitField(f, true);
                 alias = populate[alias] || alias;
                 const prop = this.getProperty(field, alias);
-                const noPrefix = (prop && prop.persist === false && !prop.formula && !prop.embedded) || RawQueryFragment.isKnownFragment(f);
+                const noPrefix = (prop?.persist === false && !prop.formula && !prop.embedded) || RawQueryFragment.isKnownFragment(f);
                 const column = this.mapper(noPrefix ? field : `${alias}.${field}`, type, undefined, null);
                 /* v8 ignore next */
                 const rawColumn = Utils.isString(column) ? column.split('.').map(e => this.platform.quoteIdentifier(e)).join('.') : column;
@@ -622,11 +622,18 @@ export class QueryBuilderHelper {
         const fromField = parts.join('.');
         return [fromAlias, fromField, ref];
     }
-    getLockSQL(qb, lockMode, lockTables = []) {
+    getLockSQL(qb, lockMode, lockTables = [], joinsMap) {
         const meta = this.metadata.find(this.entityName);
         if (lockMode === LockMode.OPTIMISTIC && meta && !meta.versionProperty) {
             throw OptimisticLockError.lockFailed(this.entityName);
         }
+        if (lockMode !== LockMode.OPTIMISTIC && lockTables.length === 0 && joinsMap) {
+            const joins = Object.values(joinsMap);
+            const innerJoins = joins.filter(join => [JoinType.innerJoin, JoinType.innerJoinLateral, JoinType.nestedInnerJoin].includes(join.type));
+            if (joins.length > innerJoins.length) {
+                lockTables.push(this.alias, ...innerJoins.map(join => join.alias));
+            }
+        }
         qb.lockMode(lockMode, lockTables);
     }
     updateVersionProperty(qb, data) {

package/query/index.d.ts

@@ -7,3 +7,4 @@ export * from './ObjectCriteriaNode.js';
 export * from './ScalarCriteriaNode.js';
 export * from './CriteriaNodeFactory.js';
 export * from './NativeQueryBuilder.js';
+export { rawKnex as raw } from './raw.js';

package/query/index.js

@@ -7,3 +7,4 @@ export * from './ObjectCriteriaNode.js';
 export * from './ScalarCriteriaNode.js';
 export * from './CriteriaNodeFactory.js';
 export * from './NativeQueryBuilder.js';
+export { rawKnex as raw } from './raw.js';

package/query/raw.d.ts

@@ -0,0 +1,58 @@
+import { type AnyString, type Dictionary, type EntityKey, type RawQueryFragment } from '@mikro-orm/core';
+import { QueryBuilder } from './QueryBuilder.js';
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export declare function rawKnex<T extends object = any, R = any>(sql: QueryBuilder<T> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): NoInfer<R>;

package/query/raw.js

@@ -0,0 +1,72 @@
+import { raw } from '@mikro-orm/core';
+// import type { Knex } from 'knex';
+import { QueryBuilder } from './QueryBuilder.js';
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export function rawKnex(sql, params) {
+    // export function rawKnex<T extends object = any, R = any>(sql: Knex.QueryBuilder | Knex.Raw | QueryBuilder<T> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): NoInfer<R> {
+    // if (Utils.isObject<Knex.QueryBuilder | Knex.Raw>(sql) && 'toSQL' in sql) {
+    //   const query = sql.toSQL();
+    //   return raw(query.sql, query.bindings);
+    // }
+    if (sql instanceof QueryBuilder) {
+        // FIXME this should live in the `knex` compat package, while what we have now should live in `sql` package
+        // @ts-ignore
+        const query = sql.toQuery()._sql;
+        return raw(query.sql, query.bindings);
+    }
+    return raw(sql, params);
+}

package/schema/DatabaseTable.js

@@ -615,7 +615,7 @@ export class DatabaseTable {
             fkOptions.deferMode = fk.deferMode;
             fkOptions.columnTypes = fk.columnNames.map(col => this.getColumn(col).type);
         }
-        return {
+        const ret = {
             name: prop,
             type,
             runtimeType,
@@ -643,6 +643,11 @@ export class DatabaseTable {
             persist,
             ...fkOptions,
         };
+        const nativeEnumName = Object.keys(this.nativeEnums).find(name => name === column.type);
+        if (nativeEnumName) {
+            ret.nativeEnumName = nativeEnumName;
+        }
+        return ret;
     }
     getReferenceKind(fk, unique) {
         if (fk && unique) {
@@ -676,10 +681,17 @@ export class DatabaseTable {
         if (fk) {
             return this.getPropertyTypeForForeignKey(namingStrategy, fk);
         }
+        const enumMode = this.platform.getConfig().get('entityGenerator').enumMode;
         // If this column is using an enum.
         if (column.enumItems?.length) {
-            // We will create a new enum name for this type and set it as the property type as well.
-            return namingStrategy.getEnumClassName(column.name, this.name, this.schema);
+            const name = column.nativeEnumName ?? column.name;
+            const tableName = column.nativeEnumName ? undefined : this.name;
+            if (enumMode === 'ts-enum') {
+                // We will create a new enum name for this type and set it as the property type as well.
+                return namingStrategy.getEnumClassName(name, tableName, this.schema);
+            }
+            // With other enum strategies, we need to use the type name.
+            return namingStrategy.getEnumTypeName(name, tableName, this.schema);
         }
         return column.mappedType?.runtimeType ?? 'unknown';
     }

package/typings.d.ts

@@ -1,10 +1,10 @@
+import type { Generated, Kysely } from 'kysely';
 import type { DeferMode, CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type, QueryFlag, AnyEntity, EntityName, EntitySchemaWithMeta, Primary, PrimaryProperty, Opt } from '@mikro-orm/core';
 import type { JoinType, QueryType } from './query/enums.js';
 import type { DatabaseSchema } from './schema/DatabaseSchema.js';
 import type { DatabaseTable } from './schema/DatabaseTable.js';
 import type { QueryBuilder } from './query/QueryBuilder.js';
 import type { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
-import type { Generated, Kysely } from 'kysely';
 export interface Table {
     table_name: string;
     schema_name?: string;
@@ -179,6 +179,7 @@ export interface ICriteriaNode<T extends object> {
     readonly entityName: string;
     readonly parent?: ICriteriaNode<T> | undefined;
     readonly key?: string | undefined;
+    readonly strict?: boolean;
     payload: any;
     prop?: EntityProperty;
     index?: number;