@mikro-orm/knex 6.0.0-dev.75 → 6.0.0-dev.76

package/AbstractSqlConnection.js

@@ -93,14 +93,14 @@ class AbstractSqlConnection extends core_1.Connection {
         }
         const formatted = this.platform.formatQuery(queryOrKnex, params);
         const sql = this.getSql(queryOrKnex, formatted, logging);
-        const res = await this.executeQuery(sql, () => {
+        return this.executeQuery(sql, async () => {
             const query = this.getKnex().raw(formatted);
             if (ctx) {
                 query.transacting(ctx);
             }
-            return query;
+            const res = await query;
+            return this.transformRawResult(res, method);
         }, { query: queryOrKnex, params, ...logging });
-        return this.transformRawResult(res, method);
     }
     /**
      * Execute raw SQL queries from file

package/AbstractSqlDriver.d.ts

@@ -55,7 +55,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     }): ConnectionType;
     protected extractManyToMany<T>(entityName: string, data: EntityDictionary<T>): EntityData<T>;
     protected processManyToMany<T extends object>(meta: EntityMetadata<T> | undefined, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
-    protected updateCollectionDiff<T extends object, O extends object>(meta: EntityMetadata<O>, prop: EntityProperty<T>, pks: Primary<O>[], deleteDiff: Primary<T>[][] | boolean, insertDiff: Primary<T>[][], options?: DriverMethodOptions & {
+    protected updateCollectionDiff<T extends object, O extends object>(meta: EntityMetadata<O>, prop: EntityProperty<O>, pks: Primary<O>[], deleteDiff: Primary<T>[][] | boolean, insertDiff: Primary<T>[][], options?: DriverMethodOptions & {
         ownerSchema?: string;
     }): Promise<void>;
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;

package/AbstractSqlDriver.js

@@ -350,7 +350,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 /* istanbul ignore next */
                 qb.insert(data)
                     .onConflict(uniqueFields.map(p => meta?.properties[p]?.fieldNames[0] ?? p))
-                    .merge(core_1.Utils.keys(data).filter(f => !uniqueFields.includes(f)));
+                    .merge(core_1.Utils.keys(data).filter(f => !uniqueFields.includes(f)))
+                    .returning(meta?.comparableProps.filter(p => !p.lazy && !(p.name in data)).map(p => p.name) ?? '*');
             }
             else {
                 qb.update(data).where(where);
@@ -370,8 +371,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const uniqueFields = core_1.Utils.isPlainObject(where[0]) ? Object.keys(where[0]) : meta.primaryKeys;
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
             qb.insert(data)
-                .onConflict(uniqueFields.map(p => meta?.properties[p]?.fieldNames[0] ?? p))
-                .merge(Object.keys(data[0]).filter(f => !uniqueFields.includes(f)));
+                .onConflict(uniqueFields.map(p => meta.properties[p]?.fieldNames[0] ?? p))
+                .merge(Object.keys(data[0]).filter(f => !uniqueFields.includes(f)))
+                .returning(meta.comparableProps.filter(p => !p.lazy && !(p.name in data[0])).map(p => p.name) ?? '*');
             return qb.execute('run', false);
         }
         const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];

package/index.mjs

@@ -146,6 +146,7 @@ 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.75",
+  "version": "6.0.0-dev.76",
   "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",
@@ -63,9 +63,9 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^5.7.6"
+    "@mikro-orm/core": "^5.7.10"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "~6.0.0-dev.75"
+    "@mikro-orm/core": "~6.0.0-dev.76"
   }
 }

package/query/QueryBuilder.d.ts

@@ -60,6 +60,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private _orderBy;
     private _groupBy;
     private _having;
+    private _returning?;
     private _onConflict?;
     private _limit?;
     private _offset?;
@@ -92,9 +93,10 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     count(field?: string | string[], distinct?: boolean): CountQueryBuilder<T>;
     join(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): this;
     leftJoin(field: string, alias: string, cond?: QBFilterQuery): this;
