@mikro-orm/sql 7.0.0-rc.2 → 7.0.0

package/query/NativeQueryBuilder.d.ts

@@ -1,6 +1,17 @@
 import { type Dictionary, LockMode, type QueryFlag, RawQueryFragment, type Subquery } from '@mikro-orm/core';
 import { QueryType } from './enums.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
+export interface CteOptions {
+    columns?: string[];
+    /** PostgreSQL: MATERIALIZED / NOT MATERIALIZED */
+    materialized?: boolean;
+}
+interface CteClause extends CteOptions {
+    name: string;
+    sql: string;
+    params: unknown[];
+    recursive?: boolean;
+}
 interface Options {
     tableName?: string | RawQueryFragment;
     indexHint?: string;
@@ -27,13 +38,14 @@ interface Options {
     onConflict?: OnConflictClause;
     lockMode?: LockMode;
     lockTables?: string[];
-    returning?: (string | RawQueryFragment)[];
+    returning?: (string | RawQueryFragment | [name: string, type: unknown])[];
     comment?: string[];
     hintComment?: string[];
     flags?: Set<QueryFlag>;
     wrap?: [prefix: string, suffix: string];
+    ctes?: CteClause[];
 }
-interface TableOptions {
+export interface TableOptions {
     schema?: string;
     indexHint?: string;
     alias?: string;
@@ -65,6 +77,17 @@ export declare class NativeQueryBuilder implements Subquery {
     groupBy(groupBy: (string | RawQueryFragment)[]): this;
     join(sql: string, params: unknown[]): this;
     orderBy(orderBy: string): this;
+    /**
+     * The sub-query is compiled eagerly at call time — later mutations to the
+     * sub-query builder will not be reflected in this CTE.
+     */
+    with(name: string, query: NativeQueryBuilder | RawQueryFragment, options?: CteOptions): this;
+    /**
+     * Adds a recursive CTE (`WITH RECURSIVE` on PostgreSQL/MySQL/SQLite, plain `WITH` on MSSQL).
+     * The sub-query is compiled eagerly — later mutations will not be reflected.
+     */
+    withRecursive(name: string, query: NativeQueryBuilder | RawQueryFragment, options?: CteOptions): this;
+    private addCte;
     toString(): string;
     compile(): {
         sql: string;
@@ -85,7 +108,7 @@ export declare class NativeQueryBuilder implements Subquery {
     distinct(): this;
     distinctOn(fields: string[]): this;
     onConflict(options: OnConflictClause): OnConflictClause;
-    returning(fields: (string | RawQueryFragment)[]): this;
+    returning(fields: (string | RawQueryFragment | [name: string, type: unknown])[]): this;
     lockMode(lockMode: LockMode, lockTables?: string[]): this;
     comment(comment: string | string[]): this;
     hintComment(comment: string | string[]): this;
@@ -103,6 +126,8 @@ export declare class NativeQueryBuilder implements Subquery {
     protected compileDelete(): void;
     protected compileTruncate(): void;
     protected addHintComment(): void;
+    protected compileCtes(): void;
+    protected getCteKeyword(hasRecursive: boolean): string;
     protected getTableName(): string;
     protected quote(id: string | RawQueryFragment | NativeQueryBuilder): string;
 }

package/query/NativeQueryBuilder.js

@@ -1,4 +1,4 @@
-import { LockMode, raw, RawQueryFragment, Utils } from '@mikro-orm/core';
+import { LockMode, raw, RawQueryFragment, Utils, } from '@mikro-orm/core';
 import { QueryType } from './enums.js';
 /** @internal */
 export class NativeQueryBuilder {
@@ -30,7 +30,8 @@ export class NativeQueryBuilder {
             tableName = tableName.toRaw();
         }
         if (typeof tableName === 'string') {
-            const alias = options?.alias ? ` as ${this.platform.quoteIdentifier(options.alias)}` : '';
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            const alias = options?.alias ? `${asKeyword}${this.platform.quoteIdentifier(options.alias)}` : '';
             const schema = options?.schema && options.schema !== this.platform.getDefaultSchemaName() ? `${options.schema}.` : '';
             tableName = this.quote(schema + tableName) + alias;
         }
@@ -59,6 +60,36 @@ export class NativeQueryBuilder {
         this.options.orderBy = orderBy;
         return this;
     }
+    /**
+     * The sub-query is compiled eagerly at call time — later mutations to the
+     * sub-query builder will not be reflected in this CTE.
+     */
+    with(name, query, options) {
+        return this.addCte(name, query, options);
+    }
+    /**
+     * Adds a recursive CTE (`WITH RECURSIVE` on PostgreSQL/MySQL/SQLite, plain `WITH` on MSSQL).
+     * The sub-query is compiled eagerly — later mutations will not be reflected.
+     */
+    withRecursive(name, query, options) {
+        return this.addCte(name, query, options, true);
+    }
+    addCte(name, query, options, recursive) {
+        this.options.ctes ??= [];
+        if (this.options.ctes.some(cte => cte.name === name)) {
+            throw new Error(`CTE with name '${name}' already exists`);
+        }
+        const { sql, params } = query instanceof NativeQueryBuilder ? query.compile() : { sql: query.sql, params: [...query.params] };
+        this.options.ctes.push({
+            name,
+            sql,
+            params,
+            recursive,
+            columns: options?.columns,
+            materialized: options?.materialized,
+        });
+        return this;
+    }
     toString() {
         const { sql, params } = this.compile();
         return this.platform.formatQuery(sql, params);
@@ -72,6 +103,7 @@ export class NativeQueryBuilder {
         if (this.options.comment) {
             this.parts.push(...this.options.comment.map(comment => `/* ${comment} */`));
         }
+        this.compileCtes();
         switch (this.type) {
             case QueryType.SELECT:
             case QueryType.COUNT:
@@ -387,6 +419,35 @@ export class NativeQueryBuilder {
             this.parts.push(`/*+ ${this.options.hintComment.join(' ')} */`);
         }
     }
+    compileCtes() {
+        const ctes = this.options.ctes;
+        if (!ctes || ctes.length === 0) {
+            return;
+        }
+        const hasRecursive = ctes.some(cte => cte.recursive);
+        const keyword = this.getCteKeyword(hasRecursive);
+        const cteParts = [];
+        for (const cte of ctes) {
+            let part = this.quote(cte.name);
+            if (cte.columns?.length) {
+                part += ` (${cte.columns.map(c => this.quote(c)).join(', ')})`;
+            }
+            part += ' as';
+            if (cte.materialized === true) {
+                part += ' materialized';
+            }
+            else if (cte.materialized === false) {
+                part += ' not materialized';
+            }
+            part += ` (${cte.sql})`;
+            this.params.push(...cte.params);
+            cteParts.push(part);
+        }
+        this.parts.push(`${keyword} ${cteParts.join(', ')}`);
+    }
+    getCteKeyword(hasRecursive) {
+        return hasRecursive ? 'with recursive' : 'with';
+    }
     getTableName() {
         if (!this.options.tableName) {
             throw new Error('No table name provided');
@@ -414,7 +475,8 @@ export class NativeQueryBuilder {
             const parts = id.split(/ as /i);
             const a = this.platform.quoteIdentifier(parts[0]);
             const b = this.platform.quoteIdentifier(parts[1]);
-            return `${a} as ${b}`;
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            return `${a}${asKeyword}${b}`;
         }
         if (id === '*') {
             return id;

package/query/ObjectCriteriaNode.js

@@ -7,7 +7,8 @@ const COLLECTION_OPERATORS = ['$some', '$none', '$every', '$size'];
  */
 export class ObjectCriteriaNode extends CriteriaNode {
     process(qb, options) {
-        const matchPopulateJoins = options?.matchPopulateJoins || (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
+        const matchPopulateJoins = options?.matchPopulateJoins ||
+            (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
         const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), { ...options, matchPopulateJoins });
         const ownerAlias = options?.alias || qb.alias;
         const keys = Utils.getObjectQueryKeys(this.payload);
@@ -20,13 +21,15 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 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
-                    if (this.parent?.parent) { // we validate only usage on top level
+                    if (this.parent?.parent) {
+                        // we validate only usage on top level
                         return {};
                     }
                     throw new Error(`Collection operators can be used only inside a collection property context, but it was used for ${this.getPath()}.`);
                 }
                 const $and = [];
-                const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) || (this.prop.kind === ReferenceKind.ONE_TO_ONE && this.prop.owner);
+                const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) ||
+                    (this.prop.kind === ReferenceKind.ONE_TO_ONE && this.prop.owner);
                 const parentMeta = this.metadata.find(this.parent.entityName);
                 const primaryKeys = parentMeta.primaryKeys.map(pk => {
                     return [QueryType.SELECT, QueryType.COUNT].includes(qb.type) ? `${knownKey ? alias : ownerAlias}.${pk}` : pk;
@@ -36,7 +39,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
                         throw new Error('Mixing collection operators with other filters is not allowed.');
                     }
                     const payload = this.payload[key].unwrap();
-                    const qb2 = qb.clone(true, ['_schema']);
+                    const qb2 = qb.clone(true, ['schema']);
                     const joinAlias = qb2.getNextAlias(this.prop.targetMeta.class);
                     const sub = qb2
                         .from(parentMeta.class)
@@ -48,7 +51,9 @@ export class ObjectCriteriaNode extends CriteriaNode {
                         const pks = this.prop.referencedColumnNames;
                         const countExpr = raw(`count(${pks.map(() => '??').join(', ')})`, pks.map(pk => `${joinAlias}.${pk}`));
                         sub.groupBy(parentMeta.primaryKeys);
-                        sub.having({ $and: Object.keys(sizeCondition).map(op => ({ [countExpr]: { [op]: sizeCondition[op] } })) });
+                        sub.having({
+                            $and: Object.keys(sizeCondition).map(op => ({ [countExpr]: { [op]: sizeCondition[op] } })),
+                        });
                     }
                     else if (key === '$every') {
                         sub.where({ $not: { [this.key]: payload } });
@@ -111,7 +116,11 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 // use '??' placeholder to properly quote the identifier
                 o[raw('??', [field])] = payload;
             }
-            else if (primaryKey || virtual || operator || field.includes('.') || ![QueryType.SELECT, QueryType.COUNT].includes(qb.type)) {
+            else if (primaryKey ||
+                virtual ||
+                operator ||
+                field.includes('.') ||
+                ![QueryType.SELECT, QueryType.COUNT].includes(qb.type)) {
                 this.inlineCondition(field.replaceAll(ALIAS_REPLACEMENT, alias), o, payload);
             }
             else {
@@ -121,9 +130,10 @@ export class ObjectCriteriaNode extends CriteriaNode {
         }, {});
     }
     isStrict() {
-        return this.strict || Utils.getObjectQueryKeys(this.payload).some(key => {
-            return this.payload[key].isStrict();
-        });
+        return (this.strict ||
+            Utils.getObjectQueryKeys(this.payload).some(key => {
+                return this.payload[key].isStrict();
+            }));
     }
     unwrap() {
         return Utils.getObjectQueryKeys(this.payload).reduce((o, field) => {
@@ -148,8 +158,18 @@ export class ObjectCriteriaNode extends CriteriaNode {
     }
     shouldInline(payload) {
         const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
-        const scalar = Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || rawField;
-        const operator = Utils.isObject(payload) && Utils.getObjectQueryKeys(payload).every(k => Utils.isOperator(k, false));
+        const scalar = Utils.isPrimaryKey(payload) ||
+            payload instanceof RegExp ||
+            payload instanceof Date ||
+            rawField;
+        const operator = Utils.isObject(payload) &&
+            Utils.getObjectQueryKeys(payload).every(k => {
+                if (k === '$not' && Utils.isPlainObject(payload[k])) {
+                    // $not wrapping non-operator conditions (entity props) should be inlined
+                    return Utils.getObjectQueryKeys(payload[k]).every(ik => Utils.isOperator(ik, false));
+                }
+                return Utils.isOperator(k, false);
+            });
         return !!this.prop && this.prop.kind !== ReferenceKind.SCALAR && !scalar && !operator;
     }
     getChildKey(k, prop, childAlias, alias) {
@@ -161,7 +181,9 @@ export class ObjectCriteriaNode extends CriteriaNode {
     inlineArrayChildPayload(obj, payload, k, prop, childAlias, alias) {
         const key = this.getChildKey(k, prop, childAlias);
         const value = payload.map((child) => Utils.getObjectQueryKeys(child).reduce((inner, childKey) => {
-            const key = (RawQueryFragment.isKnownFragmentSymbol(childKey) || this.isPrefixed(childKey) || Utils.isOperator(childKey)) ? childKey : this.aliased(childKey, childAlias);
+            const key = RawQueryFragment.isKnownFragmentSymbol(childKey) || this.isPrefixed(childKey) || Utils.isOperator(childKey)
+                ? childKey
+                : this.aliased(childKey, childAlias);
             inner[key] = child[childKey];
             return inner;
         }, {}));
@@ -173,6 +195,12 @@ export class ObjectCriteriaNode extends CriteriaNode {
             if (RawQueryFragment.isKnownFragmentSymbol(k)) {
                 o[k] = payload[k];
             }
+            else if (k === '$not' &&
+                Utils.isPlainObject(payload[k]) &&
+                Utils.getObjectQueryKeys(payload[k]).some(ik => !Utils.isOperator(ik, false))) {
+                // $not wraps entity conditions (from auto-join), inline at current level
+                this.inlineCondition(k, o, payload[k]);
+            }
             else if (Utils.isOperator(k, false)) {
                 const tmp = payload[k];
                 delete payload[k];
@@ -218,24 +246,42 @@ export class ObjectCriteriaNode extends CriteriaNode {
         }
         const meta = this.metadata.find(this.entityName);
         const embeddable = this.prop.kind === ReferenceKind.EMBEDDED;
-        const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) || (this.prop.kind === ReferenceKind.ONE_TO_ONE && this.prop.owner);
-        const operatorKeys = knownKey && keys.every(key => Utils.isOperator(key, false));
-        const primaryKeys = knownKey && keys.every(key => {
-            if (typeof key !== 'string' || !meta.primaryKeys.includes(key)) {
-                return false;
-            }
-            if (!Utils.isPlainObject(this.payload[key].payload) || ![ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[key].kind)) {
-                return true;
-            }
-            return Utils.getObjectQueryKeys(this.payload[key].payload).every(k => typeof k === 'string' && meta.properties[key].targetMeta.primaryKeys.includes(k));
-        });
+        const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) ||
+            (this.prop.kind === ReferenceKind.ONE_TO_ONE && this.prop.owner);
+        const operatorKeys = knownKey &&
+            keys.every(key => {
+                if (key === '$not') {
+                    // $not wraps conditions like $and/$or, check if it wraps entity property conditions (needs auto-join)
+                    // vs simple operator conditions on the FK (doesn't need auto-join)
+                    const childPayload = this.payload[key].payload;
+                    if (Utils.isPlainObject(childPayload)) {
+                        return Utils.getObjectQueryKeys(childPayload).every(k => Utils.isOperator(k, false));
+                    }
+                }
+                return Utils.isOperator(key, false);
+            });
+        const primaryKeys = knownKey &&
+            keys.every(key => {
+                if (typeof key !== 'string' || !meta.primaryKeys.includes(key)) {
+                    return false;
+                }
+                if (!Utils.isPlainObject(this.payload[key].payload) ||
+                    ![ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[key].kind)) {
+                    return true;
+                }
+                return Utils.getObjectQueryKeys(this.payload[key].payload).every(k => typeof k === 'string' && meta.properties[key].targetMeta.primaryKeys.includes(k));
+            });
         return !primaryKeys && !nestedAlias && !operatorKeys && !embeddable;
     }
     autoJoin(qb, alias, options) {
         const nestedAlias = qb.getNextAlias(this.prop?.pivotEntity ?? this.entityName);
         const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
-        const scalar = Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || rawField;
-        const operator = Utils.isPlainObject(this.payload) && Utils.getObjectQueryKeys(this.payload).every(k => Utils.isOperator(k, false));
+        const scalar = Utils.isPrimaryKey(this.payload) ||
+            this.payload instanceof RegExp ||
+            this.payload instanceof Date ||
+            rawField;
+        const operator = Utils.isPlainObject(this.payload) &&
+            Utils.getObjectQueryKeys(this.payload).every(k => Utils.isOperator(k, false));
         const field = `${alias}.${this.prop.name}`;
         const method = qb.hasFlag(QueryFlag.INFER_POPULATE) ? 'joinAndSelect' : 'join';
         const path = this.getPath();
@@ -243,14 +289,12 @@ export class ObjectCriteriaNode extends CriteriaNode {
             qb.join(field, nestedAlias, undefined, JoinType.pivotJoin, path);
         }
         else {
-            const prev = qb._fields?.slice();
+            const prev = qb.state.fields?.slice();
             const toOneProperty = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
-            const joinType = toOneProperty && !this.prop.nullable
-                ? JoinType.innerJoin
-                : JoinType.leftJoin;
+            const joinType = toOneProperty && !this.prop.nullable ? JoinType.innerJoin : JoinType.leftJoin;
             qb[method](field, nestedAlias, undefined, joinType, path);
             if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
-                qb._fields = prev;
+                qb.state.fields = prev;
             }
         }
         if (options?.type !== 'orderBy') {
@@ -259,6 +303,6 @@ export class ObjectCriteriaNode extends CriteriaNode {
         return nestedAlias;
     }
     isPrefixed(field) {
-        return !!field.match(/\w+\./);
+        return !!/\w+\./.exec(field);
     }
 }