@mikro-orm/sql 7.0.15-dev.9 → 7.0.15

package/query/ScalarCriteriaNode.d.ts

@@ -4,7 +4,7 @@ import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
  * @internal
  */
 export declare class ScalarCriteriaNode<T extends object> extends CriteriaNode<T> {
-    process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
-    willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
-    private shouldJoin;
+  process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+  willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
+  private shouldJoin;
 }

package/query/ScalarCriteriaNode.js

@@ -6,53 +6,60 @@ import { QueryBuilder } from './QueryBuilder.js';
  * @internal
  */
 export class ScalarCriteriaNode extends CriteriaNode {
-    process(qb, options) {
-        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 });
-        if (this.shouldJoin(qb, nestedAlias)) {
-            const path = this.getPath();
-            const parentPath = this.parent.getPath(); // the parent is always there, otherwise `shouldJoin` would return `false`
-            const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotEntity ?? this.entityName);
-            const field = this.aliased(this.prop.name, options?.alias);
-            const type = this.prop.kind === ReferenceKind.MANY_TO_MANY ? JoinType.pivotJoin : JoinType.leftJoin;
-            qb.join(field, nestedAlias, undefined, type, path);
-            // select the owner as virtual property when joining from 1:1 inverse side, but only if the parent is root entity
-            if (this.prop.kind === ReferenceKind.ONE_TO_ONE &&
-                !parentPath.includes('.') &&
-                !qb.state.fields?.includes(field)) {
-                qb.addSelect(field);
-            }
-        }
-        if (this.payload instanceof QueryBuilder) {
-            return this.payload.toRaw();
-        }
-        if (this.payload && typeof this.payload === 'object') {
-            const keys = Object.keys(this.payload).filter(key => ARRAY_OPERATORS.includes(key) && Array.isArray(this.payload[key]));
-            for (const key of keys) {
-                this.payload[key] = JSON.stringify(this.payload[key]);
-            }
-        }
-        return this.payload;
+  process(qb, options) {
+    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 });
+    if (this.shouldJoin(qb, nestedAlias)) {
+      const path = this.getPath();
+      const parentPath = this.parent.getPath(); // the parent is always there, otherwise `shouldJoin` would return `false`
+      const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotEntity ?? this.entityName);
+      const field = this.aliased(this.prop.name, options?.alias);
+      const type = this.prop.kind === ReferenceKind.MANY_TO_MANY ? JoinType.pivotJoin : JoinType.leftJoin;
+      qb.join(field, nestedAlias, undefined, type, path);
+      // select the owner as virtual property when joining from 1:1 inverse side, but only if the parent is root entity
+      if (
+        this.prop.kind === ReferenceKind.ONE_TO_ONE &&
+        !parentPath.includes('.') &&
+        !qb.state.fields?.includes(field)
+      ) {
+        qb.addSelect(field);
+      }
     }
-    willAutoJoin(qb, alias, options) {
-        return this.shouldJoin(qb, alias);
+    if (this.payload instanceof QueryBuilder) {
+      return this.payload.toRaw();
     }
-    shouldJoin(qb, nestedAlias) {
-        if (!this.parent ||
-            !this.prop ||
-            (nestedAlias && [QueryType.SELECT, QueryType.COUNT].includes(qb.type ?? QueryType.SELECT))) {
-            return false;
-        }
-        switch (this.prop.kind) {
-            case ReferenceKind.ONE_TO_MANY:
-                return true;
-            case ReferenceKind.MANY_TO_MANY:
-                return true;
-            case ReferenceKind.ONE_TO_ONE:
-                return !this.prop.owner;
-            default:
-                return false; // SCALAR, MANY_TO_ONE
-        }
+    if (this.payload && typeof this.payload === 'object') {
+      const keys = Object.keys(this.payload).filter(
+        key => ARRAY_OPERATORS.includes(key) && Array.isArray(this.payload[key]),
+      );
+      for (const key of keys) {
+        this.payload[key] = JSON.stringify(this.payload[key]);
+      }
     }
+    return this.payload;
+  }
+  willAutoJoin(qb, alias, options) {
+    return this.shouldJoin(qb, alias);
+  }
+  shouldJoin(qb, nestedAlias) {
+    if (
+      !this.parent ||
+      !this.prop ||
+      (nestedAlias && [QueryType.SELECT, QueryType.COUNT].includes(qb.type ?? QueryType.SELECT))
+    ) {
+      return false;
+    }
+    switch (this.prop.kind) {
+      case ReferenceKind.ONE_TO_MANY:
+        return true;
+      case ReferenceKind.MANY_TO_MANY:
+        return true;
+      case ReferenceKind.ONE_TO_ONE:
+        return !this.prop.owner;
+      default:
+        return false; // SCALAR, MANY_TO_ONE
+    }
+  }
 }

