@mikro-orm/knex 6.0.0-dev.20 → 6.0.0-dev.200

package/SqlEntityRepository.d.ts

@@ -1,12 +1,10 @@
 import type { Knex } from 'knex';
-import type { ConnectionType, EntityName } from '@mikro-orm/core';
-import { EntityRepository } from '@mikro-orm/core';
+import { EntityRepository, type ConnectionType, type EntityName } from '@mikro-orm/core';
 import type { SqlEntityManager } from './SqlEntityManager';
 import type { QueryBuilder } from './query';
 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>);
+    protected readonly em: SqlEntityManager;
+    constructor(em: SqlEntityManager, entityName: EntityName<T>);
     /**
      * Creates a QueryBuilder instance
      */
@@ -19,5 +17,8 @@ export declare class SqlEntityRepository<T extends object> extends EntityReposit
      * Returns configured knex instance.
      */
     getKnex(type?: ConnectionType): Knex;
-    protected get em(): SqlEntityManager;
+    /**
+     * @inheritDoc
+     */
+    getEntityManager(): SqlEntityManager;
 }

package/SqlEntityRepository.js

@@ -3,16 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqlEntityRepository = void 0;
 const core_1 = require("@mikro-orm/core");
 class SqlEntityRepository extends core_1.EntityRepository {
-    constructor(_em, entityName) {
-        super(_em, entityName);
-        this._em = _em;
-        this.entityName = entityName;
+    em;
+    constructor(em, entityName) {
+        super(em, entityName);
+        this.em = em;
     }
     /**
      * Creates a QueryBuilder instance
      */
     createQueryBuilder(alias) {
-        return this.em.createQueryBuilder(this.entityName, alias);
+        return this.getEntityManager().createQueryBuilder(this.entityName, alias);
     }
     /**
      * Shortcut for `createQueryBuilder()`
@@ -24,10 +24,13 @@ class SqlEntityRepository extends core_1.EntityRepository {
      * Returns configured knex instance.
      */
     getKnex(type) {
-        return this.em.getConnection(type).getKnex();
+        return this.getEntityManager().getKnex(type);
     }
-    get em() {
-        return this._em.getContext(false);
+    /**
+     * @inheritDoc
+     */
+    getEntityManager() {
+        return this.em;
     }
 }
 exports.SqlEntityRepository = SqlEntityRepository;

package/index.mjs

@@ -1,6 +1,8 @@
 import mod from "./index.js";
 
 export default mod;
+export const ALIAS_REPLACEMENT = mod.ALIAS_REPLACEMENT;
+export const ALIAS_REPLACEMENT_RE = mod.ALIAS_REPLACEMENT_RE;
 export const ARRAY_OPERATORS = mod.ARRAY_OPERATORS;
 export const AbstractNamingStrategy = mod.AbstractNamingStrategy;
 export const AbstractSchemaGenerator = mod.AbstractSchemaGenerator;
@@ -10,6 +12,7 @@ export const AbstractSqlPlatform = mod.AbstractSqlPlatform;
 export const AfterCreate = mod.AfterCreate;
 export const AfterDelete = mod.AfterDelete;
 export const AfterUpdate = mod.AfterUpdate;
+export const AfterUpsert = mod.AfterUpsert;
 export const ArrayCollection = mod.ArrayCollection;
 export const ArrayCriteriaNode = mod.ArrayCriteriaNode;
 export const ArrayType = mod.ArrayType;
@@ -17,6 +20,7 @@ export const BaseEntity = mod.BaseEntity;
 export const BeforeCreate = mod.BeforeCreate;
 export const BeforeDelete = mod.BeforeDelete;
 export const BeforeUpdate = mod.BeforeUpdate;
+export const BeforeUpsert = mod.BeforeUpsert;
 export const BigIntType = mod.BigIntType;
 export const BlobType = mod.BlobType;
 export const BooleanType = mod.BooleanType;
@@ -34,13 +38,17 @@ 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 Dataloader = mod.Dataloader;
+export const DataloaderUtils = mod.DataloaderUtils;
 export const DateTimeType = mod.DateTimeType;
 export const DateType = mod.DateType;
 export const DeadlockException = mod.DeadlockException;
@@ -48,8 +56,10 @@ export const DecimalType = mod.DecimalType;
 export const DefaultLogger = mod.DefaultLogger;
 export const DoubleType = mod.DoubleType;
 export const DriverException = mod.DriverException;
+export const EagerProps = mod.EagerProps;
 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;
@@ -72,6 +82,7 @@ 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;
@@ -79,13 +90,16 @@ export const FloatType = mod.FloatType;
 export const FlushMode = mod.FlushMode;
 export const ForeignKeyConstraintViolationException = mod.ForeignKeyConstraintViolationException;
 export const Formula = mod.Formula;
+export const GeneratedCacheAdapter = mod.GeneratedCacheAdapter;
 export const GroupOperator = mod.GroupOperator;
+export const HiddenProps = mod.HiddenProps;
 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 JoinType = mod.JoinType;
 export const JsonProperty = mod.JsonProperty;
 export const JsonType = mod.JsonType;
 export const Knex = mod.Knex;
@@ -124,7 +138,6 @@ 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;
@@ -134,13 +147,16 @@ export const QueryOperator = mod.QueryOperator;
 export const QueryOrder = mod.QueryOrder;
 export const QueryOrderNumeric = mod.QueryOrderNumeric;
 export const QueryType = mod.QueryType;
+export const RawQueryFragment = mod.RawQueryFragment;
 export const ReadOnlyException = mod.ReadOnlyException;
+export const Ref = mod.Ref;
 export const Reference = mod.Reference;
-export const ReferenceType = mod.ReferenceType;
+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 ScalarReference = mod.ScalarReference;
 export const SchemaComparator = mod.SchemaComparator;
 export const SchemaGenerator = mod.SchemaGenerator;
 export const SchemaHelper = mod.SchemaHelper;
@@ -153,7 +169,6 @@ 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;
@@ -163,12 +178,12 @@ export const TinyIntType = mod.TinyIntType;
 export const TransactionContext = mod.TransactionContext;
 export const TransactionEventBroadcaster = mod.TransactionEventBroadcaster;
 export const Type = mod.Type;
+export const Uint8ArrayType = mod.Uint8ArrayType;
 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;
@@ -181,12 +196,16 @@ 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 getOnConflictFields = mod.getOnConflictFields;
+export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
 export const helper = mod.helper;
 export const knex = mod.knex;
+export const parseJsonSafe = mod.parseJsonSafe;
+export const raw = mod.raw;
 export const ref = mod.ref;
 export const rel = mod.rel;
 export const serialize = mod.serialize;
+export const sql = mod.sql;
 export const t = mod.t;
 export const types = mod.types;
 export const wrap = mod.wrap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.20",
+  "version": "6.0.0-dev.200",
   "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",
@@ -46,26 +46,26 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 16.0.0"
+    "node": ">= 18.12.0"
   },
   "scripts": {
     "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",
+    "clean": "yarn run -T rimraf ./dist",
+    "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "fs-extra": "11.1.0",
-    "knex": "2.4.0",
+    "fs-extra": "11.1.1",
+    "knex": "3.0.1",
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^5.6.4"
+    "@mikro-orm/core": "^5.9.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "~6.0.0-dev.20"
+    "@mikro-orm/core": "6.0.0-dev.200"
   }
 }

