@mikro-orm/sql 7.0.10-dev.8 → 7.0.10

package/query/CriteriaNodeFactory.js

@@ -1,4 +1,12 @@
-import { GroupOperator, isRaw, JsonType, RawQueryFragment, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
+import {
+  GroupOperator,
+  isRaw,
+  JsonType,
+  RawQueryFragment,
+  ReferenceKind,
+  Utils,
+  ValidationError,
+} from '@mikro-orm/core';
 import { ObjectCriteriaNode } from './ObjectCriteriaNode.js';
 import { ArrayCriteriaNode } from './ArrayCriteriaNode.js';
 import { ScalarCriteriaNode } from './ScalarCriteriaNode.js';
@@ -7,102 +15,97 @@ import { EMBEDDABLE_ARRAY_OPS } from './enums.js';
  * @internal
  */
 export class CriteriaNodeFactory {
-    static createNode(metadata, entityName, payload, parent, key, validate = true) {
-        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, validate);
-        }
-        if (Utils.isPlainObject(payload) && !scalar) {
-            return this.createObjectNode(metadata, entityName, payload, parent, key, validate);
-        }
-        return this.createScalarNode(metadata, entityName, payload, parent, key, validate);
+  static createNode(metadata, entityName, payload, parent, key, validate = true) {
+    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, validate);
     }