-    joinAndSelect(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): SelectQueryBuilder<T>;
-    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery): SelectQueryBuilder<T>;
-    protected getFieldsForJoinedLoad(prop: EntityProperty<T>, alias: string): Field<T>[];
+    joinAndSelect(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string, fields?: string[]): SelectQueryBuilder<T>;
+    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): SelectQueryBuilder<T>;
+    innerJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): SelectQueryBuilder<T>;
+    protected getFieldsForJoinedLoad(prop: EntityProperty<T>, alias: string, explicitFields?: string[]): Field<T>[];
     withSubQuery(subQuery: Knex.QueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;
     where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
@@ -108,6 +110,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     onConflict(fields?: Field<T> | Field<T>[]): this;
     ignore(): this;
     merge(data?: EntityData<T> | Field<T>[]): this;
+    returning(fields?: Field<T> | Field<T>[]): this;
     /**
      * @internal
      */

package/query/QueryBuilder.js

@@ -144,12 +144,12 @@ class QueryBuilder {
     leftJoin(field, alias, cond = {}) {
         return this.join(field, alias, cond, 'leftJoin');
     }
-    joinAndSelect(field, alias, cond = {}, type = 'innerJoin', path) {
+    joinAndSelect(field, alias, cond = {}, type = 'innerJoin', path, fields) {
         if (!this.type) {
             this.select('*');
         }
         const prop = this.joinReference(field, alias, cond, type, path);
-        this.addSelect(this.getFieldsForJoinedLoad(prop, alias));
+        this.addSelect(this.getFieldsForJoinedLoad(prop, alias, fields));
         const [fromAlias] = this.helper.splitField(field);
         const populate = this._joinedProps.get(fromAlias);
         const item = { field: prop.name, strategy: core_1.LoadStrategy.JOINED, children: [] };
@@ -162,13 +162,16 @@ class QueryBuilder {
         this._joinedProps.set(alias, item);
         return this;
     }
-    leftJoinAndSelect(field, alias, cond = {}) {
-        return this.joinAndSelect(field, alias, cond, 'leftJoin');
+    leftJoinAndSelect(field, alias, cond = {}, fields) {
+        return this.joinAndSelect(field, alias, cond, 'leftJoin', undefined, fields);
     }
-    getFieldsForJoinedLoad(prop, alias) {
+    innerJoinAndSelect(field, alias, cond = {}, fields) {
+        return this.joinAndSelect(field, alias, cond, 'innerJoin', undefined, fields);
+    }
+    getFieldsForJoinedLoad(prop, alias, explicitFields) {
         const fields = [];
         prop.targetMeta.props
-            .filter(prop => this.platform.shouldHaveColumn(prop, this._populate))
+            .filter(prop => explicitFields ? explicitFields.includes(prop.name) || prop.primary : this.platform.shouldHaveColumn(prop, this._populate))
             .forEach(prop => fields.push(...this.driver.mapPropToFieldNames(this, prop, alias)));
         return fields;
     }
@@ -283,6 +286,10 @@ class QueryBuilder {
         this._onConflict[this._onConflict.length - 1].merge = data;
         return this;
     }
+    returning(fields) {
+        this._returning = fields != null ? core_1.Utils.asArray(fields) : fields;
+        return this;
+    }
     /**
      * @internal
      */
@@ -390,7 +397,7 @@ class QueryBuilder {
         if (this.lockMode) {
             this.helper.getLockSQL(qb, this.lockMode, this.lockTables);
         }
-        this.helper.finalize(this.type ?? enums_1.QueryType.SELECT, qb, this.mainAlias.metadata, this._data);
+        this.helper.finalize(this.type ?? enums_1.QueryType.SELECT, qb, this.mainAlias.metadata, this._data, this._returning);
         return qb;
     }
     /**
@@ -585,7 +592,7 @@ class QueryBuilder {
         // clone array/object properties
         const properties = [
             'flags', '_populate', '_populateWhere', '_populateMap', '_joins', '_joinedProps', '_cond', '_data', '_orderBy',
-            '_schema', '_indexHint', '_cache', 'subQueries', 'lockMode', 'lockTables',
+            '_schema', '_indexHint', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
         ];
         properties.forEach(prop => qb[prop] = core_1.Utils.copy(this[prop]));
         /* istanbul ignore else */

package/query/QueryBuilderHelper.d.ts

@@ -47,7 +47,7 @@ export declare class QueryBuilderHelper {
     private getOperatorReplacement;
     getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string;
     getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string;
-    finalize(type: QueryType, qb: Knex.QueryBuilder, meta?: EntityMetadata, data?: Dictionary): void;
+    finalize(type: QueryType, qb: Knex.QueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
     splitField<T>(field: EntityKey<T>, greedyAlias?: boolean): [string, EntityKey<T>];
     getLockSQL(qb: Knex.QueryBuilder, lockMode: LockMode, lockTables?: string[]): void;
     updateVersionProperty(qb: Knex.QueryBuilder, data: Dictionary): void;

package/query/QueryBuilderHelper.js

@@ -455,17 +455,23 @@ class QueryBuilderHelper {
         });
         return ret.join(', ');
     }
-    finalize(type, qb, meta, data) {
+    finalize(type, qb, meta, data, returning) {
         if (!meta || !data || !this.platform.usesReturningStatement()) {
             return;
         }
+        // always respect explicit returning hint
+        if (returning && returning.length > 0) {
+            qb.returning(returning.map(field => this.mapper(field, type)));
+            return;
+        }
         if (type === enums_1.QueryType.INSERT) {
             const returningProps = meta.hydrateProps
-                .filter(prop => prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw))
-                .filter(prop => !(prop.name in data) || core_1.Utils.isRawSql(data[prop.name]));
+                .filter(prop => prop.returning || (prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw)))
+                .filter(prop => !(prop.name in data));
             if (returningProps.length > 0) {
                 qb.returning(core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames)));
             }
+            return;
         }
         if (type === enums_1.QueryType.UPDATE) {
             const returningProps = meta.hydrateProps.filter(prop => core_1.Utils.isRawSql(data[prop.name]));

package/typings.d.ts

@@ -124,7 +124,8 @@ export interface IQueryBuilder<T> {
     join(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): this;
     leftJoin(field: string, alias: string, cond?: QBFilterQuery): this;
     joinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
-    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
+    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): this;
+    innerJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): this;
     withSubQuery(subQuery: Knex.QueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;
     where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;