@mikro-orm/knex 6.0.0-dev.312 → 6.0.0-dev.314

package/AbstractSqlDriver.js

@@ -141,7 +141,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }
         }
         qb.where(where);
-        const kqb = qb.getKnexQuery().clear('select');
+        const kqb = qb.getKnexQuery(false).clear('select');
         if (type === query_1.QueryType.COUNT) {
             kqb.select(this.connection.getKnex().raw('count(*) as count'));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.312",
+  "version": "6.0.0-dev.314",
   "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.0.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.0.0-dev.312"
+    "@mikro-orm/core": "6.0.0-dev.314"
   }
 }

package/query/QueryBuilder.d.ts

@@ -116,10 +116,10 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     andWhere(cond: string, params?: any[]): this;
     orWhere(cond: QBFilterQuery<T>): this;
     orWhere(cond: string, params?: any[]): this;
-    orderBy(orderBy: QBQueryOrderMap<T> | QBQueryOrderMap<T>[]): this;
-    groupBy(fields: (string | keyof T) | readonly (string | keyof T)[]): this;
-    having(cond?: QBFilterQuery | string, params?: any[]): this;
-    onConflict(fields?: Field<T> | Field<T>[]): this;
+    orderBy(orderBy: QBQueryOrderMap<T> | QBQueryOrderMap<T>[]): SelectQueryBuilder<T>;
+    groupBy(fields: (string | keyof T) | readonly (string | keyof T)[]): SelectQueryBuilder<T>;
+    having(cond?: QBFilterQuery | string, params?: any[]): SelectQueryBuilder<T>;
+    onConflict(fields?: Field<T> | Field<T>[]): InsertQueryBuilder<T>;
     ignore(): this;
     merge(data?: EntityData<T> | Field<T>[]): this;
     returning(fields?: Field<T> | Field<T>[]): this;
@@ -127,8 +127,8 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * @internal
      */
     populate(populate: PopulateOptions<T>[], populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`): this;
-    limit(limit?: number, offset?: number): this;
-    offset(offset?: number): this;
+    limit(limit?: number, offset?: number): SelectQueryBuilder<T>;
+    offset(offset?: number): SelectQueryBuilder<T>;
     withSchema(schema?: string): this;
     setLockMode(mode?: LockMode, tables?: string[]): this;
     setFlushMode(flushMode?: FlushMode): this;
@@ -154,9 +154,9 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * 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<T extends AnyEntity<T> = AnyEntity>(target: QueryBuilder<T>, aliasName?: string): QueryBuilder<T>;
-    from<T extends AnyEntity<T> = AnyEntity>(target: EntityName<T>): QueryBuilder<T>;
-    getKnexQuery(): Knex.QueryBuilder;
+    from<T extends AnyEntity<T> = AnyEntity>(target: QueryBuilder<T>, aliasName?: string): SelectQueryBuilder<T>;
+    from<T extends AnyEntity<T> = AnyEntity>(target: EntityName<T>): SelectQueryBuilder<T>;
+    getKnexQuery(processVirtualEntity?: boolean): Knex.QueryBuilder;
     /**
      * Returns the query with parameters as wildcards.
      */
@@ -225,7 +225,8 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      */
     as(alias: string): Knex.QueryBuilder;
     clone(reset?: boolean): QueryBuilder<T>;
-    getKnex(): Knex.QueryBuilder;
+    getKnex(processVirtualEntity?: boolean): Knex.QueryBuilder;
+    private fromVirtual;
     private joinReference;
     private prepareFields;
     private init;

package/query/QueryBuilder.js

@@ -456,9 +456,9 @@ class QueryBuilder {
         }
         return this;
     }
-    getKnexQuery() {
+    getKnexQuery(processVirtualEntity = true) {
         this.finalize();
-        const qb = this.getQueryBase();
+        const qb = this.getQueryBase(processVirtualEntity);
         const type = this.type ?? enums_1.QueryType.SELECT;
         qb.__raw = true; // tag it as there is now way to check via `instanceof`
         core_1.Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(type, this._cond, qb), this._cond && !this._onConflict);
@@ -738,9 +738,9 @@ class QueryBuilder {
         qb.finalized = false;
         return qb;
     }
-    getKnex() {
+    getKnex(processVirtualEntity = true) {
         const qb = this.knex.queryBuilder();
-        const { subQuery, aliasName, entityName } = this.mainAlias;
+        const { subQuery, aliasName, entityName, metadata } = this.mainAlias;
         const ref = subQuery ? subQuery : this.knex.ref(this.helper.getTableName(entityName));
         if (this.finalized && (this._explicitAlias || this.helper.isTableNameAliasRequired(this.type))) {
             ref.as(aliasName);
@@ -749,12 +749,36 @@ class QueryBuilder {
         if (schema) {
             ref.withSchema(schema);
         }
-        qb.from(ref);
+        if (metadata?.virtual && processVirtualEntity) {
+            qb.fromRaw(this.fromVirtual(metadata));
+        }
+        else {
+            qb.from(ref);
+        }
         if (this.context) {
             qb.transacting(this.context);
         }
         return qb;
     }
+    fromVirtual(meta) {
+        if (typeof meta.expression === 'string') {
+            return `(${meta.expression}) as ${this.platform.quoteIdentifier(this.alias)}`;
+        }
+        const res = meta.expression(this.em, this._cond, {});
+        if (typeof res === 'string') {
+            return `(${res}) as ${this.platform.quoteIdentifier(this.alias)}`;
+        }
+        if (res instanceof QueryBuilder) {
+            return `(${res.getFormattedQuery()}) as ${this.platform.quoteIdentifier(this.alias)}`;
+        }
+        if (core_1.Utils.isObject(res)) {
+            const { sql, bindings } = res.toSQL();
+            const query = this.platform.formatQuery(sql, bindings);
+            return `(${query}) as ${this.platform.quoteIdentifier(this.alias)}`;
+        }
+        /* istanbul ignore next */
+        return res;
+    }
     joinReference(field, alias, cond, type, path, schema, subquery) {
         this.ensureNotFinalized();
         if (typeof field === 'object') {
@@ -923,8 +947,8 @@ class QueryBuilder {
         }
         return this;
     }
-    getQueryBase() {
-        const qb = this.getKnex();
+    getQueryBase(processVirtualEntity) {
+        const qb = this.getKnex(processVirtualEntity);
         const schema = this.getSchema(this.mainAlias);
         // Joined tables doesn't need to belong to the same schema as the main table
         const joinSchema = this._schema ?? this.em?.schema ?? schema;