@mikro-orm/knex 6.0.0-dev.0 → 6.0.0-dev.10

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);
     }

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

@@ -1,9 +1,9 @@
 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>);
@@ -18,6 +18,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}

@@ -27,7 +27,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,192 @@
+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 CriteriaNode = mod.CriteriaNode;
+export const CriteriaNodeFactory = mod.CriteriaNodeFactory;
+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 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 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 JavaScriptMetadataProvider = mod.JavaScriptMetadataProvider;
+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 PrimaryKeyType = mod.PrimaryKeyType;
+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 ReferenceType = mod.ReferenceType;
+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 UseRequestContext = mod.UseRequestContext;
+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 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.0+4ab7bdd0ca",
+  "version": "6.0.0-dev.10",
   "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.3.0",
+    "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.0.0-dev.0+4ab7bdd0ca"
+    "@mikro-orm/core": "^5.5.3"
   },
   "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": "4ab7bdd0caf4f80b6a646dcd66c5ac6b67308764"
+    "@mikro-orm/core": "~6.0.0-dev.10"
+  }
 }

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}`);
                 }
             });
@@ -56,11 +57,13 @@ class CriteriaNode {
         }
     }
     renameFieldToPK(qb) {
-        const alias = qb.getAliasForJoinPath(this.getPath()) ?? qb.alias;
+        const joinAlias = qb.getAliasForJoinPath(this.getPath());
+        const alias = joinAlias ?? qb.alias;
         if (this.prop.reference === core_1.ReferenceType.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}`));

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

@@ -22,7 +22,8 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             const payload = childNode.process(qb, this.prop ? alias : ownerAlias);
             const operator = core_1.Utils.isOperator(field);
             const customExpression = ObjectCriteriaNode.isCustomExpression(field);
-            const virtual = childNode.prop?.persist === false;
+            // we need to keep the prefixing for formulas otherwise we would lose aliasing context when nesting inside group operators
+            const virtual = childNode.prop?.persist === false && !childNode.prop?.formula;
             // if key is missing, we are inside group operator and we need to prefix with alias
             const primaryKey = this.key && this.metadata.find(this.entityName).primaryKeys.includes(field);
             if (childNode.shouldInline(payload)) {
@@ -78,10 +79,22 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                     delete o[key];
                     o.$and = $and;
                 }
+                else if (core_1.Utils.isOperator(k) && Array.isArray(payload[k])) {
+                    o[key] = payload[k].map((child) => Object.keys(child).reduce((o, childKey) => {
+                        const key = (this.isPrefixed(childKey) || core_1.Utils.isOperator(childKey))
+                            ? childKey
+                            : `${childAlias}.${childKey}`;
+                        o[key] = child[childKey];
+                        return o;
+                    }, {}));
+                }
                 else {
                     o[key] = payload[k];
                 }
             }
+            else if (ObjectCriteriaNode.isCustomExpression(k)) {
+                o[k] = payload[k];
+            }
             else {
                 o[`${childAlias}.${k}`] = payload[k];
             }