@mikro-orm/sql 7.0.8 → 7.0.9-dev.1

package/query/CriteriaNodeFactory.js

@@ -1,12 +1,4 @@
-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';
@@ -15,97 +7,102 @@ 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);
+    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);
     }
-    if (Utils.isPlainObject(payload) && !scalar) {
-      return this.createObjectNode(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;
     }
-    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 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 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 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;
     }
-    if (prop?.kind === ReferenceKind.SCALAR && val != null && Object.keys(val).some(f => f in GroupOperator)) {
-      throw ValidationError.cannotUseGroupOperatorsInsideScalars(entityName, prop.name, payload);
+    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 (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

@@ -3,137 +3,137 @@ 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;
-}
-interface Options {
-  tableName?: string | RawQueryFragment;
-  indexHint?: string;
-  select?: (string | RawQueryFragment)[];
-  distinct?: boolean;
-  distinctOn?: string[];
-  joins?: {
-    sql: string;
-    params: unknown[];
-  }[];
-  groupBy?: (string | RawQueryFragment)[];
-  where?: {
+    name: string;
     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[];
+    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[];
 }
 /** 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 {};