package/query/enums.d.ts

@@ -1,22 +1,22 @@
 /** Type of SQL query to be generated. */
 export declare enum QueryType {
-    TRUNCATE = "TRUNCATE",
-    SELECT = "SELECT",
-    COUNT = "COUNT",
-    INSERT = "INSERT",
-    UPDATE = "UPDATE",
-    DELETE = "DELETE",
-    UPSERT = "UPSERT"
+  TRUNCATE = 'TRUNCATE',
+  SELECT = 'SELECT',
+  COUNT = 'COUNT',
+  INSERT = 'INSERT',
+  UPDATE = 'UPDATE',
+  DELETE = 'DELETE',
+  UPSERT = 'UPSERT',
 }
 /** Operators that apply to the embedded array column itself, not to individual elements. */
 export declare const EMBEDDABLE_ARRAY_OPS: string[];
 /** Type of SQL JOIN clause. */
 export declare enum JoinType {
-    leftJoin = "left join",
-    innerJoin = "inner join",
-    nestedLeftJoin = "nested left join",
-    nestedInnerJoin = "nested inner join",
-    pivotJoin = "pivot join",
-    innerJoinLateral = "inner join lateral",
-    leftJoinLateral = "left join lateral"
+  leftJoin = 'left join',
+  innerJoin = 'inner join',
+  nestedLeftJoin = 'nested left join',
+  nestedInnerJoin = 'nested inner join',
+  pivotJoin = 'pivot join',
+  innerJoinLateral = 'inner join lateral',
+  leftJoinLateral = 'left join lateral',
 }

package/query/enums.js

@@ -1,24 +1,24 @@
 /** Type of SQL query to be generated. */
 export var QueryType;
 (function (QueryType) {
-    QueryType["TRUNCATE"] = "TRUNCATE";
-    QueryType["SELECT"] = "SELECT";
-    QueryType["COUNT"] = "COUNT";
-    QueryType["INSERT"] = "INSERT";
-    QueryType["UPDATE"] = "UPDATE";
-    QueryType["DELETE"] = "DELETE";
-    QueryType["UPSERT"] = "UPSERT";
+  QueryType['TRUNCATE'] = 'TRUNCATE';
+  QueryType['SELECT'] = 'SELECT';
+  QueryType['COUNT'] = 'COUNT';
+  QueryType['INSERT'] = 'INSERT';
+  QueryType['UPDATE'] = 'UPDATE';
+  QueryType['DELETE'] = 'DELETE';
+  QueryType['UPSERT'] = 'UPSERT';
 })(QueryType || (QueryType = {}));
 /** Operators that apply to the embedded array column itself, not to individual elements. */
 export const EMBEDDABLE_ARRAY_OPS = ['$contains', '$contained', '$overlap'];
 /** Type of SQL JOIN clause. */
 export var JoinType;
 (function (JoinType) {
-    JoinType["leftJoin"] = "left join";
-    JoinType["innerJoin"] = "inner join";
-    JoinType["nestedLeftJoin"] = "nested left join";
-    JoinType["nestedInnerJoin"] = "nested inner join";
-    JoinType["pivotJoin"] = "pivot join";
-    JoinType["innerJoinLateral"] = "inner join lateral";
-    JoinType["leftJoinLateral"] = "left join lateral";
+  JoinType['leftJoin'] = 'left join';
+  JoinType['innerJoin'] = 'inner join';
+  JoinType['nestedLeftJoin'] = 'nested left join';
+  JoinType['nestedInnerJoin'] = 'nested inner join';
+  JoinType['pivotJoin'] = 'pivot join';
+  JoinType['innerJoinLateral'] = 'inner join lateral';
+  JoinType['leftJoinLateral'] = 'left join lateral';
 })(JoinType || (JoinType = {}));