package/query/ArrayCriteriaNode.d.ts

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

package/query/ArrayCriteriaNode.js

@@ -6,9 +6,14 @@ const CriteriaNode_1 = require("./CriteriaNode");
  * @internal
  */
 class ArrayCriteriaNode extends CriteriaNode_1.CriteriaNode {
-    process(qb, alias) {
+    process(qb, options) {
         return this.payload.map((node) => {
-            return node.process(qb, alias);
+            return node.process(qb, options);
+        });
+    }
+    unwrap() {
+        return this.payload.map((node) => {
+            return node.unwrap();
         });
     }
     willAutoJoin(qb, alias) {

package/query/CriteriaNode.d.ts

@@ -1,29 +1,31 @@
 /// <reference types="node" />
 import { inspect } from 'util';
-import type { EntityProperty, MetadataStorage } from '@mikro-orm/core';
-import type { ICriteriaNode, IQueryBuilder } from '../typings';
+import { type EntityProperty, type MetadataStorage, type EntityKey } from '@mikro-orm/core';
+import type { ICriteriaNode, ICriteriaNodeProcessOptions, 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>, options?: ICriteriaNodeProcessOptions): any;
+    unwrap(): 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;
     private isPivotJoin;
     getPivotPath(path: string): string;
+    /** @ignore */
     [inspect.custom](): string;
     static isCustomExpression(field: string): boolean;
 }

package/query/CriteriaNode.js

@@ -9,6 +9,13 @@ const core_1 = require("@mikro-orm/core");
  * @internal
  */
 class CriteriaNode {
+    metadata;
+    entityName;
+    parent;
+    key;
+    payload;
+    prop;
+    index;
     constructor(metadata, entityName, parent, key, validate = true) {
         this.metadata = metadata;
         this.entityName = entityName;
@@ -30,7 +37,10 @@ class CriteriaNode {
             });
         }
     }
-    process(qb, alias) {
+    process(qb, options) {
+        return this.payload;
+    }
+    unwrap() {
         return this.payload;
     }
     shouldInline(payload) {
@@ -40,26 +50,28 @@ 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;
-        const operator = core_1.Utils.isPlainObject(payload) && Object.keys(payload).every(k => core_1.Utils.isOperator(k, false));
+        const plainObject = core_1.Utils.isPlainObject(payload);
+        const keys = plainObject ? Object.keys(payload) : [];
+        const operator = plainObject && keys.every(k => core_1.Utils.isOperator(k, false));
         if (composite) {
             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 joinAlias = qb.getAliasForJoinPath(this.getPath());
         const alias = joinAlias ?? qb.alias;
-        if (this.prop.reference === core_1.ReferenceType.MANY_TO_MANY) {
+        if (this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY) {
             return core_1.Utils.getPrimaryKeyHash(this.prop.inverseJoinColumns.map(col => `${alias}.${col}`));
         }
         // if we found a matching join, we need to use the target table column names, as we use that alias instead of the root
@@ -70,7 +82,7 @@ class CriteriaNode {
     }
     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)
@@ -89,15 +101,16 @@ 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]`;
     }
+    /** @ignore */
     [util_1.inspect.custom]() {
         const o = {};
         ['entityName', 'key', 'index', 'payload']
-            .filter(k => this[k] != null)
+            .filter(k => this[k] !== undefined)
             .forEach(k => o[k] = this[k]);
         return `${this.constructor.name} ${(0, util_1.inspect)(o)}`;
     }

package/query/CriteriaNodeFactory.d.ts

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

package/query/CriteriaNodeFactory.js

@@ -12,7 +12,7 @@ const CriteriaNode_1 = require("./CriteriaNode");
 class CriteriaNodeFactory {
     static createNode(metadata, entityName, payload, parent, key) {
         const customExpression = CriteriaNode_1.CriteriaNode.isCustomExpression(key || '');
-        const scalar = core_1.Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
+        const scalar = core_1.Utils.isPrimaryKey(payload) || core_1.Utils.isRawSql(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
         if (Array.isArray(payload) && !scalar) {
             return this.createArrayNode(metadata, entityName, payload, parent, key);
         }
@@ -30,16 +30,16 @@ class CriteriaNodeFactory {
         const node = new ArrayCriteriaNode_1.ArrayCriteriaNode(metadata, entityName, parent, key);
         node.payload = payload.map((item, index) => {
             const n = this.createNode(metadata, entityName, item, node);
-            n.index = key === '$and' ? index : undefined; // we care about branching only for $and
+            // we care about branching only for $and
+            if (key === '$and' && payload.length > 1) {
+                n.index = index;
+            }
             return n;
         });
         return node;
     }
     static createObjectNode(metadata, entityName, payload, parent, key) {
         const meta = metadata.find(entityName);
-        if (!parent && Object.keys(payload).every(k => meta?.properties[k]?.reference === core_1.ReferenceType.SCALAR)) {
-            return this.createScalarNode(metadata, entityName, payload, parent, key);
-        }
         const node = new ObjectCriteriaNode_1.ObjectCriteriaNode(metadata, entityName, parent, key);
         node.payload = Object.keys(payload).reduce((o, item) => {
             o[item] = this.createObjectItemNode(metadata, entityName, node, payload, item, meta);
@@ -47,24 +47,41 @@ class CriteriaNodeFactory {
         }, {});
         return node;
     }
-    static createObjectItemNode(metadata, entityName, node, payload, item, meta) {
-        const prop = meta?.properties[item];
-        if (prop?.reference !== core_1.ReferenceType.EMBEDDED) {
-            const childEntity = prop && prop.reference !== core_1.ReferenceType.SCALAR ? prop.type : entityName;
-            return this.createNode(metadata, childEntity, payload[item], node, item);
+    static createObjectItemNode(metadata, entityName, node, payload, key, meta) {
+        const prop = meta?.properties[key];
+        const childEntity = prop && prop.kind !== core_1.ReferenceKind.SCALAR ? prop.type : entityName;
+        if (prop?.kind !== core_1.ReferenceKind.EMBEDDED) {
+            return this.createNode(metadata, childEntity, payload[key], node, key);
+        }
+        if (payload[key] == null) {
+            const map = Object.keys(prop.embeddedProps).reduce((oo, k) => {
+                oo[prop.embeddedProps[k].name] = null;
+                return oo;
+            }, {});
+            return this.createNode(metadata, entityName, map, node, key);
         }
-        const operator = Object.keys(payload[item]).some(f => core_1.Utils.isOperator(f));
+        // array operators can be used on embedded properties
+        const allowedOperators = ['$contains', '$contained', '$overlap'];
+        const operator = Object.keys(payload[key]).some(f => core_1.Utils.isOperator(f) && !allowedOperators.includes(f));
         if (operator) {
             throw core_1.ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
         }
-        const map = Object.keys(payload[item]).reduce((oo, k) => {
-            if (!prop.embeddedProps[k]) {
+        const map = Object.keys(payload[key]).reduce((oo, k) => {
+            if (!prop.embeddedProps[k] && !allowedOperators.includes(k)) {
                 throw core_1.ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
             }
-            oo[prop.embeddedProps[k].name] = payload[item][k];
+            if (prop.embeddedProps[k]) {
+                oo[prop.embeddedProps[k].name] = payload[key][k];
+            }
+            else if (typeof payload[key][k] === 'object') {
+                oo[k] = JSON.stringify(payload[key][k]);
+            }
+            else {
+                oo[k] = payload[key][k];
+            }
             return oo;
         }, {});
-        return this.createNode(metadata, entityName, map, node, item);
+        return this.createNode(metadata, entityName, map, node, key);
     }
 }
 exports.CriteriaNodeFactory = CriteriaNodeFactory;

package/query/ObjectCriteriaNode.d.ts

@@ -1,11 +1,12 @@
 import { CriteriaNode } from './CriteriaNode';
-import type { IQueryBuilder } from '../typings';
+import type { IQueryBuilder, ICriteriaNodeProcessOptions } from '../typings';
 /**
  * @internal
  */
-export declare class ObjectCriteriaNode extends CriteriaNode {
-    process<T>(qb: IQueryBuilder<T>, alias?: string): any;
-    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string): boolean;
+export declare class ObjectCriteriaNode<T extends object> extends CriteriaNode<T> {
+    process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    unwrap(): any;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string): boolean;
     shouldInline(payload: any): boolean;
     private inlineChildPayload;
     private shouldAutoJoin;