@mikro-orm/sql 7.0.0-dev.113 → 7.0.0-dev.115

package/query/CriteriaNodeFactory.d.ts

@@ -1,12 +1,12 @@
-import { type Dictionary, type EntityKey, type EntityMetadata, type MetadataStorage } from '@mikro-orm/core';
+import { type Dictionary, type EntityKey, type EntityMetadata, type EntityName, type MetadataStorage, type RawQueryFragmentSymbol } from '@mikro-orm/core';
 import type { ICriteriaNode } from '../typings.js';
 /**
  * @internal
  */
 export declare class CriteriaNodeFactory {
-    static createNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createArrayNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any[], parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createObjectNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: Dictionary, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: string, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T>, meta?: EntityMetadata<T>): ICriteriaNode<T>;
+    static createNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol): ICriteriaNode<T>;
+    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol): ICriteriaNode<T>;
+    static createArrayNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any[], parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createObjectNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: Dictionary, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T> | RawQueryFragmentSymbol, meta?: EntityMetadata<T>): ICriteriaNode<T>;
 }

package/query/CriteriaNodeFactory.js

@@ -7,8 +7,8 @@ import { ScalarCriteriaNode } from './ScalarCriteriaNode.js';
  */
 export class CriteriaNodeFactory {
     static createNode(metadata, entityName, payload, parent, key) {
-        const customExpression = RawQueryFragment.isKnownFragment(key || '');
-        const scalar = Utils.isPrimaryKey(payload) || isRaw(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(key);
+        const scalar = Utils.isPrimaryKey(payload) || isRaw(payload) || payload instanceof RegExp || payload instanceof Date || rawField;
         if (Array.isArray(payload) && !scalar) {
             return this.createArrayNode(metadata, entityName, payload, parent, key);
         }
@@ -38,25 +38,27 @@ export class CriteriaNodeFactory {
         const meta = metadata.find(entityName);
         const node = new ObjectCriteriaNode(metadata, entityName, parent, key, true, payload.__strict);
         node.payload = {};
-        for (const key of Object.keys(payload)) {
-            node.payload[key] = this.createObjectItemNode(metadata, entityName, node, payload, key, meta);
+        for (const k of Utils.getObjectQueryKeys(payload)) {
+            node.payload[k] = this.createObjectItemNode(metadata, entityName, node, payload, k, meta);
         }
         return node;
     }
     static createObjectItemNode(metadata, entityName, node, payload, key, meta) {
-        const prop = meta?.properties[key];
-        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? prop.type : entityName;
-        const isNotEmbedded = prop?.kind !== ReferenceKind.EMBEDDED;
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(key);
+        const prop = rawField ? null : meta?.properties[key];
+        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? prop.targetMeta.class : entityName;
+        const isNotEmbedded = rawField || prop?.kind !== ReferenceKind.EMBEDDED;
+        const val = payload[key];
         if (isNotEmbedded && prop?.customType instanceof JsonType) {
-            return this.createScalarNode(metadata, childEntity, payload[key], node, key);
+            return this.createScalarNode(metadata, childEntity, val, node, key);
         }
-        if (prop?.kind === ReferenceKind.SCALAR && payload[key] != null && Object.keys(payload[key]).some(f => f in GroupOperator)) {
+        if (prop?.kind === ReferenceKind.SCALAR && val != null && Object.keys(val).some(f => f in GroupOperator)) {
             throw ValidationError.cannotUseGroupOperatorsInsideScalars(entityName, prop.name, payload);
         }
         if (isNotEmbedded) {
-            return this.createNode(metadata, childEntity, payload[key], node, key);
+            return this.createNode(metadata, childEntity, val, node, key);
         }
-        if (payload[key] == null) {
+        if (val == null) {
             const map = Object.keys(prop.embeddedProps).reduce((oo, k) => {
                 oo[prop.embeddedProps[k].name] = null;
                 return oo;
@@ -65,23 +67,23 @@ export class CriteriaNodeFactory {
         }
         // array operators can be used on embedded properties
         const allowedOperators = ['$contains', '$contained', '$overlap'];
-        const operator = Object.keys(payload[key]).some(f => Utils.isOperator(f) && !allowedOperators.includes(f));
+        const operator = Object.keys(val).some(f => Utils.isOperator(f) && !allowedOperators.includes(f));
         if (operator) {
             throw ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
         }
-        const map = Object.keys(payload[key]).reduce((oo, k) => {
+        const map = Object.keys(val).reduce((oo, k) => {
             const embeddedProp = prop.embeddedProps[k] ?? Object.values(prop.embeddedProps).find(p => p.name === k);
             if (!embeddedProp && !allowedOperators.includes(k)) {
                 throw ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
             }
             if (embeddedProp) {
-                oo[embeddedProp.name] = payload[key][k];
+                oo[embeddedProp.name] = val[k];
             }
-            else if (typeof payload[key][k] === 'object') {
-                oo[k] = JSON.stringify(payload[key][k]);
+            else if (typeof val[k] === 'object') {
+                oo[k] = JSON.stringify(val[k]);
             }
             else {
-                oo[k] = payload[key][k];
+                oo[k] = val[k];
             }
             return oo;
         }, {});

package/query/NativeQueryBuilder.js

@@ -27,8 +27,7 @@ export class NativeQueryBuilder {
     }
     from(tableName, options) {
         if (tableName instanceof NativeQueryBuilder) {
-            const { sql, params } = tableName.compile();
-            tableName = raw(sql, params);
+            tableName = tableName.toRaw();
         }
         if (typeof tableName === 'string') {
             const alias = options?.alias ? ` as ${this.platform.quoteIdentifier(options.alias)}` : '';

package/query/ObjectCriteriaNode.js

@@ -9,7 +9,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
         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, matchPopulateJoins });
         const ownerAlias = options?.alias || qb.alias;
-        const keys = Object.keys(this.payload);
+        const keys = Utils.getObjectQueryKeys(this.payload);
         let alias = options?.alias;
         if (nestedAlias) {
             alias = nestedAlias;
@@ -31,14 +31,14 @@ export class ObjectCriteriaNode extends CriteriaNode {
                     return [QueryType.SELECT, QueryType.COUNT].includes(qb.type) ? `${knownKey ? alias : ownerAlias}.${pk}` : pk;
                 });
                 for (const key of keys) {
-                    if (!['$some', '$none', '$every'].includes(key)) {
+                    if (typeof key !== 'string' || !['$some', '$none', '$every'].includes(key)) {
                         throw new Error('Mixing collection operators with other filters is not allowed.');
                     }
                     const payload = this.payload[key].unwrap();
                     const qb2 = qb.clone(true);
                     const sub = qb2
-                        .from(parentMeta.className)
-                        .innerJoin(this.key, qb2.getNextAlias(this.prop.type))
+                        .from(parentMeta.class)
+                        .innerJoin(this.key, qb2.getNextAlias(this.prop.targetMeta.class))
                         .select(parentMeta.primaryKeys);
                     if (key === '$every') {
                         sub.where({ $not: { [this.key]: payload } });
@@ -78,7 +78,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
             const childNode = this.payload[field];
             const payload = childNode.process(qb, { ...options, alias: this.prop ? alias : ownerAlias });
             const operator = Utils.isOperator(field);
-            const isRawField = RawQueryFragment.isKnownFragment(field);
+            const isRawField = RawQueryFragment.isKnownFragmentSymbol(field);
             // we need to keep the prefixing for formulas otherwise we would lose aliasing context when nesting inside group operators
             const virtual = childNode.prop?.persist === false && !childNode.prop?.formula;
             // if key is missing, we are inside group operator and we need to prefix with alias
@@ -100,18 +100,18 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 this.inlineCondition(field.replaceAll(ALIAS_REPLACEMENT, alias), o, payload);
             }
             else {
-                this.inlineCondition(`${alias}.${field}`, o, payload);
+                this.inlineCondition(`${alias ?? qb.alias}.${field}`, o, payload);
             }
             return o;
         }, {});
     }
     isStrict() {
-        return this.strict || Object.keys(this.payload).some(key => {
+        return this.strict || Utils.getObjectQueryKeys(this.payload).some(key => {
             return this.payload[key].isStrict();
         });
     }
     unwrap() {
-        return Object.keys(this.payload).reduce((o, field) => {
+        return Utils.getObjectQueryKeys(this.payload).reduce((o, field) => {
             o[field] = this.payload[field].unwrap();
             return o;
         }, {});
@@ -119,7 +119,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
     willAutoJoin(qb, alias, options) {
         const nestedAlias = qb.getAliasForJoinPath(this.getPath(), options);
         const ownerAlias = alias || qb.alias;
-        const keys = Object.keys(this.payload);
+        const keys = Utils.getObjectQueryKeys(this.payload);
         if (nestedAlias) {
             alias = nestedAlias;
         }
@@ -132,9 +132,9 @@ export class ObjectCriteriaNode extends CriteriaNode {
         });
     }
     shouldInline(payload) {
-        const customExpression = RawQueryFragment.isKnownFragment(this.key);
-        const scalar = Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
-        const operator = Utils.isObject(payload) && Object.keys(payload).every(k => Utils.isOperator(k, false));
+        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));
         return !!this.prop && this.prop.kind !== ReferenceKind.SCALAR && !scalar && !operator;
     }
     getChildKey(k, prop, childAlias, alias) {
@@ -145,8 +145,8 @@ export class ObjectCriteriaNode extends CriteriaNode {
     }
     inlineArrayChildPayload(obj, payload, k, prop, childAlias, alias) {
         const key = this.getChildKey(k, prop, childAlias);
-        const value = payload.map((child) => Object.keys(child).reduce((inner, childKey) => {
-            const key = (this.isPrefixed(childKey) || Utils.isOperator(childKey)) ? childKey : this.aliased(childKey, 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);
             inner[key] = child[childKey];
             return inner;
         }, {}));
@@ -154,8 +154,11 @@ export class ObjectCriteriaNode extends CriteriaNode {
     }
     inlineChildPayload(o, payload, field, alias, childAlias) {
         const prop = this.metadata.find(this.entityName).properties[field];
-        for (const k of Object.keys(payload)) {
-            if (Utils.isOperator(k, false)) {
+        for (const k of Utils.getObjectQueryKeys(payload)) {
+            if (RawQueryFragment.isKnownFragmentSymbol(k)) {
+                o[k] = payload[k];
+            }
+            else if (Utils.isOperator(k, false)) {
                 const tmp = payload[k];
                 delete payload[k];
                 o[this.aliased(field, alias)] = { [k]: tmp, ...o[this.aliased(field, alias)] };
@@ -167,9 +170,6 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 const key = this.getChildKey(k, prop, childAlias, alias);
                 this.inlineCondition(key, o, payload[k]);
             }
-            else if (RawQueryFragment.isKnownFragment(k)) {
-                o[k] = payload[k];
-            }
             else {
                 o[this.aliased(k, childAlias)] = payload[k];
             }
@@ -194,8 +194,8 @@ export class ObjectCriteriaNode extends CriteriaNode {
         if (!this.prop || !this.parent) {
             return false;
         }
-        const keys = Object.keys(this.payload);
-        if (keys.every(k => k.includes('.') && k.startsWith(`${qb.alias}.`))) {
+        const keys = Utils.getObjectQueryKeys(this.payload);
+        if (keys.every(k => typeof k === 'string' && k.includes('.') && k.startsWith(`${qb.alias}.`))) {
             return false;
         }
         if (keys.some(k => ['$some', '$none', '$every'].includes(k))) {
@@ -206,21 +206,21 @@ export class ObjectCriteriaNode extends CriteriaNode {
         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 (!meta.primaryKeys.includes(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 Object.keys(this.payload[key].payload).every(k => meta.properties[key].targetMeta.primaryKeys.includes(k));
+            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?.pivotTable ?? this.entityName);
-        const customExpression = RawQueryFragment.isKnownFragment(this.key);
-        const scalar = Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
-        const operator = Utils.isPlainObject(this.payload) && Object.keys(this.payload).every(k => Utils.isOperator(k, false));
+        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 field = `${alias}.${this.prop.name}`;
         const method = qb.hasFlag(QueryFlag.INFER_POPULATE) ? 'joinAndSelect' : 'join';
         const path = this.getPath();

package/query/QueryBuilder.d.ts

@@ -98,8 +98,6 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     __populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
     /** @internal */
     _populateMap: Dictionary<string>;
-    /** @internal */
-    readonly rawFragments: Set<string>;
     protected aliasCounter: number;
     protected flags: Set<QueryFlag>;
     protected finalized: boolean;
@@ -175,11 +173,11 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     applyJoinedFilters(em: EntityManager, filterOptions: FilterOptions | undefined): Promise<void>;
     withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<Entity>, operator?: keyof typeof GroupOperator): this;
-    where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
+    where(cond: string | RawQueryFragment, params?: any[], operator?: keyof typeof GroupOperator): this;
     andWhere(cond: QBFilterQuery<Entity>): this;
-    andWhere(cond: string, params?: any[]): this;
+    andWhere(cond: string | RawQueryFragment, params?: any[]): this;
     orWhere(cond: QBFilterQuery<Entity>): this;
-    orWhere(cond: string, params?: any[]): this;
+    orWhere(cond: string | RawQueryFragment, params?: any[]): this;
     orderBy(orderBy: QBQueryOrderMap<Entity> | QBQueryOrderMap<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     andOrderBy(orderBy: QBQueryOrderMap<Entity> | QBQueryOrderMap<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     private processOrderBy;
@@ -222,13 +220,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 AnyEntity<Entity> = AnyEntity>(target: QueryBuilder<Entity>, aliasName?: string): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
-    from<Entity extends AnyEntity<Entity> = AnyEntity>(target: EntityName<Entity>): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    from<Entity extends object>(target: QueryBuilder<Entity>, aliasName?: string): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    from<Entity extends object>(target: EntityName<Entity>): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     getNativeQuery(processVirtualEntity?: boolean): NativeQueryBuilder;
-    /**
-     * @internal
-     */
-    clearRawFragmentsCache(): void;
     /**
      * Returns the query with parameters as wildcards.
      */
@@ -260,11 +254,11 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     /**
      * @internal
      */
-    getNextAlias(entityName?: string): string;
+    getNextAlias(entityName?: string | EntityName): string;
     /**
      * @internal
      */
-    getAliasMap(): Dictionary<string>;
+    getAliasMap(): Dictionary<EntityName>;
     /**
      * Executes this QB and returns the raw results, mapped to the property names (unless disabled via last parameter).
      * Use `method` to specify what kind of result you want to get (array/single/meta).
@@ -313,9 +307,13 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     getResultAndCount(): Promise<[Entity[], number]>;
     /**
      * Returns native query builder instance with sub-query aliased with given alias.
-     * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
      */
     as(alias: string): NativeQueryBuilder;
+    /**
+     * Returns native query builder instance with sub-query aliased with given alias.
+     * You can provide the target entity name as the first parameter and use the second parameter to point to an existing property to infer its field name.
+     */
+    as<T>(targetEntity: EntityName<T>, alias: EntityKey<T>): NativeQueryBuilder;
     clone(reset?: boolean | string[]): QueryBuilder<Entity>;
     /**
      * Sets logger context for this query builder.