@mikro-orm/knex 6.5.10-dev.9 → 6.6.1-dev.0

package/AbstractSqlDriver.js

@@ -847,10 +847,10 @@ class AbstractSqlDriver extends core_1.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 = (0, core_1.getLoadingStrategy)(hint.strategy || prop.strategy || options?.strategy || this.config.get('loadStrategy'), prop.kind);
-            if (hint.filter && [core_1.ReferenceKind.ONE_TO_ONE, core_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) && !prop.nullable) {
+            if (ref && [core_1.ReferenceKind.ONE_TO_ONE, core_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
                 return true;
             }
             // skip redundant joins for 1:1 owner population hints when using `mapToPk`

package/index.d.ts

@@ -16,4 +16,5 @@ export { SqlEntityManager as EntityManager } from './SqlEntityManager';
 export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository';
 /** @ignore */
 export { Knex, knex } from 'knex';
+/** @ts-ignore */
 export * from '@mikro-orm/core';

package/index.js

@@ -38,4 +38,5 @@ Object.defineProperty(exports, "EntityRepository", { enumerable: true, get: func
 var knex_1 = require("knex");
 Object.defineProperty(exports, "Knex", { enumerable: true, get: function () { return knex_1.Knex; } });
 Object.defineProperty(exports, "knex", { enumerable: true, get: function () { return knex_1.knex; } });
+/** @ts-ignore */
 __exportStar(require("@mikro-orm/core"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.5.10-dev.9",
+  "version": "6.6.1-dev.0",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -63,10 +63,10 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.5.9"
+    "@mikro-orm/core": "^6.6.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.5.10-dev.9",
+    "@mikro-orm/core": "6.6.1-dev.0",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

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

@@ -21,5 +21,8 @@ class ArrayCriteriaNode extends CriteriaNode_1.CriteriaNode {
             return node.willAutoJoin(qb, alias, options);
         });
     }
+    isStrict() {
+        return this.strict || this.payload.some((node) => node.isStrict());
+    }
 }
 exports.ArrayCriteriaNode = ArrayCriteriaNode;

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

@@ -13,14 +13,16 @@ 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 = core_1.Utils.splitPrimaryKeys(key);
@@ -109,6 +111,9 @@ class CriteriaNode {
     aliased(field, alias) {
         return alias ? `${alias}.${field}` : field;
     }
+    isStrict() {
+        return this.strict;
+    }
     /** @ignore */
     [node_util_1.inspect.custom]() {
         const o = {};

package/query/CriteriaNodeFactory.js

@@ -39,7 +39,7 @@ class CriteriaNodeFactory {
     }
     static createObjectNode(metadata, entityName, payload, parent, key) {
         const meta = metadata.find(entityName);
-        const node = new ObjectCriteriaNode_1.ObjectCriteriaNode(metadata, entityName, parent, key);
+        const node = new ObjectCriteriaNode_1.ObjectCriteriaNode(metadata, entityName, parent, key, true, payload.__strict);
         node.payload = Object.keys(payload).reduce((o, item) => {
             o[item] = this.createObjectItemNode(metadata, entityName, node, payload, item, meta);
             return o;

package/query/ObjectCriteriaNode.d.ts

@@ -5,6 +5,7 @@ import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings';
  */
 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

@@ -61,6 +61,22 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             }
             alias = this.autoJoin(qb, ownerAlias, options);
         }
+        if (this.prop && nestedAlias) {
+            const toOneProperty = [core_1.ReferenceKind.MANY_TO_ONE, core_1.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 + '.' + core_1.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 });
@@ -92,6 +108,11 @@ class ObjectCriteriaNode extends CriteriaNode_1.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();
@@ -216,19 +237,6 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                 ? enums_1.JoinType.innerJoin
                 : enums_1.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 + '.' + core_1.Utils.getPrimaryKeyHash(this.prop.referencedPKs)]: { $ne: null } },
-                    ],
-                });
-            }
             if (!qb.hasFlag(core_1.QueryFlag.INFER_POPULATE)) {
                 qb._fields = prev;
             }

package/query/QueryBuilder.d.ts

@@ -1,6 +1,6 @@
 import { inspect } from 'node:util';
 import type { Knex } from 'knex';
-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 } 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 } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 import { type Alias, QueryBuilderHelper } from './QueryBuilderHelper';
@@ -147,7 +147,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
@@ -156,7 +156,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: Knex.QueryBuilder, 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

