@mikro-orm/sql 7.2.0-dev.2 → 7.2.0-dev.20

package/dialects/sqlite/SqlitePlatform.d.ts

@@ -6,6 +6,8 @@ import { SqliteExceptionConverter } from './SqliteExceptionConverter.js';
 export declare class SqlitePlatform extends AbstractSqlPlatform {
     protected readonly schemaHelper: SqliteSchemaHelper;
     protected readonly exceptionConverter: SqliteExceptionConverter;
+    /** sqlite treats null as the lowest value when no placement is requested. */
+    sortsNullsLowest(): boolean;
     /** @internal */
     createNativeQueryBuilder(): SqliteNativeQueryBuilder;
     usesDefaultKeyword(): boolean;

package/dialects/sqlite/SqlitePlatform.js

@@ -5,6 +5,10 @@ import { SqliteExceptionConverter } from './SqliteExceptionConverter.js';
 export class SqlitePlatform extends AbstractSqlPlatform {
     schemaHelper = new SqliteSchemaHelper(this);
     exceptionConverter = new SqliteExceptionConverter();
+    /** sqlite treats null as the lowest value when no placement is requested. */
+    sortsNullsLowest() {
+        return true;
+    }
     /** @internal */
     createNativeQueryBuilder() {
         return new SqliteNativeQueryBuilder(this);

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -489,7 +489,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
      * Foreign key references can only point to tables in the same database.
      */
     getReferencedTableName(referencedTableName, schema) {
-        const [schemaName, tableName] = this.splitTableName(referencedTableName);
+        const [, tableName] = this.splitTableName(referencedTableName);
         // Strip any schema prefix - SQLite REFERENCES clause doesn't support it
         return tableName;
     }
@@ -561,7 +561,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
         for (const event of trigger.events) {
             const name = trigger.events.length > 1 ? `${trigger.name}_${event}` : trigger.name;
             const when = trigger.when ? `\n  when ${trigger.when}` : '';
-            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ${forEach}${when} begin ${trigger.body}; end`);
+            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ${forEach}${when} begin ${this.normalizeTriggerBody(trigger.body)} end`);
         }
         return ret.join(';\n');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.2.0-dev.2",
+  "version": "7.2.0-dev.20",
   "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.",
   "keywords": [
     "data-mapper",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "kysely": "0.29.4"
+    "kysely": "0.29.5"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.1.7"
+    "@mikro-orm/core": "^7.1.15"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.2.0-dev.2"
+    "@mikro-orm/core": "7.2.0-dev.20"
   },
   "engines": {
     "node": ">= 22.17.0"

package/plugin/transformer.d.ts

@@ -1,5 +1,5 @@
 import { type EntityMetadata, type EntityProperty, type Type } from '@mikro-orm/core';
-import { type CommonTableExpressionNameNode, type DeleteQueryNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type OperationNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, IdentifierNode, OperationNodeTransformer, SelectionNode, TableNode, ValueNode } from 'kysely';
+import { type BinaryOperationNode, type CommonTableExpressionNameNode, type DeleteQueryNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type OperationNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, IdentifierNode, OperationNodeTransformer, SelectionNode, TableNode, ValueNode } from 'kysely';
 import type { MikroKyselyPluginOptions } from './index.js';
 import type { SqlEntityManager } from '../SqlEntityManager.js';
 export declare class MikroTransformer extends OperationNodeTransformer {
@@ -28,6 +28,12 @@ export declare class MikroTransformer extends OperationNodeTransformer {
     processOnUpdateHooks(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
     processInsertValues(node: InsertQueryNode, meta: EntityMetadata): InsertQueryNode;
     processUpdateValues(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
+    transformBinaryOperation(node: BinaryOperationNode, queryId: QueryId): BinaryOperationNode;
+    /** Resolve the entity property a comparison's left operand refers to, so its value operand can be converted. */
+    resolveOperandProperty(operand: OperationNode): {
+        prop: EntityProperty;
+        fieldName: string;
+    } | undefined;
     processInputValueNode(prop: EntityProperty | undefined, fieldName: string | undefined, valueNode: ValueNode): OperationNode;
     expandSelections(selections: readonly SelectionNode[]): readonly SelectionNode[];
     expandSelection(sel: SelectionNode): SelectionNode[] | null;

package/plugin/transformer.js

@@ -455,6 +455,60 @@ export class MikroTransformer extends OperationNodeTransformer {
             updates,
         };
     }
+    transformBinaryOperation(node, queryId) {
+        const transformed = super.transformBinaryOperation(node, queryId);
+        if (!this.#options.convertValues) {
+            return transformed;
+        }
+        const resolved = this.resolveOperandProperty(transformed.leftOperand);
+        if (!resolved) {
+            return transformed;
+        }
+        const { prop, fieldName } = resolved;
+        const right = transformed.rightOperand;
+        if (ValueNode.is(right)) {
+            const converted = this.processInputValueNode(prop, fieldName, right);
+            return converted === right ? transformed : { ...transformed, rightOperand: converted };
+        }
+        if (PrimitiveValueListNode.is(right)) {
+            // upgrade to ValueListNode when the type needs SQL-side wrapping, since
+            // PrimitiveValueListNode can only hold primitives
+            if (prop.hasConvertToDatabaseValueSQL) {
+                const values = right.values.map(value => this.processInputValueNode(prop, fieldName, ValueNode.create(value)));
+                return { ...transformed, rightOperand: ValueListNode.create(values) };
+            }
+            const values = right.values.map(value => this.prepareInputValue(prop, value, true));
+            return values.every((value, idx) => value === right.values[idx])
+                ? transformed
+                : { ...transformed, rightOperand: PrimitiveValueListNode.create(values) };
+        }
+        if (ValueListNode.is(right)) {
+            let changed = false;
+            const values = right.values.map(valueNode => {
+                if (!ValueNode.is(valueNode)) {
+                    return valueNode;
+                }
+                const converted = this.processInputValueNode(prop, fieldName, valueNode);
+                if (converted !== valueNode) {
+                    changed = true;
+                }
+                return converted;
+            });
+            return changed ? { ...transformed, rightOperand: ValueListNode.create(values) } : transformed;
+        }
+        return transformed;
+    }
+    /** Resolve the entity property a comparison's left operand refers to, so its value operand can be converted. */
+    resolveOperandProperty(operand) {
+        if (!ReferenceNode.is(operand) || !ColumnNode.is(operand.column)) {
+            return undefined;
+        }
+        const tableName = operand.table ? this.getTableName(operand.table) : undefined;
+        const meta = this.findOwnerMeta(tableName);
+        const fieldName = this.normalizeColumnName(operand.column.column);
+        const prop = this.findProperty(meta, fieldName);
+        return prop ? { prop, fieldName } : undefined;
+    }
     processInputValueNode(prop, fieldName, valueNode) {
         const converted = this.prepareInputValue(prop, valueNode.value, true);
         const newValueNode = converted === valueNode.value
@@ -543,8 +597,13 @@ export class MikroTransformer extends OperationNodeTransformer {
         if (name) {
             return this.lookupInContextStack(name) ?? this.#subqueryAliasMap.get(name) ?? this.findEntityMetadata(name);
         }
+        // the stack can be empty when transforming a raw root node with embedded expressions
+        const context = this.#contextStack[this.#contextStack.length - 1];
+        if (!context) {
+            return undefined;
+        }
         let single;
-        for (const meta of this.#contextStack[this.#contextStack.length - 1].values()) {
+        for (const meta of context.values()) {
             if (!meta) {
                 continue;
             }

package/query/CriteriaNodeFactory.js

@@ -57,6 +57,10 @@ export class CriteriaNodeFactory {
         if (isNotEmbedded && prop?.customType instanceof JsonType) {
             return this.createScalarNode(metadata, childEntity, val, node, key, validate);
         }
+        // operator payloads under an unresolvable alias-prefixed key (e.g. `a.meta`) are opaque values, not entity criteria
+        if (!prop && !rawField && Utils.isOperator(key, false) && String(node.key).includes('.')) {
+            return this.createScalarNode(metadata, entityName, val, node, key, validate);
+        }
         if (prop?.kind === ReferenceKind.SCALAR && val != null && Object.keys(val).some(f => f in GroupOperator)) {
             throw ValidationError.cannotUseGroupOperatorsInsideScalars(entityName, prop.name, payload);
         }

package/query/NativeQueryBuilder.js

@@ -308,7 +308,7 @@ export class NativeQueryBuilder {
             const fields = this.options.groupBy.map(field => this.quote(field));
             this.parts.push(`group by ${fields.join(', ')}`);
         }
-        if (this.options.having) {
+        if (this.options.having?.sql.trim()) {
             this.parts.push(`having ${this.options.having.sql}`);
             this.params.push(...this.options.having.params);
         }

package/query/ObjectCriteriaNode.d.ts

@@ -13,6 +13,7 @@ export declare class ObjectCriteriaNode<T extends object> extends CriteriaNode<T
     private inlineArrayChildPayload;
     private inlineChildPayload;
     private inlineCondition;
+    private isCollectionOperator;
     private shouldAutoJoin;
     private autoJoin;
     private isPrefixed;

package/query/ObjectCriteriaNode.js

@@ -1,7 +1,7 @@
 import { ALIAS_REPLACEMENT, GroupOperator, QueryFlag, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
 import { CriteriaNode } from './CriteriaNode.js';
 import { JoinType, QueryType } from './enums.js';
-const COLLECTION_OPERATORS = ['$some', '$none', '$every', '$size'];
+const COLLECTION_OPERATORS = ['$some', '$none', '$every', '$size', '$all'];
 /**
  * @internal
  */
@@ -17,7 +17,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
             alias = nestedAlias;
         }
         if (this.shouldAutoJoin(qb, nestedAlias)) {
-            if (keys.some(k => COLLECTION_OPERATORS.includes(k))) {
+            if (keys.some(k => this.isCollectionOperator(k))) {
                 if (![ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(this.prop.kind)) {
                     // ignore collection operators when used on a non-relational property - this can happen when they get into
                     // populateWhere via `infer` on m:n properties with select-in strategy
@@ -34,11 +34,24 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 const primaryKeys = parentMeta.primaryKeys.map(pk => {
                     return [QueryType.SELECT, QueryType.COUNT].includes(qb.type) ? `${knownKey ? alias : ownerAlias}.${pk}` : pk;
                 });
+                const conditions = [];
+                let matchNothing = false;
                 for (const key of keys) {
                     if (typeof key !== 'string' || !COLLECTION_OPERATORS.includes(key)) {
                         throw new Error('Mixing collection operators with other filters is not allowed.');
                     }
                     const payload = this.payload[key].unwrap();
+                    // `$all` requires every listed item to be present, which is an intersection of `$some` conditions
+                    if (key === '$all') {
+                        // an empty `$all` matches nothing, same as in mongo
+                        matchNothing ||= payload.length === 0;
+                        conditions.push(...payload.map(item => ['$some', item]));
+                    }
+                    else {
+                        conditions.push([key, payload]);
+                    }
+                }
+                for (const [key, payload] of conditions) {
                     // entities with a fixed schema must resolve the `from` table's own schema in the subquery,
                     // otherwise a nested operator inherits the root entity's schema (GH #7894); for wildcard or
                     // schema-less entities the schema is resolved dynamically and needs to be carried over
@@ -70,6 +83,9 @@ export class ObjectCriteriaNode extends CriteriaNode {
                         [Utils.getPrimaryKeyHash(primaryKeys)]: { [op]: sub.getNativeQuery().toRaw() },
                     });
                 }
+                if (matchNothing) {
+                    $and.push({ [Utils.getPrimaryKeyHash(primaryKeys)]: { $in: [] } });
+                }
                 if ($and.length === 1) {
                     return $and[0];
                 }
@@ -113,7 +129,8 @@ export class ObjectCriteriaNode extends CriteriaNode {
             }
             else if (isRawField) {
                 const rawField = RawQueryFragment.getKnownFragment(field);
-                o[raw(rawField.sql.replaceAll(ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
+                qb.ensureTPTJoins();
+                o[raw(qb.helper.replaceAliases(rawField.sql, alias), rawField.params)] = payload;
             }
             else if (!childNode.validate && !childNode.prop && !field.includes('.') && !operator) {
                 // wrap unknown fields in raw() to prevent alias prefixing (e.g. raw SQL aliases in HAVING)
@@ -153,7 +170,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
             alias = nestedAlias;
         }
         if (this.shouldAutoJoin(qb, nestedAlias)) {
-            return !keys.some(k => COLLECTION_OPERATORS.includes(k));
+            return !keys.some(k => this.isCollectionOperator(k));
         }
         return keys.some(field => {
             const childNode = this.payload[field];
@@ -237,6 +254,14 @@ export class ObjectCriteriaNode extends CriteriaNode {
         delete o[key];
         o.$and = $and;
     }
+    isCollectionOperator(key) {
+        if (typeof key !== 'string' || !COLLECTION_OPERATORS.includes(key)) {
+            return false;
+        }
+        // `$all` is primarily a mongo array operator, in SQL it is supported only on collections
+        return (key !== '$all' ||
+            (!!this.prop && [ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(this.prop.kind)));
+    }
     shouldAutoJoin(qb, nestedAlias) {
         if (!this.prop || !this.parent) {
             return false;
@@ -245,7 +270,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
         if (keys.every(k => typeof k === 'string' && k.includes('.') && k.startsWith(`${qb.alias}.`))) {
             return false;
         }
-        if (keys.some(k => COLLECTION_OPERATORS.includes(k))) {
+        if (keys.some(k => this.isCollectionOperator(k))) {
             return true;
         }
         const meta = this.metadata.find(this.entityName);

package/query/QueryBuilder.d.ts

@@ -152,11 +152,10 @@ type ContextFilterKeys<Context> = {
 type RawFilterKeys<RawAliases extends string> = {
     [K in RawAliases]?: AliasedFilterValue;
 };
-type NestedFilterCondition<Entity, RootAlias extends string, Context, RawAliases extends string> = ObjectQuery<Entity> & (IsNever<RootAlias> extends true ? {} : string extends RootAlias ? {} : RootAliasFilterKeys<RootAlias, Entity>) & ([Context] extends [never] ? {} : ContextFilterKeys<Context>) & (IsNever<RawAliases> extends true ? {} : string extends RawAliases ? {} : RawFilterKeys<RawAliases>);
 type GroupOperators<RootAlias extends string, Context, Entity, RawAliases extends string> = {
-    $and?: NestedFilterCondition<Entity, RootAlias, Context, RawAliases>[];
-    $or?: NestedFilterCondition<Entity, RootAlias, Context, RawAliases>[];
-    $not?: NestedFilterCondition<Entity, RootAlias, Context, RawAliases>;
+    $and?: QBFilterQuery<Entity, RootAlias, Context, RawAliases>[];
+    $or?: QBFilterQuery<Entity, RootAlias, Context, RawAliases>[];
+    $not?: QBFilterQuery<Entity, RootAlias, Context, RawAliases>;
 };
 export type AliasedFilterCondition<RootAlias extends string, Context, Entity, RawAliases extends string = never> = (IsNever<RootAlias> extends true ? {} : string extends RootAlias ? {} : RootAliasFilterKeys<RootAlias, Entity>) & ([Context] extends [never] ? {} : ContextFilterKeys<Context>) & (IsNever<RawAliases> extends true ? {} : string extends RawAliases ? {} : RawFilterKeys<RawAliases>) & GroupOperators<RootAlias, Context, Entity, RawAliases>;
 export type QBFilterQuery<Entity, RootAlias extends string = never, Context = never, RawAliases extends string = never> = FilterObject<Entity> & AliasedFilterCondition<RootAlias, Context, Entity, RawAliases>;
@@ -440,7 +439,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      */
     join<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field, alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, type?: JoinType, path?: string, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field> & {}, ModifyContext<Entity, Context, Field, Alias>, RawAliases, Fields, CTEs>;
     /**
-     * Adds a JOIN clause to the query for a subquery.
+     * Adds a JOIN clause to the query for a subquery. Use `sql.ref('...')` to join a table or CTE by name.
      */
     join<Alias extends string>(field: RawQueryFragment | QueryBuilder<any>, alias: Alias, cond?: RawJoinCondition, type?: JoinType, path?: string, schema?: string): SelectQueryBuilder<Entity, RootAlias, Hint, ModifyContext<Entity, Context, string, Alias>, RawAliases, Fields, CTEs>;
     /**
@@ -448,7 +447,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      */
     innerJoin<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field, alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field> & {}, ModifyContext<Entity, Context, Field, Alias>, RawAliases, Fields, CTEs>;
     /**
-     * Adds an INNER JOIN clause to the query for a subquery.
+     * Adds an INNER JOIN clause to the query for a subquery. Use `sql.ref('...')` to join a table or CTE by name.
      */
     innerJoin<Alias extends string>(field: RawQueryFragment | QueryBuilder<any>, alias: Alias, cond?: RawJoinCondition, schema?: string): SelectQueryBuilder<Entity, RootAlias, Hint, ModifyContext<Entity, Context, string, Alias>, RawAliases, Fields, CTEs>;
     innerJoinLateral<Alias extends string>(field: RawQueryFragment | QueryBuilder<any>, alias: Alias, cond?: RawJoinCondition, schema?: string): SelectQueryBuilder<Entity, RootAlias, Hint, ModifyContext<Entity, Context, string, Alias>, RawAliases, Fields, CTEs>;
@@ -457,7 +456,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      */
     leftJoin<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field, alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field> & {}, ModifyContext<Entity, Context, Field, Alias>, RawAliases, Fields, CTEs>;
     /**
-     * Adds a LEFT JOIN clause to the query for a subquery.
+     * Adds a LEFT JOIN clause to the query for a subquery. Use `sql.ref('...')` to join a table or CTE by name.
      */
     leftJoin<Alias extends string>(field: RawQueryFragment | QueryBuilder<any>, alias: Alias, cond?: RawJoinCondition, schema?: string): SelectQueryBuilder<Entity, RootAlias, Hint, ModifyContext<Entity, Context, string, Alias>, RawAliases, Fields, CTEs>;
     leftJoinLateral<Alias extends string>(field: RawQueryFragment | QueryBuilder<any>, alias: Alias, cond?: RawJoinCondition, schema?: string): SelectQueryBuilder<Entity, RootAlias, Hint, ModifyContext<Entity, Context, string, Alias>, RawAliases, Fields, CTEs>;
@@ -506,6 +505,17 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * @internal
      */
     applyJoinedFilters(em: EntityManager, filterOptions: FilterOptions | undefined): Promise<void>;
+    /**
+     * The `on` clause of `condJoin` — its explicit join condition or a filter condition merged into
+     * it — can reference the alias of any join in its subtree, both auto-joins created while
+     * processing the condition and pre-existing joined paths, all of which render after `condJoin`
+     * and would be forward alias references (issues #7681, #8090, #8099). When that happens, fold the
+     * subtree into `condJoin`, so it renders as a single parenthesized join group and every alias
+     * shares the scope of the outer `on` clause.
+     */
+    private nestReferencedJoins;
+    private getJoinSubtree;
+    private condReferencesAlias;
     withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
     /**
      * Adds a WHERE clause to the query using an object condition.
@@ -772,6 +782,8 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * @internal
      */
     getJoinForPath(path: string, options?: ICriteriaNodeProcessOptions): JoinOptions | undefined;
+    /** Branch-insensitive path matching still must not cross branches — segments with different explicit branch markers (e.g. `Mobile[0]` vs `Mobile[1]`) belong to sibling joins. */
+    private branchesConflict;
     /**
      * @internal
      */
@@ -938,6 +950,13 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      */
     addPropertyJoin(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, path: string, schema?: string): string;
     private joinReference;
+    /**
+     * Walks the TPT inheritance chain of `leafMeta` and INNER JOINs each parent table.
+     * Registers the parent aliases in `state.tptAlias` so column resolution finds them
+     * when conditions reference parent-table columns.
+     * @internal
+     */
+    addTPTParentJoins(leafMeta: EntityMetadata, leafAlias: string, basePath: string): void;
     protected prepareFields<T>(fields: InternalField<T>[], type?: 'where' | 'groupBy' | 'sub-query', schema?: string): (string | RawQueryFragment)[];
     /**
      * Resolves nested paths like `a.books.title` to their actual field references.
@@ -984,6 +1003,20 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     processPopulateHint(): void;
     private processPopulateWhere;
     private mergeOnConditions;
+    /**
+     * `$or` branches can be moved to a join's `on` clause only when they all target that same join
+     * and stay flat — a partial `$or` in the `on` clause would drop rows matching a sibling branch,
+     * and nested operators cannot be preserved inside a distributed disjunction, as `mergeOnConditions`
+     * would flatten them into `and` conjuncts.
+     */
+    private canDistributeOrBranches;
+    private getOrBranchAliases;
+    /**
+     * An entity filter's `$or` that cannot be distributed is applied intact to the `on` clause of the
+     * outermost join common to all targeted joins, nesting the targeted joins under it so the clause
+     * can reference their aliases.
+     */
+    private mergeFilterOrCondition;
     /**
      * When adding an inner join on a left joined relation, we need to nest them,
      * otherwise the inner join could discard rows of the root table.