-    static createScalarNode(metadata, entityName, payload, parent, key, validate = true) {
-        const node = new ScalarCriteriaNode(metadata, entityName, parent, key, validate);
-        node.payload = payload;
-        return node;
+    if (Utils.isPlainObject(payload) && !scalar) {
+      return this.createObjectNode(metadata, entityName, payload, parent, key, validate);
     }
-    static createArrayNode(metadata, entityName, payload, parent, key, validate = true) {
-        const node = new ArrayCriteriaNode(metadata, entityName, parent, key, validate);
-        node.payload = payload.map((item, index) => {
-            const n = this.createNode(metadata, entityName, item, node, undefined, validate);
-            // we care about branching only for $and
-            if (key === '$and' && payload.length > 1) {
-                n.index = index;
-            }
-            return n;
-        });
-        return node;
+    return this.createScalarNode(metadata, entityName, payload, parent, key, validate);
+  }
+  static createScalarNode(metadata, entityName, payload, parent, key, validate = true) {
+    const node = new ScalarCriteriaNode(metadata, entityName, parent, key, validate);
+    node.payload = payload;
+    return node;
+  }
+  static createArrayNode(metadata, entityName, payload, parent, key, validate = true) {
+    const node = new ArrayCriteriaNode(metadata, entityName, parent, key, validate);
+    node.payload = payload.map((item, index) => {
+      const n = this.createNode(metadata, entityName, item, node, undefined, validate);
+      // we care about branching only for $and
+      if (key === '$and' && payload.length > 1) {
+        n.index = index;
+      }
+      return n;
+    });
+    return node;
+  }
+  static createObjectNode(metadata, entityName, payload, parent, key, validate = true) {
+    const meta = metadata.find(entityName);
+    const node = new ObjectCriteriaNode(metadata, entityName, parent, key, validate, payload.__strict);
+    node.payload = {};
+    for (const k of Utils.getObjectQueryKeys(payload)) {
+      node.payload[k] = this.createObjectItemNode(metadata, entityName, node, payload, k, meta, validate);
     }
-    static createObjectNode(metadata, entityName, payload, parent, key, validate = true) {
-        const meta = metadata.find(entityName);
-        const node = new ObjectCriteriaNode(metadata, entityName, parent, key, validate, payload.__strict);
-        node.payload = {};
-        for (const k of Utils.getObjectQueryKeys(payload)) {
-            node.payload[k] = this.createObjectItemNode(metadata, entityName, node, payload, k, meta, validate);
-        }
-        return node;
+    return node;
+  }
+  static createObjectItemNode(metadata, entityName, node, payload, key, meta, validate = true) {
+    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, val, node, key, validate);
     }
-    static createObjectItemNode(metadata, entityName, node, payload, key, meta, validate = true) {
-        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, val, node, key, validate);
-        }
-        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, val, node, key, validate);
-        }
-        if (val == null) {
-            const map = Object.keys(prop.embeddedProps).reduce((oo, k) => {
-                oo[prop.embeddedProps[k].name] = null;
-                return oo;
-            }, {});
-            return this.createNode(metadata, entityName, map, node, key, validate);
-        }
-        // For array embeddeds stored as real columns, route property-level queries
-        // as scalar nodes so QueryBuilderHelper generates EXISTS subqueries with
-        // JSON array iteration.  Keys containing `~` indicate the property lives
-        // inside a parent's object-mode JSON column (MetadataDiscovery uses `~` as
-        // the glue for object embeds), where JSON path access is used instead.
-        if (prop.array && !String(key).includes('~')) {
-            const keys = Object.keys(val);
-            const hasOnlyArrayOps = keys.every(k => EMBEDDABLE_ARRAY_OPS.includes(k));
-            if (!hasOnlyArrayOps) {
-                return this.createScalarNode(metadata, entityName, val, node, key, validate);
-            }
-        }
-        // array operators can be used on embedded properties
-        const operator = Object.keys(val).some(f => Utils.isOperator(f) && !EMBEDDABLE_ARRAY_OPS.includes(f));
-        if (operator) {
-            throw ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
-        }
-        const map = Object.keys(val).reduce((oo, k) => {
-            const embeddedProp = prop.embeddedProps[k] ?? Object.values(prop.embeddedProps).find(p => p.name === k);
-            if (!embeddedProp && !EMBEDDABLE_ARRAY_OPS.includes(k)) {
-                throw ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
-            }
-            if (embeddedProp) {
-                oo[embeddedProp.name] = val[k];
-            }
-            else if (typeof val[k] === 'object') {
-                oo[k] = JSON.stringify(val[k]);
-            }
-            else {
-                oo[k] = val[k];
-            }
-            return oo;
-        }, {});
-        return this.createNode(metadata, entityName, map, node, key, validate);
+    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, val, node, key, validate);
+    }
+    if (val == null) {
+      const map = Object.keys(prop.embeddedProps).reduce((oo, k) => {
+        oo[prop.embeddedProps[k].name] = null;
+        return oo;
+      }, {});
+      return this.createNode(metadata, entityName, map, node, key, validate);
+    }
+    // For array embeddeds stored as real columns, route property-level queries
+    // as scalar nodes so QueryBuilderHelper generates EXISTS subqueries with
+    // JSON array iteration.  Keys containing `~` indicate the property lives
+    // inside a parent's object-mode JSON column (MetadataDiscovery uses `~` as
+    // the glue for object embeds), where JSON path access is used instead.
+    if (prop.array && !String(key).includes('~')) {
+      const keys = Object.keys(val);
+      const hasOnlyArrayOps = keys.every(k => EMBEDDABLE_ARRAY_OPS.includes(k));
+      if (!hasOnlyArrayOps) {
+        return this.createScalarNode(metadata, entityName, val, node, key, validate);
+      }
+    }
+    // array operators can be used on embedded properties
+    const operator = Object.keys(val).some(f => Utils.isOperator(f) && !EMBEDDABLE_ARRAY_OPS.includes(f));
+    if (operator) {
+      throw ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
+    }
+    const map = Object.keys(val).reduce((oo, k) => {
+      const embeddedProp = prop.embeddedProps[k] ?? Object.values(prop.embeddedProps).find(p => p.name === k);
+      if (!embeddedProp && !EMBEDDABLE_ARRAY_OPS.includes(k)) {
+        throw ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
+      }
+      if (embeddedProp) {
+        oo[embeddedProp.name] = val[k];
+      } else if (typeof val[k] === 'object') {
+        oo[k] = JSON.stringify(val[k]);
+      } else {
+        oo[k] = val[k];
+      }
+      return oo;
+    }, {});
+    return this.createNode(metadata, entityName, map, node, key, validate);
+  }
 }