package/query/raw.d.ts

@@ -2,11 +2,11 @@ import { type AnyString, type Dictionary, type EntityKey, type RawQueryFragment
 import type { SelectQueryBuilder as KyselySelectQueryBuilder } from 'kysely';
 /** @internal Type for QueryBuilder instances passed to raw() - uses toRaw to distinguish from Kysely QueryBuilder */
 type QueryBuilderLike = {
-    toQuery(): {
-        sql: string;
-        params: readonly unknown[];
-    };
-    toRaw(): RawQueryFragment;
+  toQuery(): {
+    sql: string;
+    params: readonly unknown[];
+  };
+  toRaw(): RawQueryFragment;
 };
 /**
  * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
@@ -63,5 +63,15 @@ type QueryBuilderLike = {
  * export class Author { ... }
  * ```
  */
-export declare function raw<R = RawQueryFragment & symbol, T extends object = any>(sql: QueryBuilderLike | KyselySelectQueryBuilder<any, any, any> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): R;
+export declare function raw<R = RawQueryFragment & symbol, T extends object = any>(
+  sql:
+    | QueryBuilderLike
+    | KyselySelectQueryBuilder<any, any, any>
+    | EntityKey<T>
+    | EntityKey<T>[]
+    | AnyString
+    | ((alias: string) => string)
+    | RawQueryFragment,
+  params?: readonly unknown[] | Dictionary<unknown>,
+): R;
 export {};

package/query/raw.js

@@ -1,4 +1,4 @@
-import { raw as raw_, Utils, } from '@mikro-orm/core';
+import { raw as raw_, Utils } from '@mikro-orm/core';
 /**
  * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
  * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
@@ -55,13 +55,13 @@ import { raw as raw_, Utils, } from '@mikro-orm/core';
  * ```
  */
 export function raw(sql, params) {
-    if (Utils.isObject(sql) && 'compile' in sql) {
-        const query = sql.compile();
-        return raw_(query.sql, query.parameters);
-    }
-    if (Utils.isObject(sql) && 'toQuery' in sql) {
-        const query = sql.toQuery();
-        return raw_(query.sql, query.params);
-    }
-    return raw_(sql, params);
+  if (Utils.isObject(sql) && 'compile' in sql) {
+    const query = sql.compile();
+    return raw_(query.sql, query.parameters);
+  }
+  if (Utils.isObject(sql) && 'toQuery' in sql) {
+    const query = sql.toQuery();
+    return raw_(query.sql, query.params);
+  }
+  return raw_(sql, params);
 }

package/schema/DatabaseSchema.d.ts

@@ -7,54 +7,78 @@ import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
  * @internal
  */
 export declare class DatabaseSchema {
-    #private;
-    readonly name: string;
-    constructor(platform: AbstractSqlPlatform, name: string);
-    addTable(name: string, schema: string | undefined | null, comment?: string): DatabaseTable;
-    getTables(): DatabaseTable[];
-    /** @internal */
-    setTables(tables: DatabaseTable[]): void;
-    /** @internal */
-    setNamespaces(namespaces: Set<string>): void;
-    getTable(name: string): DatabaseTable | undefined;
-    hasTable(name: string): boolean;
-    addView(name: string, schema: string | undefined | null, definition: string, materialized?: boolean, withData?: boolean): DatabaseView;
-    getViews(): DatabaseView[];
-    /** @internal */
-    setViews(views: DatabaseView[]): void;
-    getView(name: string): DatabaseView | undefined;
-    hasView(name: string): boolean;
-    setNativeEnums(nativeEnums: Dictionary<{
-        name: string;
-        schema?: string;
-        items: string[];
-    }>): void;
-    getNativeEnums(): Dictionary<{
-        name: string;
-        schema?: string;
-        items: string[];
-    }>;
-    getNativeEnum(name: string): {
-        name: string;
-        schema?: string;
-        items: string[];
-    };
-    hasNamespace(namespace: string): boolean;
-    hasNativeEnum(name: string): boolean;
-    getNamespaces(): string[];
-    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[], skipViews?: (string | RegExp)[], ctx?: Transaction): Promise<DatabaseSchema>;
-    static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, em?: any): DatabaseSchema;
-    private static getViewDefinition;
-    private static getSchemaName;
-    /**
-     * Add a foreign key from a TPT child entity's PK to its parent entity's PK.
-     * This FK uses ON DELETE CASCADE to ensure child rows are deleted when parent is deleted.
-     */
-    private static addTPTForeignKey;
-    private static matchName;
-    private static isNameAllowed;
-    private static isTableNameAllowed;
-    private static shouldHaveColumn;
-    toJSON(): Dictionary;
-    prune(schema: string | undefined, wildcardSchemaTables: string[]): void;
+  #private;
+  readonly name: string;
+  constructor(platform: AbstractSqlPlatform, name: string);
+  addTable(name: string, schema: string | undefined | null, comment?: string): DatabaseTable;
+  getTables(): DatabaseTable[];
+  /** @internal */
+  setTables(tables: DatabaseTable[]): void;
+  /** @internal */
+  setNamespaces(namespaces: Set<string>): void;
+  getTable(name: string): DatabaseTable | undefined;
+  hasTable(name: string): boolean;
+  addView(
+    name: string,
+    schema: string | undefined | null,
+    definition: string,
+    materialized?: boolean,
+    withData?: boolean,
+  ): DatabaseView;
+  getViews(): DatabaseView[];
+  /** @internal */
+  setViews(views: DatabaseView[]): void;
+  getView(name: string): DatabaseView | undefined;
+  hasView(name: string): boolean;
+  setNativeEnums(
+    nativeEnums: Dictionary<{
+      name: string;
+      schema?: string;
+      items: string[];
+    }>,
+  ): void;
+  getNativeEnums(): Dictionary<{
+    name: string;
+    schema?: string;
+    items: string[];
+  }>;
+  getNativeEnum(name: string): {
+    name: string;
+    schema?: string;
+    items: string[];
+  };
+  hasNamespace(namespace: string): boolean;
+  hasNativeEnum(name: string): boolean;
+  getNamespaces(): string[];
+  static create(
+    connection: AbstractSqlConnection,
+    platform: AbstractSqlPlatform,
+    config: Configuration,
+    schemaName?: string,
+    schemas?: string[],
+    takeTables?: (string | RegExp)[],
+    skipTables?: (string | RegExp)[],
+    skipViews?: (string | RegExp)[],
+    ctx?: Transaction,
+  ): Promise<DatabaseSchema>;
+  static fromMetadata(
+    metadata: EntityMetadata[],
+    platform: AbstractSqlPlatform,
+    config: Configuration,
+    schemaName?: string,
+    em?: any,
+  ): DatabaseSchema;
+  private static getViewDefinition;
+  private static getSchemaName;
+  /**
+   * Add a foreign key from a TPT child entity's PK to its parent entity's PK.
+   * This FK uses ON DELETE CASCADE to ensure child rows are deleted when parent is deleted.
+   */
+  private static addTPTForeignKey;
+  private static matchName;
+  private static isNameAllowed;
+  private static isTableNameAllowed;
+  private static shouldHaveColumn;
+  toJSON(): Dictionary;
+  prune(schema: string | undefined, wildcardSchemaTables: string[]): void;
 }