@mikro-orm/sql 7.0.2 → 7.0.3-dev.0

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,60 +6,53 @@ 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);
-      }
+    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;
     }
-    if (this.payload instanceof QueryBuilder) {
-      return this.payload.toRaw();
+    willAutoJoin(qb, alias, options) {
+        return this.shouldJoin(qb, alias);
     }
-    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]);
-      }
+    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
+        }
     }
-    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,15 +63,5 @@ 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,77 +7,54 @@ 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)[],
-  ): 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)[]): 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;
 }