@yandjin-mikro-orm/knex 6.1.4-rc-sti-changes-1

package/index.mjs

@@ -0,0 +1,215 @@
+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;
+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 AfterUpsert = mod.AfterUpsert;
+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 BeforeUpsert = mod.BeforeUpsert;
+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 Config = mod.Config;
+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 CursorError = mod.CursorError;
+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 DataloaderType = mod.DataloaderType;
+export const DataloaderUtils = mod.DataloaderUtils;
+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 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;
+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 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 IntervalType = mod.IntervalType;
+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;
+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 RawQueryFragment = mod.RawQueryFragment;
+export const ReadOnlyException = mod.ReadOnlyException;
+export const Ref = mod.Ref;
+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 ScalarReference = mod.ScalarReference;
+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 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 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 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 createSqlFunction = mod.createSqlFunction;
+export const defineConfig = mod.defineConfig;
+export const equals = mod.equals;
+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

@@ -0,0 +1,71 @@
+{
+  "name": "@yandjin-mikro-orm/knex",
+  "version": "6.1.4-rc-sti-changes-1",
+  "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",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.mjs"
+      },
+      "require": "./index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "keywords": [
+    "orm",
+    "mongo",
+    "mongodb",
+    "mysql",
+    "mariadb",
+    "postgresql",
+    "sqlite",
+    "sqlite3",
+    "ts",
+    "typescript",
+    "js",
+    "javascript",
+    "entity",
+    "ddd",
+    "mikro-orm",
+    "unit-of-work",
+    "data-mapper",
+    "identity-map"
+  ],
+  "author": "Martin Adámek",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mikro-orm/mikro-orm/issues"
+  },
+  "homepage": "https://mikro-orm.io",
+  "engines": {
+    "node": ">= 18.12.0"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn compile && yarn copy && yarn run -T gen-esm-wrapper index.js index.mjs",
+    "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.2.0",
+    "knex": "3.1.0",
+    "sqlstring": "2.3.3"
+  },
+  "devDependencies": {
+    "@yandjin-mikro-orm/core": "^6.1.4-rc-sti-changes-1"
+  },
+  "peerDependencies": {
+    "@yandjin-mikro-orm/core": "^6.0.0"
+  }
+}

package/query/ArrayCriteriaNode.d.ts

@@ -0,0 +1,10 @@
+import { CriteriaNode } from './CriteriaNode';
+import type { IQueryBuilder, ICriteriaNodeProcessOptions } from '../typings';
+/**
+ * @internal
+ */
+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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayCriteriaNode = void 0;
+const CriteriaNode_1 = require("./CriteriaNode");
+/**
+ * @internal
+ */
+class ArrayCriteriaNode extends CriteriaNode_1.CriteriaNode {
+    process(qb, options) {
+        return this.payload.map((node) => {
+            return node.process(qb, options);
+        });
+    }
+    unwrap() {
+        return this.payload.map((node) => {
+            return node.unwrap();
+        });
+    }
+    willAutoJoin(qb, alias) {
+        return this.payload.some((node) => {
+            return node.willAutoJoin(qb, alias);
+        });
+    }
+}
+exports.ArrayCriteriaNode = ArrayCriteriaNode;

package/query/CriteriaNode.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import { inspect } from "util";
+import { type EntityKey, type EntityProperty, type MetadataStorage } from "@yandjin-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<T extends object> implements ICriteriaNode<T> {
+    protected readonly metadata: MetadataStorage;
+    readonly entityName: string;
+    readonly parent?: ICriteriaNode<T> | undefined;
+    readonly key?: EntityKey<T> | undefined;
+    payload: any;
+    prop?: EntityProperty<T>;
+    index?: number;
+    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(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;
+    aliased(field: string, alias?: string): string;
+    /** @ignore */
+    [inspect.custom](): string;
+}

