@mikro-orm/knex 6.0.0-dev.267 → 6.0.0-dev.269

package/AbstractSqlConnection.d.ts

@@ -40,7 +40,7 @@ export declare abstract class AbstractSqlConnection extends Connection {
     }): Promise<Knex.Transaction>;
     commit(ctx: Knex.Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
     rollback(ctx: Knex.Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
-    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, logging?: LoggingOptions): Promise<T>;
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
     /**
      * Execute raw SQL queries from file
      */

package/AbstractSqlConnection.js

@@ -106,7 +106,7 @@ class AbstractSqlConnection extends core_1.Connection {
             await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionRollback, ctx);
         }
     }
-    async execute(queryOrKnex, params = [], method = 'all', ctx, logging) {
+    async execute(queryOrKnex, params = [], method = 'all', ctx, loggerContext) {
         await this.ensureConnection();
         if (core_1.Utils.isObject(queryOrKnex)) {
             ctx ??= (queryOrKnex.client.transacting ? queryOrKnex : null);
@@ -115,7 +115,7 @@ class AbstractSqlConnection extends core_1.Connection {
             params = q.bindings;
         }
         const formatted = this.platform.formatQuery(queryOrKnex, params);
-        const sql = this.getSql(queryOrKnex, formatted, logging);
+        const sql = this.getSql(queryOrKnex, formatted, loggerContext);
         return this.executeQuery(sql, async () => {
             const query = this.getKnex().raw(formatted);
             if (ctx) {
@@ -123,7 +123,7 @@ class AbstractSqlConnection extends core_1.Connection {
             }
             const res = await query;
             return this.transformRawResult(res, method);
-        }, { query: queryOrKnex, params, ...logging });
+        }, { query: queryOrKnex, params, ...loggerContext });
     }
     /**
      * Execute raw SQL queries from file

package/AbstractSqlDriver.d.ts

@@ -35,7 +35,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     /**
      * 1:1 owner side needs to be marked for population so QB auto-joins the owner id
      */
-    protected autoJoinOneToOneOwner<T extends object, P extends string = never>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[]): PopulateOptions<T>[];
+    protected autoJoinOneToOneOwner<T extends object, P extends string = never>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, any>[]): PopulateOptions<T>[];
     /**
      * @internal
      */
@@ -55,7 +55,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
      */
     mapPropToFieldNames<T extends object>(qb: QueryBuilder<T>, prop: EntityProperty<T>, tableAlias?: string): Field<T>[];
     /** @internal */
-    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, logging?: LoggingOptions): QueryBuilder<T>;
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions): QueryBuilder<T>;
     protected resolveConnectionType(args: {
         ctx?: Transaction<Knex.Transaction>;
         connectionType?: ConnectionType;

package/AbstractSqlDriver.js

@@ -217,9 +217,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 }
                 return;
             }
-            const relationPojo = {};
+            let relationPojo = {};
             meta2.props
-                .filter(prop => prop.persist === false && prop.fieldNames)
+                .filter(prop => !ref && prop.persist === false && prop.fieldNames)
                 .filter(prop => !prop.lazy || populate.some(p => p.field === prop.name || p.all))
                 .forEach(prop => {
                 /* istanbul ignore if */
@@ -231,7 +231,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     relationPojo[prop.name] = root[alias];
                 }
             });
-            const props = meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []));
+            const props = ref
+                ? meta2.getPrimaryProps()
+                : meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []));
             for (const prop1 of props) {
                 if (prop1.fieldNames.length > 1) { // composite keys
                     const fk = prop1.fieldNames.map(name => root[`${relationAlias}__${name}`]);
@@ -251,6 +253,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             for (const prop1 of props) {
                 prop1.fieldNames.map(name => delete root[`${relationAlias}__${name}`]);
             }
+            if (ref) {
+                const tmp = Object.values(relationPojo);
+                relationPojo = meta2.compositePK ? tmp : tmp[0];
+            }
             if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
                 result[prop.name] ??= [];
                 result[prop.name].push(relationPojo);
@@ -764,8 +770,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 return false;
             }
             if (ref) {
-                // keep only pivot ref joins here, as that only triggers actual join
-                return prop.kind === core_1.ReferenceKind.MANY_TO_MANY;
+                return [core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind);
             }
             return ![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind);
         });
@@ -847,6 +852,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             if (pivotRefJoin) {
                 fields.push(...prop.joinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)), ...prop.inverseJoinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
             }