package/query/NativeQueryBuilder.d.ts

@@ -1,139 +1,139 @@
-import { type Dictionary, LockMode, type QueryFlag, RawQueryFragment, type Subquery } from '@mikro-orm/core';
+import { type Dictionary, LockMode, type QueryFlag, type RawQueryFragment, type Subquery } from '@mikro-orm/core';
 import { QueryType } from './enums.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /** Options for Common Table Expression (CTE) definitions. */
 export interface CteOptions {
-    /** Column names for the CTE. */
-    columns?: string[];
-    /** PostgreSQL: MATERIALIZED / NOT MATERIALIZED */
-    materialized?: boolean;
+  /** Column names for the CTE. */
+  columns?: string[];
+  /** PostgreSQL: MATERIALIZED / NOT MATERIALIZED */
+  materialized?: boolean;
 }
 interface CteClause extends CteOptions {
-    name: string;
-    sql: string;
-    params: unknown[];
-    recursive?: boolean;
+  name: string;
+  sql: string;
+  params: unknown[];
+  recursive?: boolean;
 }
 interface Options {
-    tableName?: string | RawQueryFragment;
-    indexHint?: string;
-    select?: (string | RawQueryFragment)[];
-    distinct?: boolean;
-    distinctOn?: string[];
-    joins?: {
-        sql: string;
-        params: unknown[];
-    }[];
-    groupBy?: (string | RawQueryFragment)[];
-    where?: {
-        sql: string;
-        params: unknown[];
-    };
-    having?: {
-        sql: string;
-        params: unknown[];
-    };
-    orderBy?: string;
-    limit?: number;
-    offset?: number;
-    data?: Dictionary;
-    onConflict?: OnConflictClause;
-    lockMode?: LockMode;
-    lockTables?: string[];
-    returning?: (string | RawQueryFragment | [name: string, type: unknown])[];
-    comment?: string[];
-    hintComment?: string[];
-    flags?: Set<QueryFlag>;
-    wrap?: [prefix: string, suffix: string];
-    ctes?: CteClause[];
+  tableName?: string | RawQueryFragment;
+  indexHint?: string;
+  select?: (string | RawQueryFragment)[];
+  distinct?: boolean;
+  distinctOn?: string[];
+  joins?: {
+    sql: string;
+    params: unknown[];
+  }[];
+  groupBy?: (string | RawQueryFragment)[];
+  where?: {
+    sql: string;
+    params: unknown[];
+  };
+  having?: {
+    sql: string;
+    params: unknown[];
+  };
+  orderBy?: string;
+  limit?: number;
+  offset?: number;
+  data?: Dictionary;
+  onConflict?: OnConflictClause;
+  lockMode?: LockMode;
+  lockTables?: string[];
+  returning?: (string | RawQueryFragment | [name: string, type: unknown])[];
+  comment?: string[];
+  hintComment?: string[];
+  flags?: Set<QueryFlag>;
+  wrap?: [prefix: string, suffix: string];
+  ctes?: CteClause[];
 }
 /** Options for specifying the target table in FROM/INTO clauses. */
 export interface TableOptions {
-    schema?: string;
-    indexHint?: string;
-    alias?: string;
+  schema?: string;
+  indexHint?: string;
+  alias?: string;
 }
 interface OnConflictClause {
-    fields: string[] | RawQueryFragment;
-    ignore?: boolean;
-    merge?: Dictionary | (string | RawQueryFragment)[];
-    where?: {
-        sql: string;
-        params: unknown[];
-    };
+  fields: string[] | RawQueryFragment;
+  ignore?: boolean;
+  merge?: Dictionary | (string | RawQueryFragment)[];
+  where?: {
+    sql: string;
+    params: unknown[];
+  };
 }
 /** @internal */
 export declare class NativeQueryBuilder implements Subquery {
-    protected readonly platform: AbstractSqlPlatform;
-    readonly __subquery: true;
-    protected type?: QueryType;
-    protected parts: string[];
-    protected params: unknown[];
-    protected options: Options;
-    constructor(platform: AbstractSqlPlatform);
-    select(fields: string | RawQueryFragment | (string | RawQueryFragment)[]): this;
-    count(fields?: string | RawQueryFragment | (string | RawQueryFragment)[], distinct?: boolean): this;
-    into(tableName: string | RawQueryFragment | NativeQueryBuilder, options?: TableOptions): this;
-    from(tableName: string | RawQueryFragment | NativeQueryBuilder, options?: TableOptions): this;
-    where(sql: string, params: unknown[]): this;
-    having(sql: string, params: unknown[]): this;
-    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;
-        params: unknown[];
-    };
-    protected addLockClause(): void;
-    protected addOnConflictClause(): void;
-    protected combineParts(): {
-        sql: string;
-        params: unknown[];
-    };
-    limit(limit: number): this;
-    offset(offset: number): this;
-    insert(data: Dictionary): this;
-    update(data: Dictionary): this;
-    delete(): this;
-    truncate(): this;
-    distinct(): this;
-    distinctOn(fields: string[]): this;
-    onConflict(options: OnConflictClause): OnConflictClause;
-    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;
-    setFlags(flags: Set<QueryFlag>): this;
-    clear(clause: keyof Options): this;
-    wrap(prefix: string, suffix: string): this;
-    as(alias: string): this;
-    toRaw(): RawQueryFragment;
-    protected compileSelect(): void;
-    /** Whether this COUNT query needs a subquery wrapper for multi-column distinct. */
-    protected needsCountSubquery(): boolean;
-    protected getFields(countSubquery?: boolean): string;
-    protected compileInsert(): void;
-    protected addOutputClause(type: 'inserted' | 'deleted'): void;
-    protected processInsertData(): string[];
-    protected compileUpdate(): void;
-    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;
+  protected readonly platform: AbstractSqlPlatform;
+  readonly __subquery: true;
+  protected type?: QueryType;
+  protected parts: string[];
+  protected params: unknown[];
+  protected options: Options;
+  constructor(platform: AbstractSqlPlatform);
+  select(fields: string | RawQueryFragment | (string | RawQueryFragment)[]): this;
+  count(fields?: string | RawQueryFragment | (string | RawQueryFragment)[], distinct?: boolean): this;
+  into(tableName: string | RawQueryFragment | NativeQueryBuilder, options?: TableOptions): this;
+  from(tableName: string | RawQueryFragment | NativeQueryBuilder, options?: TableOptions): this;
+  where(sql: string, params: unknown[]): this;
+  having(sql: string, params: unknown[]): this;
+  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;
+    params: unknown[];
+  };
+  protected addLockClause(): void;
+  protected addOnConflictClause(): void;
+  protected combineParts(): {
+    sql: string;
+    params: unknown[];
+  };
+  limit(limit: number): this;
+  offset(offset: number): this;
+  insert(data: Dictionary): this;
+  update(data: Dictionary): this;
+  delete(): this;
+  truncate(): this;
+  distinct(): this;
+  distinctOn(fields: string[]): this;
+  onConflict(options: OnConflictClause): OnConflictClause;
+  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;
+  setFlags(flags: Set<QueryFlag>): this;
+  clear(clause: keyof Options): this;
+  wrap(prefix: string, suffix: string): this;
+  as(alias: string): this;
+  toRaw(): RawQueryFragment;
+  protected compileSelect(): void;
+  /** Whether this COUNT query needs a subquery wrapper for multi-column distinct. */
+  protected needsCountSubquery(): boolean;
+  protected getFields(countSubquery?: boolean): string;
+  protected compileInsert(): void;
+  protected addOutputClause(type: 'inserted' | 'deleted'): void;
+  protected processInsertData(): string[];
+  protected compileUpdate(): void;
+  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;
 }
 export {};