package/query/CriteriaNode.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CriteriaNode = void 0;
+const util_1 = require("util");
+const core_1 = require("@yandjin-mikro-orm/core");
+/**
+ * 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
+ */
+class CriteriaNode {
+    metadata;
+    entityName;
+    parent;
+    key;
+    payload;
+    prop;
+    index;
+    constructor(metadata, entityName, parent, key, validate = true) {
+        this.metadata = metadata;
+        this.entityName = entityName;
+        this.parent = parent;
+        this.key = key;
+        const meta = parent && metadata.find(parent.entityName);
+        if (meta && key) {
+            const pks = core_1.Utils.splitPrimaryKeys(key);
+            if (pks.length > 1) {
+                return;
+            }
+            pks.forEach((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 &&
+                    !isProp &&
+                    !k.includes(".") &&
+                    !k.includes("::") &&
+                    !core_1.Utils.isOperator(k) &&
+                    !core_1.RawQueryFragment.isKnownFragment(k)) {
+                    throw new Error(`Trying to query by not existing property ${entityName}.${k}`);
+                }
+            });
+        }
+    }
+    process(qb, options) {
+        return this.payload;
+    }
+    unwrap() {
+        return this.payload;
+    }
+    shouldInline(payload) {
+        return false;
+    }
+    willAutoJoin(qb, alias) {
+        return false;
+    }
+    shouldRename(payload) {
+        const type = this.prop ? this.prop.kind : null;
+        const composite = this.prop?.joinColumns
+            ? this.prop.joinColumns.length > 1
+            : false;
+        const customExpression = core_1.RawQueryFragment.isKnownFragment(this.key);
+        const scalar = payload === null ||
+            core_1.Utils.isPrimaryKey(payload) ||
+            payload instanceof RegExp ||
+            payload instanceof Date ||
+            customExpression;
+        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.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.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
+        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.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)
+        const key = this.key && !["$and", "$or", "$not"].includes(this.key)
+            ? "." + this.key
+            : "";
+        const ret = parentPath + index + key;
+        if (this.isPivotJoin()) {
+            // distinguish pivot table join from target entity join
+            return this.getPivotPath(ret);
+        }
+        return ret;
+    }
+    isPivotJoin() {
+        if (!this.key || !this.prop) {
+            return false;
+        }
+        const customExpression = core_1.RawQueryFragment.isKnownFragment(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.kind === core_1.ReferenceKind.MANY_TO_MANY && (scalar || operator));
+    }
+    getPivotPath(path) {
+        return `${path}[pivot]`;
+    }
+    aliased(field, alias) {
+        return alias ? `${alias}.${field}` : field;
+    }
+    /** @ignore */
+    [util_1.inspect.custom]() {
+        const o = {};
+        ["entityName", "key", "index", "payload"]
+            .filter((k) => this[k] !== undefined)
+            .forEach((k) => (o[k] = this[k]));
+        return `${this.constructor.name} ${(0, util_1.inspect)(o)}`;
+    }
+}
+exports.CriteriaNode = CriteriaNode;

package/query/CriteriaNodeFactory.d.ts

@@ -0,0 +1,12 @@
+import { type Dictionary, type EntityKey, type EntityMetadata, type MetadataStorage } from "@yandjin-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>;
+}

package/query/CriteriaNodeFactory.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CriteriaNodeFactory = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const ObjectCriteriaNode_1 = require("./ObjectCriteriaNode");
+const ArrayCriteriaNode_1 = require("./ArrayCriteriaNode");
+const ScalarCriteriaNode_1 = require("./ScalarCriteriaNode");
+/**
+ * @internal
+ */
+class CriteriaNodeFactory {
+    static createNode(metadata, entityName, payload, parent, key) {
+        const customExpression = core_1.RawQueryFragment.isKnownFragment(key || "");
+        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);
+        }
+        if (core_1.Utils.isPlainObject(payload) && !scalar) {
+            return this.createObjectNode(metadata, entityName, payload, parent, key);
+        }
+        return this.createScalarNode(metadata, entityName, payload, parent, key);
+    }
+    static createScalarNode(metadata, entityName, payload, parent, key) {
+        const node = new ScalarCriteriaNode_1.ScalarCriteriaNode(metadata, entityName, parent, key);
+        node.payload = payload;
+        return node;
+    }
+    static createArrayNode(metadata, entityName, payload, parent, key) {
+        const node = new ArrayCriteriaNode_1.ArrayCriteriaNode(metadata, entityName, parent, key);
+        node.payload = payload.map((item, index) => {
+            const n = this.createNode(metadata, entityName, item, node);
+            // 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);
+        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);
+            return o;
+        }, {});
+        return node;
+    }
+    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);
+        }
+        // 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[key]).reduce((oo, k) => {
+            if (!prop.embeddedProps[k] && !allowedOperators.includes(k)) {
+                throw core_1.ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
+            }
+            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, key);
+    }
+}
+exports.CriteriaNodeFactory = CriteriaNodeFactory;

package/query/ObjectCriteriaNode.d.ts

@@ -0,0 +1,15 @@
+import { CriteriaNode } from "./CriteriaNode";
+import type { ICriteriaNodeProcessOptions, IQueryBuilder } from "../typings";
+/**
+ * @internal
+ */
+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;
+    private autoJoin;
+    private isPrefixed;
+}