@mikro-orm/knex 6.0.0-dev.4 → 6.0.0-dev.40

package/{dist/AbstractSqlPlatform.d.ts → AbstractSqlPlatform.d.ts}

@@ -1,19 +1,19 @@
-import type { Constructor, EntityManager, EntityRepository, IDatabaseDriver } from '@mikro-orm/core';
+import type { Constructor, EntityManager, EntityRepository, IDatabaseDriver, MikroORM } from '@mikro-orm/core';
 import { Platform } from '@mikro-orm/core';
 import type { SchemaHelper } from './schema';
-import { SchemaGenerator } from './schema';
+import { SqlSchemaGenerator } from './schema';
 export declare abstract class AbstractSqlPlatform extends Platform {
     protected readonly schemaHelper?: SchemaHelper;
     usesPivotTable(): boolean;
     indexForeignKeys(): boolean;
-    getRepositoryClass<T>(): Constructor<EntityRepository<T>>;
+    getRepositoryClass<T extends object>(): Constructor<EntityRepository<T>>;
     getSchemaHelper(): SchemaHelper | undefined;
-    getSchemaGenerator(driver: IDatabaseDriver): SchemaGenerator;
-    getEntityGenerator(em: EntityManager): any;
-    getMigrator(em: EntityManager): any;
+    /** @inheritDoc */
+    lookupExtensions(orm: MikroORM): void;
+    getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): SqlSchemaGenerator;
     quoteValue(value: any): string;
     formatQuery(sql: string, params: readonly any[]): string;
-    getSearchJsonPropertySQL(path: string, type: string): string;
+    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string;
     isRaw(value: any): boolean;
     supportsSchemas(): boolean;
     /** @inheritDoc */

package/{dist/AbstractSqlPlatform.js → AbstractSqlPlatform.js}

