@mikro-orm/sql 7.2.0-dev.0 → 7.2.0-dev.1

package/AbstractSqlDriver.d.ts

@@ -168,7 +168,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected extractManyToMany<T>(meta: EntityMetadata<T>, data: EntityDictionary<T>): EntityData<T>;
     protected processManyToMany<T extends object>(meta: EntityMetadata<T>, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
-    protected buildPopulateWhere<T extends object>(meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'populateWhere'>): ObjectQuery<T>;
+    protected buildPopulateWhere<T extends object>(meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'populateWhere' | 'strategy'>): ObjectQuery<T>;
     /**
      * Builds a UNION ALL (or UNION) subquery from `unionWhere` branches and merges it
      * into the main WHERE as `pk IN (branch_1 UNION ALL branch_2 ...)`.

package/AbstractSqlDriver.js

@@ -2124,7 +2124,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (hint.children) {
                 const targetMeta = prop.targetMeta;
                 if (targetMeta) {
-                    const inner = this.buildPopulateWhere(targetMeta, hint.children, {});
+                    // only joined children contribute to the ON conditions, the rest is handled by the entity loader
+                    const children = this.joinedProps(targetMeta, hint.children, options);
+                    const inner = this.buildPopulateWhere(targetMeta, children, { strategy: options.strategy });
                     if (!Utils.isEmpty(inner) || RawQueryFragment.hasObjectFragments(inner)) {
                         where[prop.name] ??= {};
                         Object.assign(where[prop.name], inner);

package/AbstractSqlPlatform.d.ts

@@ -6,6 +6,7 @@ import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 /** Base class for SQL database platforms, providing SQL generation and quoting utilities. */
 export declare abstract class AbstractSqlPlatform extends Platform {
     #private;
+    private static readonly ORDER_BY_DIRECTIONS;
     protected readonly schemaHelper?: SchemaHelper;
     usesPivotTable(): boolean;
     indexForeignKeys(): boolean;
@@ -46,6 +47,12 @@ export declare abstract class AbstractSqlPlatform extends Platform {
      * @internal
      */
     getOrderByExpression(column: string, direction: string, collation?: string): string[];
+    /**
+     * `toLowerCase()` folds every `QueryOrder` enum member (and the normalized `QueryOrderNumeric`
+     * values) onto the six allow-listed directions, so only unknown values are rejected.
+     * @internal
+     */
+    validateOrderByDirection(direction: string): string;
     /**
      * Quotes a collation name for use in COLLATE clauses.
      * @internal

package/AbstractSqlPlatform.js

@@ -5,6 +5,14 @@ import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 /** Base class for SQL database platforms, providing SQL generation and quoting utilities. */
 export class AbstractSqlPlatform extends Platform {
     static #JSON_PROPERTY_NAME_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    static ORDER_BY_DIRECTIONS = new Set([
+        'asc',
+        'desc',
+        'asc nulls first',
+        'asc nulls last',
+        'desc nulls first',
+        'desc nulls last',
+    ]);
     schemaHelper;
     usesPivotTable() {
         return true;
@@ -115,10 +123,23 @@ export class AbstractSqlPlatform extends Platform {
      * @internal
      */
     getOrderByExpression(column, direction, collation) {
+        const dir = this.validateOrderByDirection(direction);
         if (collation) {
-            return [`${column} collate ${this.quoteCollation(collation)} ${direction.toLowerCase()}`];
+            return [`${column} collate ${this.quoteCollation(collation)} ${dir}`];
         }
-        return [`${column} ${direction.toLowerCase()}`];
+        return [`${column} ${dir}`];
+    }
+    /**
+     * `toLowerCase()` folds every `QueryOrder` enum member (and the normalized `QueryOrderNumeric`
+     * values) onto the six allow-listed directions, so only unknown values are rejected.
+     * @internal
+     */
+    validateOrderByDirection(direction) {
+        const dir = ('' + direction).toLowerCase().trim();
+        if (!AbstractSqlPlatform.ORDER_BY_DIRECTIONS.has(dir)) {
+            throw new Error(`Invalid order direction: '${direction}'`);
+        }
+        return dir;
     }
     /**
      * Quotes a collation name for use in COLLATE clauses.

package/dialects/mysql/BaseMySqlPlatform.js

@@ -114,7 +114,7 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
     }
     getOrderByExpression(column, direction, collation) {
         const ret = [];
-        const dir = direction.toLowerCase();
+        const dir = this.validateOrderByDirection(direction);
         const col = collation ? `${column} collate ${this.quoteCollation(collation)}` : column;
         if (dir in this.ORDER_BY_NULLS_TRANSLATE) {
             ret.push(`${col} ${this.ORDER_BY_NULLS_TRANSLATE[dir]}`);

package/dialects/mysql/MySqlSchemaHelper.js

@@ -54,10 +54,10 @@ export class MySqlSchemaHelper extends SchemaHelper {
         return sql;
     }
     getListTablesSQL() {
-        return `select table_name as table_name, nullif(table_schema, schema()) as schema_name, table_comment as table_comment, table_collation as table_collation from information_schema.tables where table_type = 'BASE TABLE' and table_schema = schema()`;
+        return `select table_name as table_name, nullif(table_schema, schema()) as schema_name, table_comment as table_comment, table_collation as table_collation from information_schema.tables where table_type = 'BASE TABLE' and table_schema = schema() order by table_name`;
     }
     getListViewsSQL() {
-        return `select table_name as view_name, nullif(table_schema, schema()) as schema_name, view_definition from information_schema.views where table_schema = schema()`;
+        return `select table_name as view_name, nullif(table_schema, schema()) as schema_name, view_definition from information_schema.views where table_schema = schema() order by table_name`;
     }
     async loadViews(schema, connection, schemaName, ctx) {
         const views = await connection.execute(this.getListViewsSQL(), [], 'all', ctx);
@@ -372,6 +372,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
       from information_schema.routines r
       where r.routine_schema = database()
         and r.routine_type in ('PROCEDURE', 'FUNCTION')
+      order by r.routine_name
     `;
         const [rows, params] = await Promise.all([
             connection.execute(sql),

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -579,6 +579,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         )
         -- exclude trigger-helper functions; they're managed alongside their owning trigger.
         and p.prorettype <> 'trigger'::regtype
+      order by n.nspname, p.proname
     `;
         const rows = await connection.execute(sql);
         return rows.map(row => {
@@ -775,7 +776,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         left join pg_enum e on t.oid = e.enumtypid
         join pg_catalog.pg_namespace n on n.oid = t.typnamespace
         where t.typtype = 'e' and n.nspname in (${Array(uniqueSchemas.length).fill('?').join(', ')})
-        group by t.typname, n.nspname`, uniqueSchemas, 'all', ctx);
+        group by t.typname, n.nspname
+        order by n.nspname, t.typname`, uniqueSchemas, 'all', ctx);
         return res.reduce((o, row) => {
             let name = row.enum_name;
             if (row.schema_name && row.schema_name !== this.platform.getDefaultSchemaName()) {

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -52,7 +52,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
         for (const dbName of targetSchemas) {
             const prefix = this.getSchemaPrefix(dbName);
             const tables = await connection.execute(`select name from ${prefix}sqlite_master where type = 'table' ` +
-                `and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys'`, [], 'all', ctx);
+                `and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' order by name`, [], 'all', ctx);
             for (const t of tables) {
                 allTables.push({ table_name: t.name, schema_name: dbName });
             }

package/package.json

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

package/query/QueryBuilder.d.ts

@@ -52,6 +52,12 @@ type IsNever<T, True = true, False = false> = [T] extends [never] ? True : False
 type GetAlias<T extends string> = T extends `${infer A}.${string}` ? A : never;
 type GetPropName<T extends string> = T extends `${string}.${infer P}` ? P : T;
 type AppendToHint<Parent extends string, Child extends string> = `${Parent}.${Child}`;
+/**
+ * Extracts the entity type from a query builder via its main alias. Matching against
+ * `QueryBuilder<infer T>` is unreliable once another generic, such as selected fields,
+ * differs from its default.
+ */
+type QueryBuilderEntity<Q extends QueryBuilder<any>> = Q['mainAlias'] extends Alias<infer T extends object> ? T : object;
 /**
  * Context tuple format: [Path, Alias, Type, Select]
  * - Path: The relation path from root entity (e.g., 'books', 'books.author')
@@ -85,7 +91,7 @@ type ContextRelationKeys<Context> = Context[keyof Context] extends infer Join ?
 export type QBField<Entity, RootAlias extends string, Context> = EntityRelations<Entity> | `${RootAlias}.${EntityRelations<Entity>}` | ([Context] extends [never] ? never : ContextRelationKeys<Context>);
 type ContextFieldKeys<Context> = Context[keyof Context] extends infer Join ? Join extends any ? Join extends [string, infer Alias, infer Type, any] ? `${Alias & string}.${keyof Type & string}` : never : never : never;
 type WithAlias<T extends string> = T | `${T} as ${string}`;
-export type Field<Entity, RootAlias extends string = never, Context = never> = WithAlias<EntityKey<Entity>> | (IsNever<RootAlias> extends true ? never : WithAlias<`${RootAlias}.${EntityKey<Entity>}`> | `${RootAlias}.*`) | ([Context] extends [never] ? never : WithAlias<ContextFieldKeys<Context>> | `${AliasNames<Context>}.*`) | '*' | QueryBuilder<any> | NativeQueryBuilder | RawQueryFragment<any> | (RawQueryFragment & symbol);
+export type Field<Entity, RootAlias extends string = never, Context = never> = WithAlias<EntityKey<Entity>> | (IsNever<RootAlias> extends true ? never : WithAlias<`${RootAlias}.${EntityKey<Entity>}`> | `${RootAlias}.*`) | ([Context] extends [never] ? never : WithAlias<ContextFieldKeys<Context>> | `${AliasNames<Context>}.*`) | '*' | AnyQueryBuilder | NativeQueryBuilder | RawQueryFragment<any> | (RawQueryFragment & symbol);
 type RootAliasOrderKeys<RootAlias extends string, Entity> = {
     [K in `${RootAlias}.${EntityKey<Entity>}`]?: QueryOrderKeysFlat;
 };
@@ -432,29 +438,29 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      *   .where({ 'a.name': 'John' });
      * ```
      */
-    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, '*', CTEs>;
+    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.
      */
-    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, '*', CTEs>;
+    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>;
     /**
      * Adds an INNER JOIN clause to the query for an entity relation.
      */
-    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, '*', CTEs>;
+    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.
      */
-    innerJoin<Alias extends string>(field: RawQueryFragment | QueryBuilder<any>, alias: Alias, cond?: RawJoinCondition, schema?: string): SelectQueryBuilder<Entity, RootAlias, Hint, ModifyContext<Entity, Context, string, Alias>, RawAliases, '*', 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, '*', CTEs>;
+    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>;
     /**
      * Adds a LEFT JOIN clause to the query for an entity relation.
      */
-    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, '*', CTEs>;
+    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.
      */
-    leftJoin<Alias extends string>(field: RawQueryFragment | QueryBuilder<any>, alias: Alias, cond?: RawJoinCondition, schema?: string): SelectQueryBuilder<Entity, RootAlias, Hint, ModifyContext<Entity, Context, string, Alias>, RawAliases, '*', 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, '*', CTEs>;
+    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>;
     /**
      * Adds a JOIN clause and automatically selects the joined entity's fields.
      * This is useful for eager loading related entities.
@@ -723,7 +729,9 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * Specifies FROM which entity's table select/update/delete will be executed, removing all previously set FROM-s.
      * Allows setting a main string alias of the selection data.
      */
-    from<Entity extends object>(target: QueryBuilder<Entity>, aliasName?: string): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields, CTEs>;
+    from<Entity extends object>(target: Subquery & {
+        readonly mainAlias: Alias<Entity>;
+    }, aliasName?: string): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields, CTEs>;
     /**
      * Specifies FROM which entity's table select/update/delete will be executed, removing all previously set FROM-s.
      * Allows setting a main string alias of the selection data.
@@ -733,7 +741,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * Specifies a CTE name as the FROM source, with full type safety.
      * The entity type is inferred from the CTE definition passed to `.with()`.
      */
-    from<Name extends string & keyof CTEs, Alias extends string = Name>(target: Name, aliasName?: Alias): SelectQueryBuilder<CTEs[Name], Alias, never, never, never, '*', CTEs>;
+    from<Name extends string & keyof CTEs, Alias extends string = Name>(target: Name, aliasName?: Alias): SelectQueryBuilder<CTEs[Name], Alias, never, never, never, Fields, CTEs>;
     getNativeQuery(processVirtualEntity?: boolean): NativeQueryBuilder;
     protected processReturningStatement(qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
     /**
@@ -849,7 +857,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * const results = await em.find(Employee, { id: { $in: subquery } });
      * ```
      */
-    unionAll(...others: (QueryBuilder<any> | NativeQueryBuilder)[]): QueryBuilder<Entity>;
+    unionAll(...others: (QueryBuilder<any> | NativeQueryBuilder)[]): QueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields, CTEs>;
     /**
      * Combines the current query with one or more other queries using `UNION` (with deduplication).
      * All queries must select the same columns. Returns a `QueryBuilder` that
@@ -864,7 +872,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * const results = await em.find(Employee, { id: { $in: subquery } });
      * ```
      */
-    union(...others: (QueryBuilder<any> | NativeQueryBuilder)[]): QueryBuilder<Entity>;
+    union(...others: (QueryBuilder<any> | NativeQueryBuilder)[]): QueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields, CTEs>;
     private buildUnionQuery;
     /**
      * Adds a Common Table Expression (CTE) to the query.
@@ -879,7 +887,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      *   .from('recent_books', 'rb'); // entity type inferred as Book
      * ```
      */
-    with<Name extends string, Q extends QueryBuilder<any>>(name: Name, query: Q, options?: CteOptions): QueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields, CTEs & Record<Name, Q extends QueryBuilder<infer T> ? T : object>>;
+    with<Name extends string, Q extends QueryBuilder<any>>(name: Name, query: Q, options?: CteOptions): QueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields, CTEs & Record<Name, QueryBuilderEntity<Q>>>;
     /**
      * Adds a Common Table Expression (CTE) to the query using a `NativeQueryBuilder` or raw SQL fragment.
      * The CTE name is tracked but without entity type inference — use `from()` to query from it.
@@ -900,7 +908,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      *   .from('category_tree', 'ct'); // entity type inferred as Category
      * ```
      */
-    withRecursive<Name extends string, Q extends QueryBuilder<any>>(name: Name, query: Q, options?: CteOptions): QueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields, CTEs & Record<Name, Q extends QueryBuilder<infer T> ? T : object>>;
+    withRecursive<Name extends string, Q extends QueryBuilder<any>>(name: Name, query: Q, options?: CteOptions): QueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields, CTEs & Record<Name, QueryBuilderEntity<Q>>>;
     /**
      * Adds a recursive Common Table Expression (CTE) to the query using a `NativeQueryBuilder` or raw SQL fragment.
      * The CTE name is tracked but without entity type inference — use `from()` to query from it.

package/query/QueryBuilder.js

@@ -782,7 +782,9 @@ export class QueryBuilder {
             this.fromRawTable(target, aliasName);
         }
         else {
-            if (aliasName && this.#state.mainAlias && Utils.className(target) !== this.#state.mainAlias.aliasName) {
+            if (aliasName &&
+                this.#state.mainAlias &&
+                Utils.className(target) !== this.#state.mainAlias.aliasName) {
                 throw new Error(`Cannot override the alias to '${aliasName}' since a query already contains references to '${this.#state.mainAlias.aliasName}'`);
             }
             this.fromEntityName(target, aliasName);