+            if (prop.kind === core_1.ReferenceKind.ONE_TO_MANY && ref) {
+                fields.push(...this.getFieldsForJoinedLoad(qb, meta2, prop.referencedColumnNames, hint.children, options, tableAlias, path));
+            }
             const childExplicitFields = explicitFields?.filter(f => core_1.Utils.isPlainObject(f)).map(o => o[prop.name])[0] || [];
             explicitFields?.forEach(f => {
                 if (typeof f === 'string' && f.startsWith(`${prop.name}.`)) {
@@ -889,9 +897,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         return prop.fieldNames;
     }
     /** @internal */
-    createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, logging) {
+    createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext) {
         const connectionType = this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
-        const qb = new query_1.QueryBuilder(entityName, this.metadata, this, ctx, undefined, connectionType, undefined, logging);
+        const qb = new query_1.QueryBuilder(entityName, this.metadata, this, ctx, undefined, connectionType, undefined, loggerContext);
         if (!convertCustomTypes) {
             qb.unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
         }

package/SqlEntityManager.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import { EntityManager, type AnyEntity, type ConnectionType, type EntityData, type EntityName, type EntityRepository, type GetRepository, type QueryResult, type FilterQuery } from '@mikro-orm/core';
+import { EntityManager, type AnyEntity, type ConnectionType, type EntityData, type EntityName, type EntityRepository, type GetRepository, type QueryResult, type FilterQuery, type LoggingOptions } from '@mikro-orm/core';
 import type { AbstractSqlDriver } from './AbstractSqlDriver';
 import { QueryBuilder } from './query';
 import type { SqlEntityRepository } from './SqlEntityRepository';
@@ -10,11 +10,11 @@ export declare class SqlEntityManager<D extends AbstractSqlDriver = AbstractSqlD
     /**
      * Creates a QueryBuilder instance
      */
-    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, alias?: string, type?: ConnectionType): QueryBuilder<T>;
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, alias?: string, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<T>;
     /**
      * Shortcut for `createQueryBuilder()`
      */
-    qb<T extends object>(entityName: EntityName<T>, alias?: string, type?: ConnectionType): QueryBuilder<T>;
+    qb<T extends object>(entityName: EntityName<T>, alias?: string, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<T>;
     /**
      * Returns configured knex instance.
      */

package/SqlEntityManager.js

@@ -10,15 +10,15 @@ class SqlEntityManager extends core_1.EntityManager {
     /**
      * Creates a QueryBuilder instance
      */
-    createQueryBuilder(entityName, alias, type) {
+    createQueryBuilder(entityName, alias, type, loggerContext) {
         const context = this.getContext();
-        return new query_1.QueryBuilder(entityName, this.getMetadata(), this.getDriver(), context.getTransactionContext(), alias, type, context);
+        return new query_1.QueryBuilder(entityName, this.getMetadata(), this.getDriver(), context.getTransactionContext(), alias, type, context, loggerContext ?? context.loggerContext);
     }
     /**
      * Shortcut for `createQueryBuilder()`
      */
-    qb(entityName, alias, type) {
-        return this.createQueryBuilder(entityName, alias, type);
+    qb(entityName, alias, type, loggerContext) {
+        return this.createQueryBuilder(entityName, alias, type, loggerContext);
     }
     /**
      * Returns configured knex instance.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.267",
+  "version": "6.0.0-dev.269",
   "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",
@@ -66,6 +66,6 @@
     "@mikro-orm/core": "^5.9.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.0.0-dev.267"
+    "@mikro-orm/core": "6.0.0-dev.269"
   }
 }

package/query/QueryBuilder.d.ts

@@ -38,7 +38,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private readonly context?;
     private connectionType?;
     private readonly em?;
-    private readonly logging?;
+    private readonly loggerContext?;
     get mainAlias(): Alias<T>;
     get alias(): string;
     get helper(): QueryBuilderHelper;
@@ -87,7 +87,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     /**
      * @internal
      */
-    constructor(entityName: EntityName<T> | QueryBuilder<T>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined, logging?: LoggingOptions | undefined);
+    constructor(entityName: EntityName<T> | QueryBuilder<T>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined, loggerContext?: LoggingOptions | undefined);
     select(fields: Field<T> | Field<T>[], distinct?: boolean): SelectQueryBuilder<T>;
     addSelect(fields: Field<T> | Field<T>[]): SelectQueryBuilder<T>;
     distinct(): SelectQueryBuilder<T>;

package/query/QueryBuilder.js

@@ -31,7 +31,7 @@ class QueryBuilder {
     context;
     connectionType;
     em;
-    logging;
+    loggerContext;
     get mainAlias() {
         this.ensureFromClause();
         return this._mainAlias;
@@ -88,13 +88,13 @@ class QueryBuilder {
     /**
      * @internal
      */
-    constructor(entityName, metadata, driver, context, alias, connectionType, em, logging) {
+    constructor(entityName, metadata, driver, context, alias, connectionType, em, loggerContext) {
         this.metadata = metadata;
         this.driver = driver;
         this.context = context;
         this.connectionType = connectionType;
         this.em = em;
-        this.logging = logging;
+        this.loggerContext = loggerContext;
         this.platform = this.driver.getPlatform();
         this.knex = this.driver.getConnection(this.connectionType).getKnex();
         if (alias) {
@@ -587,7 +587,7 @@ class QueryBuilder {
         }
         const write = method === 'run' || !this.platform.getConfig().get('preferReadReplicas');
         const type = this.connectionType || (write ? 'write' : 'read');
-        const res = await this.driver.getConnection(type).execute(query.sql, query.bindings, method, this.context, this.logging);
+        const res = await this.driver.getConnection(type).execute(query.sql, query.bindings, method, this.context, this.loggerContext);
         const meta = this.mainAlias.metadata;
         if (!options.mapResults || !meta) {
             await this.em?.storeCache(this._cache, cached, res);