@@ -18,20 +18,18 @@ class AbstractSqlPlatform extends core_1.Platform {
     getSchemaHelper() {
         return this.schemaHelper;
     }
-    getSchemaGenerator(driver) {
-        return new schema_1.SchemaGenerator(driver); // cast as `any` to get around circular dependencies
-    }
-    getEntityGenerator(em) {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { EntityGenerator } = require('@mikro-orm/entity-generator');
-        return new EntityGenerator(em);
+    /** @inheritDoc */
+    lookupExtensions(orm) {
+        schema_1.SqlSchemaGenerator.register(orm);
     }
-    getMigrator(em) {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { Migrator } = require('@mikro-orm/migrations');
-        return new Migrator(em);
+    /* istanbul ignore next: kept for type inference only */
+    getSchemaGenerator(driver, em) {
+        return new schema_1.SqlSchemaGenerator(em ?? driver);
     }
     quoteValue(value) {
+        if (this.isRaw(value)) {
+            return value;
+        }
         /* istanbul ignore if */
         if (core_1.Utils.isPlainObject(value) || value?.[core_1.JsonProperty]) {
             return (0, sqlstring_1.escape)(JSON.stringify(value));
@@ -68,11 +66,11 @@ class AbstractSqlPlatform extends core_1.Platform {
         }
         return ret;
     }
-    getSearchJsonPropertySQL(path, type) {
-        return this.getSearchJsonPropertyKey(path.split('->'), type);
+    getSearchJsonPropertySQL(path, type, aliased) {
+        return this.getSearchJsonPropertyKey(path.split('->'), type, aliased);
     }
     isRaw(value) {
-        return super.isRaw(value) || (typeof value === 'object' && value !== null && value.client && value.ref && value.constructor.name === 'Ref');
+        return super.isRaw(value) || (typeof value === 'object' && value !== null && value.client && ['Ref', 'Raw'].includes(value.constructor.name));
     }
     supportsSchemas() {
         return false;

package/{dist/README.md → README.md}

@@ -8,8 +8,8 @@ MariaDB, PostgreSQL and SQLite databases.
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Nextras Orm](https://nextras.org/orm/).
 
-[![NPM version](https://img.shields.io/npm/v/mikro-orm.svg)](https://www.npmjs.com/package/@mikro-orm/core)
-[![NPM dev version](https://img.shields.io/npm/v/mikro-orm/next.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![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)
 [![Chat on slack](https://img.shields.io/badge/chat-on%20slack-blue.svg)](https://join.slack.com/t/mikroorm/shared_invite/enQtNTM1ODYzMzM4MDk3LWM4ZDExMjU5ZDhmNjA2MmM3MWMwZmExNjhhNDdiYTMwNWM0MGY5ZTE3ZjkyZTMzOWExNDgyYmMzNDE1NDI5NjA)
 [![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/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)

package/{dist/SqlEntityManager.d.ts → SqlEntityManager.d.ts}

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import type { AnyEntity, EntityData, EntityName, EntityRepository, GetRepository, QueryResult } from '@mikro-orm/core';
+import type { AnyEntity, ConnectionType, EntityData, EntityName, EntityRepository, GetRepository, QueryResult } from '@mikro-orm/core';
 import { EntityManager } from '@mikro-orm/core';
 import type { AbstractSqlDriver } from './AbstractSqlDriver';
 import { QueryBuilder } from './query';
@@ -11,11 +11,11 @@ export declare class SqlEntityManager<D extends AbstractSqlDriver = AbstractSqlD
     /**
      * Creates a QueryBuilder instance
      */
-    createQueryBuilder<T>(entityName: EntityName<T>, alias?: string, type?: 'read' | 'write'): QueryBuilder<T>;
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, alias?: string, type?: ConnectionType): QueryBuilder<T>;
     /**
      * Shortcut for `createQueryBuilder()`
      */
-    qb<T>(entityName: EntityName<T>, alias?: string, type?: 'read' | 'write'): QueryBuilder<T>;
+    qb<T extends object>(entityName: EntityName<T>, alias?: string, type?: ConnectionType): QueryBuilder<T>;
     /**
      * Creates raw SQL query that won't be escaped when used as a parameter.
      */
@@ -23,7 +23,7 @@ export declare class SqlEntityManager<D extends AbstractSqlDriver = AbstractSqlD
     /**
      * Returns configured knex instance.
      */
-    getKnex(type?: 'read' | 'write'): Knex<any, Record<string, any>[]>;
+    getKnex(type?: ConnectionType): Knex<any, any[]>;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: any[], method?: 'all' | 'get' | 'run'): Promise<T>;
-    getRepository<T extends AnyEntity<T>, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
+    getRepository<T extends object, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
 }

package/{dist/SqlEntityManager.js → SqlEntityManager.js}

@@ -11,7 +11,6 @@ class SqlEntityManager extends core_1.EntityManager {
      * Creates a QueryBuilder instance
      */
     createQueryBuilder(entityName, alias, type) {
-        entityName = core_1.Utils.className(entityName);
         const context = this.getContext();
         return new query_1.QueryBuilder(entityName, this.getMetadata(), this.getDriver(), context.getTransactionContext(), alias, type, context);
     }
@@ -36,7 +35,7 @@ class SqlEntityManager extends core_1.EntityManager {
         return this.getConnection(type).getKnex();
     }
     async execute(queryOrKnex, params = [], method = 'all') {
-        return this.getDriver().execute(queryOrKnex, params, method, this.getTransactionContext());
+        return this.getDriver().execute(queryOrKnex, params, method, this.getContext(false).getTransactionContext());
     }
     getRepository(entityName) {
         return super.getRepository(entityName);

package/{dist/SqlEntityRepository.d.ts → SqlEntityRepository.d.ts}

@@ -1,11 +1,10 @@
 import type { Knex } from 'knex';
-import type { EntityName } from '@mikro-orm/core';
+import type { ConnectionType, EntityName } from '@mikro-orm/core';
 import { EntityRepository } from '@mikro-orm/core';
 import type { SqlEntityManager } from './SqlEntityManager';
 import type { QueryBuilder } from './query';
-export declare class SqlEntityRepository<T> extends EntityRepository<T> {
+export declare class SqlEntityRepository<T extends object> extends EntityRepository<T> {
     protected readonly _em: SqlEntityManager;
-    protected readonly entityName: EntityName<T>;
     constructor(_em: SqlEntityManager, entityName: EntityName<T>);
     /**
      * Creates a QueryBuilder instance
@@ -18,6 +17,6 @@ export declare class SqlEntityRepository<T> extends EntityRepository<T> {
     /**
      * Returns configured knex instance.
      */
-    getKnex(type?: 'read' | 'write'): Knex;
+    getKnex(type?: ConnectionType): Knex;
     protected get em(): SqlEntityManager;
 }

package/{dist/SqlEntityRepository.js → SqlEntityRepository.js}

@@ -6,7 +6,6 @@ class SqlEntityRepository extends core_1.EntityRepository {
     constructor(_em, entityName) {
         super(_em, entityName);
         this._em = _em;
-        this.entityName = entityName;
     }
     /**
      * Creates a QueryBuilder instance
@@ -27,7 +26,7 @@ class SqlEntityRepository extends core_1.EntityRepository {
         return this.em.getConnection(type).getKnex();
     }
     get em() {
-        return this._em.getContext();
+        return this._em.getContext(false);
     }
 }
 exports.SqlEntityRepository = SqlEntityRepository;

package/{dist/index.d.ts → index.d.ts}

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

package/{dist/index.js → index.js}

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -33,3 +37,4 @@ 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; } });
+__exportStar(require("@mikro-orm/core"), exports);

package/index.mjs

@@ -0,0 +1,194 @@
+import mod from "./index.js";
+
+export default mod;
+export const ARRAY_OPERATORS = mod.ARRAY_OPERATORS;
+export const AbstractNamingStrategy = mod.AbstractNamingStrategy;
+export const AbstractSchemaGenerator = mod.AbstractSchemaGenerator;
+export const AbstractSqlConnection = mod.AbstractSqlConnection;
+export const AbstractSqlDriver = mod.AbstractSqlDriver;
+export const AbstractSqlPlatform = mod.AbstractSqlPlatform;
+export const AfterCreate = mod.AfterCreate;
+export const AfterDelete = mod.AfterDelete;
+export const AfterUpdate = mod.AfterUpdate;
+export const ArrayCollection = mod.ArrayCollection;
+export const ArrayCriteriaNode = mod.ArrayCriteriaNode;
+export const ArrayType = mod.ArrayType;
+export const BaseEntity = mod.BaseEntity;
+export const BeforeCreate = mod.BeforeCreate;
+export const BeforeDelete = mod.BeforeDelete;
+export const BeforeUpdate = mod.BeforeUpdate;
+export const BigIntType = mod.BigIntType;
+export const BlobType = mod.BlobType;
+export const BooleanType = mod.BooleanType;
+export const Cascade = mod.Cascade;
+export const ChangeSet = mod.ChangeSet;
+export const ChangeSetComputer = mod.ChangeSetComputer;
+export const ChangeSetPersister = mod.ChangeSetPersister;
+export const ChangeSetType = mod.ChangeSetType;
+export const Check = mod.Check;
+export const CheckConstraintViolationException = mod.CheckConstraintViolationException;
+export const Collection = mod.Collection;
+export const CommitOrderCalculator = mod.CommitOrderCalculator;
+export const Configuration = mod.Configuration;
+export const ConfigurationLoader = mod.ConfigurationLoader;
+export const Connection = mod.Connection;
+export const ConnectionException = mod.ConnectionException;
+export const ConstraintViolationException = mod.ConstraintViolationException;
+export const CreateRequestContext = mod.CreateRequestContext;
+export const CriteriaNode = mod.CriteriaNode;
+export const CriteriaNodeFactory = mod.CriteriaNodeFactory;
+export const Cursor = mod.Cursor;
+export const DatabaseDriver = mod.DatabaseDriver;
+export const DatabaseObjectExistsException = mod.DatabaseObjectExistsException;
+export const DatabaseObjectNotFoundException = mod.DatabaseObjectNotFoundException;
+export const DatabaseSchema = mod.DatabaseSchema;
+export const DatabaseTable = mod.DatabaseTable;
+export const DateTimeType = mod.DateTimeType;
+export const DateType = mod.DateType;
+export const DeadlockException = mod.DeadlockException;
+export const DecimalType = mod.DecimalType;
+export const DefaultLogger = mod.DefaultLogger;
+export const DoubleType = mod.DoubleType;
+export const DriverException = mod.DriverException;
+export const Embeddable = mod.Embeddable;
+export const Embedded = mod.Embedded;
+export const EnsureRequestContext = mod.EnsureRequestContext;
+export const Entity = mod.Entity;
+export const EntityAssigner = mod.EntityAssigner;
+export const EntityCaseNamingStrategy = mod.EntityCaseNamingStrategy;
+export const EntityComparator = mod.EntityComparator;
+export const EntityFactory = mod.EntityFactory;
+export const EntityHelper = mod.EntityHelper;
+export const EntityIdentifier = mod.EntityIdentifier;
+export const EntityLoader = mod.EntityLoader;
+export const EntityManager = mod.EntityManager;
+export const EntityManagerType = mod.EntityManagerType;
+export const EntityMetadata = mod.EntityMetadata;
+export const EntityRepository = mod.EntityRepository;
+export const EntityRepositoryType = mod.EntityRepositoryType;
+export const EntitySchema = mod.EntitySchema;
+export const EntitySerializer = mod.EntitySerializer;
+export const EntityTransformer = mod.EntityTransformer;
+export const EntityValidator = mod.EntityValidator;
+export const Enum = mod.Enum;
+export const EnumArrayType = mod.EnumArrayType;
+export const EnumType = mod.EnumType;
+export const EventManager = mod.EventManager;
+export const EventType = mod.EventType;
+export const EventTypeMap = mod.EventTypeMap;
+export const ExceptionConverter = mod.ExceptionConverter;
+export const FileCacheAdapter = mod.FileCacheAdapter;
+export const Filter = mod.Filter;
+export const FloatType = mod.FloatType;
+export const FlushMode = mod.FlushMode;
+export const ForeignKeyConstraintViolationException = mod.ForeignKeyConstraintViolationException;
+export const Formula = mod.Formula;
+export const GroupOperator = mod.GroupOperator;
+export const Hydrator = mod.Hydrator;
+export const IdentityMap = mod.IdentityMap;
+export const Index = mod.Index;
+export const IntegerType = mod.IntegerType;
+export const InvalidFieldNameException = mod.InvalidFieldNameException;
+export const IsolationLevel = mod.IsolationLevel;
+export const JsonProperty = mod.JsonProperty;
+export const JsonType = mod.JsonType;
+export const Knex = mod.Knex;
+export const LoadStrategy = mod.LoadStrategy;
+export const LockMode = mod.LockMode;
+export const LockWaitTimeoutException = mod.LockWaitTimeoutException;
+export const ManyToMany = mod.ManyToMany;
+export const ManyToOne = mod.ManyToOne;
+export const MediumIntType = mod.MediumIntType;
+export const MemoryCacheAdapter = mod.MemoryCacheAdapter;
+export const MetadataDiscovery = mod.MetadataDiscovery;
+export const MetadataError = mod.MetadataError;
+export const MetadataProvider = mod.MetadataProvider;
+export const MetadataStorage = mod.MetadataStorage;
+export const MetadataValidator = mod.MetadataValidator;
+export const MikroORM = mod.MikroORM;
+export const MongoNamingStrategy = mod.MongoNamingStrategy;
+export const MonkeyPatchable = mod.MonkeyPatchable;
+export const NodeState = mod.NodeState;
+export const NonUniqueFieldNameException = mod.NonUniqueFieldNameException;
+export const NotFoundError = mod.NotFoundError;
+export const NotNullConstraintViolationException = mod.NotNullConstraintViolationException;
+export const NullCacheAdapter = mod.NullCacheAdapter;
+export const NullHighlighter = mod.NullHighlighter;
+export const ObjectBindingPattern = mod.ObjectBindingPattern;
+export const ObjectCriteriaNode = mod.ObjectCriteriaNode;
+export const ObjectHydrator = mod.ObjectHydrator;
+export const OnInit = mod.OnInit;
+export const OnLoad = mod.OnLoad;
+export const OneToMany = mod.OneToMany;
+export const OneToOne = mod.OneToOne;
+export const OptimisticLockError = mod.OptimisticLockError;
+export const OptionalProps = mod.OptionalProps;
+export const PlainObject = mod.PlainObject;
+export const Platform = mod.Platform;
+export const PopulateHint = mod.PopulateHint;
+export const PrimaryKey = mod.PrimaryKey;
+export const PrimaryKeyProp = mod.PrimaryKeyProp;
+export const Property = mod.Property;
+export const QueryBuilder = mod.QueryBuilder;
+export const QueryBuilderHelper = mod.QueryBuilderHelper;
+export const QueryFlag = mod.QueryFlag;
+export const QueryHelper = mod.QueryHelper;
+export const QueryOperator = mod.QueryOperator;
+export const QueryOrder = mod.QueryOrder;
+export const QueryOrderNumeric = mod.QueryOrderNumeric;
+export const QueryType = mod.QueryType;
+export const ReadOnlyException = mod.ReadOnlyException;
+export const Reference = mod.Reference;
+export const ReferenceKind = mod.ReferenceKind;
+export const ReflectMetadataProvider = mod.ReflectMetadataProvider;
+export const RequestContext = mod.RequestContext;
+export const SCALAR_TYPES = mod.SCALAR_TYPES;
+export const ScalarCriteriaNode = mod.ScalarCriteriaNode;
+export const SchemaComparator = mod.SchemaComparator;
+export const SchemaGenerator = mod.SchemaGenerator;
+export const SchemaHelper = mod.SchemaHelper;
+export const SerializationContext = mod.SerializationContext;
+export const SerializedPrimaryKey = mod.SerializedPrimaryKey;
+export const ServerException = mod.ServerException;
+export const SimpleLogger = mod.SimpleLogger;
+export const SmallIntType = mod.SmallIntType;
+export const SqlEntityManager = mod.SqlEntityManager;
+export const SqlEntityRepository = mod.SqlEntityRepository;
+export const SqlSchemaGenerator = mod.SqlSchemaGenerator;
+export const StringType = mod.StringType;
+export const Subscriber = mod.Subscriber;
+export const SyntaxErrorException = mod.SyntaxErrorException;
+export const TableExistsException = mod.TableExistsException;
+export const TableNotFoundException = mod.TableNotFoundException;
+export const TextType = mod.TextType;
+export const TimeType = mod.TimeType;
+export const TinyIntType = mod.TinyIntType;
+export const TransactionContext = mod.TransactionContext;
+export const TransactionEventBroadcaster = mod.TransactionEventBroadcaster;
+export const Type = mod.Type;
+export const UnderscoreNamingStrategy = mod.UnderscoreNamingStrategy;
+export const Unique = mod.Unique;
+export const UniqueConstraintViolationException = mod.UniqueConstraintViolationException;
+export const UnitOfWork = mod.UnitOfWork;
+export const UnknownType = mod.UnknownType;
+export const Utils = mod.Utils;
+export const UuidType = mod.UuidType;
+export const ValidationError = mod.ValidationError;
+export const WrappedEntity = mod.WrappedEntity;
+export const assign = mod.assign;
+export const colors = mod.colors;
+export const compareArrays = mod.compareArrays;
+export const compareBooleans = mod.compareBooleans;
+export const compareBuffers = mod.compareBuffers;
+export const compareObjects = mod.compareObjects;
+export const defineConfig = mod.defineConfig;
+export const equals = mod.equals;
+export const expr = mod.expr;
+export const helper = mod.helper;
+export const knex = mod.knex;
+export const ref = mod.ref;
+export const rel = mod.rel;
+export const serialize = mod.serialize;
+export const t = mod.t;
+export const types = mod.types;
+export const wrap = mod.wrap;

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.4+5d8bf0c0c2",
+  "version": "6.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.",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "typings": "dist/index.d.ts",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.mjs"
+      },
+      "require": "./index.js"
     }
   },
   "repository": {
@@ -43,58 +46,26 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 14.0.0"
+    "node": ">= 16.0.0"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
-    "postbuild": "yarn gen-esm-wrapper dist/index.js dist/index.mjs",
+    "build": "yarn clean && yarn compile && yarn copy && yarn run -T gen-esm-wrapper index.js index.mjs",
     "clean": "rimraf ./dist",
     "compile": "tsc -p tsconfig.build.json",
-    "copy": "ts-node -T ../../scripts/copy.ts"
+    "copy": "node ../../scripts/copy.mjs"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "fs-extra": "10.0.0",
-    "knex": "1.0.1",
-    "sqlstring": "2.3.2"
+    "fs-extra": "11.1.0",
+    "knex": "2.4.2",
+    "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.0.0-dev.4+5d8bf0c0c2"
+    "@mikro-orm/core": "^5.6.10"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "^5.0.0",
-    "@mikro-orm/entity-generator": "^5.0.0",
-    "@mikro-orm/migrations": "^5.0.0",
-    "@vscode/sqlite3": "^5.0.0",
-    "mssql": "^7.0.0",
-    "mysql": "^2.18.1",
-    "mysql2": "^2.1.0",
-    "pg": "^8.0.3"
-  },
-  "peerDependenciesMeta": {
-    "@mikro-orm/entity-generator": {
-      "optional": true
-    },
-    "@mikro-orm/migrations": {
-      "optional": true
-    },
-    "@vscode/sqlite3": {
-      "optional": true
-    },
-    "mssql": {
-      "optional": true
-    },
-    "mysql": {
-      "optional": true
-    },
-    "mysql2": {
-      "optional": true
-    },
-    "pg": {
-      "optional": true
-    }
-  },
-  "gitHead": "5d8bf0c0c2254b0bcc0160827108ee17a8d63442"
+    "@mikro-orm/core": "~6.0.0-dev.40"
+  }
 }

package/query/ArrayCriteriaNode.d.ts

@@ -0,0 +1,9 @@
+import { CriteriaNode } from './CriteriaNode';
+import type { IQueryBuilder } from '../typings';
+/**
+ * @internal
+ */
+export declare class ArrayCriteriaNode<T extends object> extends CriteriaNode<T> {
+    process(qb: IQueryBuilder<T>, alias?: string): any;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string): any;
+}

package/{dist/query → query}/CriteriaNode.d.ts

@@ -1,24 +1,24 @@
 /// <reference types="node" />
 import { inspect } from 'util';
-import type { EntityProperty, MetadataStorage } from '@mikro-orm/core';
+import type { EntityKey, EntityProperty, MetadataStorage } from '@mikro-orm/core';
 import type { ICriteriaNode, IQueryBuilder } from '../typings';
 /**
  * Helper for working with deeply nested where/orderBy/having criteria. Uses composite pattern to build tree from the payload.
  * Auto-joins relations and converts payload from { books: { publisher: { name: '...' } } } to { 'publisher_alias.name': '...' }
  * @internal
  */
-export declare class CriteriaNode implements ICriteriaNode {
+export declare class CriteriaNode<T extends object> implements ICriteriaNode<T> {
     protected readonly metadata: MetadataStorage;
     readonly entityName: string;
-    readonly parent?: ICriteriaNode | undefined;
-    readonly key?: string | undefined;
+    readonly parent?: ICriteriaNode<T> | undefined;
+    readonly key?: EntityKey<T> | undefined;
     payload: any;
-    prop?: EntityProperty;
+    prop?: EntityProperty<T>;
     index?: number;
-    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode | undefined, key?: string | undefined, validate?: boolean);
-    process<T>(qb: IQueryBuilder<T>, alias?: string): any;
+    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | undefined, validate?: boolean);
+    process(qb: IQueryBuilder<T>, alias?: string): any;
     shouldInline(payload: any): boolean;
-    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string): boolean;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string): boolean;
     shouldRename(payload: any): boolean;
     renameFieldToPK<T>(qb: IQueryBuilder<T>): string;
     getPath(addIndex?: boolean): string;

package/{dist/query → query}/CriteriaNode.js

@@ -21,9 +21,10 @@ class CriteriaNode {
                 return;
             }
             pks.forEach(k => {
-                this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames || []).includes(k));
+                this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k));
+                const isProp = this.prop || meta.props.find(prop => (prop.fieldNames || []).includes(k));
                 // do not validate if the key is prefixed or type casted (e.g. `k::text`)
-                if (validate && !this.prop && !k.includes('.') && !k.includes('::') && !core_1.Utils.isOperator(k) && !CriteriaNode.isCustomExpression(k)) {
+                if (validate && !isProp && !k.includes('.') && !k.includes('::') && !core_1.Utils.isOperator(k) && !CriteriaNode.isCustomExpression(k)) {
                     throw new Error(`Trying to query by not existing property ${entityName}.${k}`);
                 }
             });
@@ -39,7 +40,7 @@ class CriteriaNode {
         return false;
     }
     shouldRename(payload) {
-        const type = this.prop ? this.prop.reference : null;
+        const type = this.prop ? this.prop.kind : null;
         const composite = this.prop?.joinColumns ? this.prop.joinColumns.length > 1 : false;
         const customExpression = CriteriaNode.isCustomExpression(this.key);
         const scalar = payload === null || core_1.Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
@@ -48,26 +49,28 @@ class CriteriaNode {
             return true;
         }
         switch (type) {
-            case core_1.ReferenceType.MANY_TO_ONE: return false;
-            case core_1.ReferenceType.ONE_TO_ONE: return !this.prop.owner;
-            case core_1.ReferenceType.ONE_TO_MANY: return scalar || operator;
-            case core_1.ReferenceType.MANY_TO_MANY: return scalar || operator;
+            case core_1.ReferenceKind.MANY_TO_ONE: return false;
+            case core_1.ReferenceKind.ONE_TO_ONE: return !this.prop.owner;
+            case core_1.ReferenceKind.ONE_TO_MANY: return scalar || operator;
+            case core_1.ReferenceKind.MANY_TO_MANY: return scalar || operator;
             default: return false;
         }
     }
     renameFieldToPK(qb) {
-        const alias = qb.getAliasForJoinPath(this.getPath()) ?? qb.alias;
-        if (this.prop.reference === core_1.ReferenceType.MANY_TO_MANY) {
+        const joinAlias = qb.getAliasForJoinPath(this.getPath());
+        const alias = joinAlias ?? qb.alias;
+        if (this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY) {
             return core_1.Utils.getPrimaryKeyHash(this.prop.inverseJoinColumns.map(col => `${alias}.${col}`));
         }
-        if (this.prop.joinColumns.length > 1) {
+        // if we found a matching join, we need to use the target table column names, as we use that alias instead of the root
+        if (!joinAlias && this.prop.owner && this.prop.joinColumns.length > 1) {
             return core_1.Utils.getPrimaryKeyHash(this.prop.joinColumns.map(col => `${alias}.${col}`));
         }
         return core_1.Utils.getPrimaryKeyHash(this.prop.referencedColumnNames.map(col => `${alias}.${col}`));
     }
     getPath(addIndex = false) {
         // use index on parent only if we are processing to-many relation
-        const addParentIndex = this.prop && [core_1.ReferenceType.ONE_TO_MANY, core_1.ReferenceType.MANY_TO_MANY].includes(this.prop.reference);
+        const addParentIndex = this.prop && [core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(this.prop.kind);
         const parentPath = this.parent?.getPath(addParentIndex) ?? this.entityName;
         const index = addIndex && this.index != null ? `[${this.index}]` : '';
         // ignore group operators to allow easier mapping (e.g. for orderBy)
@@ -86,7 +89,7 @@ class CriteriaNode {
         const customExpression = CriteriaNode.isCustomExpression(this.key);
         const scalar = this.payload === null || core_1.Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
         const operator = core_1.Utils.isObject(this.payload) && Object.keys(this.payload).every(k => core_1.Utils.isOperator(k, false));
-        return this.prop.reference === core_1.ReferenceType.MANY_TO_MANY && (scalar || operator);
+        return this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY && (scalar || operator);
     }
     getPivotPath(path) {
         return `${path}[pivot]`;

package/query/CriteriaNodeFactory.d.ts

@@ -0,0 +1,12 @@
+import type { Dictionary, EntityKey, EntityMetadata, MetadataStorage } from '@mikro-orm/core';
+import type { ICriteriaNode } from '../typings';
+/**
+ * @internal
+ */
+export declare class CriteriaNodeFactory {
+    static createNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createArrayNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any[], parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createObjectNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: Dictionary, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: string, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T>, meta?: EntityMetadata<T>): ICriteriaNode<T>;
+}