@@ -280,12 +280,13 @@ 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 === enums_1.JoinType.pivotJoin) {
                 continue;
             }
+            filterOptions = core_1.QueryHelper.mergePropertyFilters(join.prop.filters, filterOptions);
             const cond = await em.applyFilters(join.prop.type, join.cond, filterOptions, 'read');
             if (core_1.Utils.hasObjectKeys(cond)) {
                 // remove nested filters, we only care about scalars here, nesting would require another join branch
@@ -572,7 +573,7 @@ class QueryBuilder {
             return this._query.qb = this.knex.raw(qb.toSQL().toNative().sql + ' cascade');
         }
         if (this.lockMode) {
-            this.helper.getLockSQL(qb, this.lockMode, this.lockTables);
+            this.helper.getLockSQL(qb, this.lockMode, this.lockTables, this._joins);
         }
         this.helper.finalize(type, qb, this.mainAlias.metadata, this._data, this._returning);
         this.clearRawFragmentsCache();

package/query/QueryBuilderHelper.d.ts

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

package/query/QueryBuilderHelper.js

@@ -629,11 +629,18 @@ 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 === core_1.LockMode.OPTIMISTIC && meta && !meta.versionProperty) {
             throw core_1.OptimisticLockError.lockFailed(this.entityName);
         }
+        if (lockMode !== core_1.LockMode.OPTIMISTIC && lockTables.length === 0 && joinsMap) {
+            const joins = Object.values(joinsMap);
+            const innerJoins = joins.filter(join => [enums_1.JoinType.innerJoin, enums_1.JoinType.innerJoinLateral, enums_1.JoinType.nestedInnerJoin].includes(join.type));
+            if (joins.length > innerJoins.length) {
+                lockTables.push(this.alias, ...innerJoins.map(join => join.alias));
+            }
+        }
         switch (lockMode) {
             case core_1.LockMode.PESSIMISTIC_READ: return void qb.forShare(...lockTables);
             case core_1.LockMode.PESSIMISTIC_WRITE: return void qb.forUpdate(...lockTables);

package/query/index.d.ts

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

package/query/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.raw = void 0;
 __exportStar(require("./enums"), exports);
 __exportStar(require("./QueryBuilderHelper"), exports);
 __exportStar(require("./QueryBuilder"), exports);
@@ -22,3 +23,5 @@ __exportStar(require("./ArrayCriteriaNode"), exports);
 __exportStar(require("./ObjectCriteriaNode"), exports);
 __exportStar(require("./ScalarCriteriaNode"), exports);
 __exportStar(require("./CriteriaNodeFactory"), exports);
+var raw_1 = require("./raw");
+Object.defineProperty(exports, "raw", { enumerable: true, get: function () { return raw_1.rawKnex; } });

package/query/raw.d.ts

@@ -0,0 +1,59 @@
+import { type AnyString, type Dictionary, type EntityKey, type RawQueryFragment } from '@mikro-orm/core';
+import type { Knex } from 'knex';
+import { QueryBuilder } from './QueryBuilder';
+/**
+ * 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: Knex.QueryBuilder | Knex.Raw | 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,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawKnex = rawKnex;
+const core_1 = require("@mikro-orm/core");
+const QueryBuilder_1 = require("./QueryBuilder");
+/**
+ * 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 { ... }
+ * ```
+ */
+function rawKnex(sql, params) {
+    if (core_1.Utils.isObject(sql) && 'toSQL' in sql) {
+        const query = sql.toSQL();
+        return (0, core_1.raw)(query.sql, query.bindings);
+    }
+    if (sql instanceof QueryBuilder_1.QueryBuilder) {
+        const query = sql.toQuery()._sql;
+        return (0, core_1.raw)(query.sql, query.bindings);
+    }
+    return (0, core_1.raw)(sql, params);
+}

package/schema/DatabaseTable.js

@@ -614,7 +614,7 @@ class DatabaseTable {
             fkOptions.deferMode = fk.deferMode;
             fkOptions.columnTypes = fk.columnNames.map(col => this.getColumn(col).type);
         }
-        return {
+        const ret = {
             name: prop,
             type,
             runtimeType,
@@ -642,6 +642,11 @@ 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) {
@@ -675,10 +680,17 @@ 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

@@ -178,6 +178,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;