@mikro-orm/core 7.0.2-dev.9 → 7.0.3-dev.0

package/utils/RawQueryFragment.js

@@ -1,4 +1,5 @@
 import { Utils } from './Utils.js';
+/** Represents a raw SQL fragment with optional parameters, usable as both a value and an object key via Symbol coercion. */
 export class RawQueryFragment {
     sql;
     params;
@@ -8,6 +9,7 @@ export class RawQueryFragment {
         this.sql = sql;
         this.params = params;
     }
+    /** Returns a unique symbol key for this fragment, creating and caching it on first access. */
     get key() {
         if (!this.#key) {
             this.#key = Symbol(this.toJSON());
@@ -15,6 +17,7 @@ export class RawQueryFragment {
         }
         return this.#key;
     }
+    /** Creates a new fragment with an alias appended via `as ??`. */
     as(alias) {
         return new RawQueryFragment(`${this.sql} as ??`, [...this.params, alias]);
     }
@@ -35,19 +38,23 @@ export class RawQueryFragment {
     clone() {
         return this;
     }
+    /** Checks whether the given value is a symbol that maps to a known raw query fragment. */
     static isKnownFragmentSymbol(key) {
         return typeof key === 'symbol' && this.#rawQueryReferences.has(key);
     }
+    /** Checks whether an object has any symbol keys that are known raw query fragments. */
     static hasObjectFragments(object) {
         return (Utils.isPlainObject(object) &&
             Object.getOwnPropertySymbols(object).some(symbol => this.isKnownFragmentSymbol(symbol)));
     }
+    /** Checks whether the given value is a RawQueryFragment instance or a known fragment symbol. */
     static isKnownFragment(key) {
         if (key instanceof RawQueryFragment) {
             return true;
         }
         return this.isKnownFragmentSymbol(key);
     }
+    /** Retrieves the RawQueryFragment associated with the given key (instance or symbol). */
     static getKnownFragment(key) {
         if (key instanceof RawQueryFragment) {
             return key;
@@ -70,6 +77,7 @@ export { RawQueryFragment as Raw };
 Object.defineProperties(RawQueryFragment.prototype, {
     __raw: { value: true, enumerable: false },
 });
+/** Checks whether the given value is a `RawQueryFragment` instance. */
 export function isRaw(value) {
     return typeof value === 'object' && value !== null && '__raw' in value;
 }
@@ -178,6 +186,7 @@ export function raw(sql, params) {
 export function sql(sql, ...values) {
     return raw(sql.join('?'), values);
 }
+/** Creates a raw SQL function expression wrapping the given key (e.g., `lower(name)`). */
 export function createSqlFunction(func, key) {
     if (typeof key === 'string') {
         return raw(`${func}(${key})`);

package/utils/RequestContext.d.ts

@@ -35,6 +35,7 @@ export declare class RequestContext {
     static getEntityManager(name?: string): EntityManager | undefined;
     private static createContext;
 }
+/** Options for creating a new RequestContext, allowing schema and logger overrides. */
 export interface CreateContextOptions {
     schema?: string;
     loggerContext?: LoggingOptions;

package/utils/TransactionContext.d.ts

@@ -1,4 +1,5 @@
 import type { EntityManager } from '../EntityManager.js';
+/** Uses `AsyncLocalStorage` to maintain a transaction-scoped EntityManager context across async operations. */
 export declare class TransactionContext {
     readonly em: EntityManager;
     private static storage;

package/utils/TransactionContext.js

@@ -1,4 +1,5 @@
 import { createAsyncContext } from './AsyncContext.js';
+/** Uses `AsyncLocalStorage` to maintain a transaction-scoped EntityManager context across async operations. */
 export class TransactionContext {
     em;
     static storage = createAsyncContext();

package/utils/Utils.d.ts

@@ -3,15 +3,21 @@ import type { Collection } from '../entity/Collection.js';
 import type { Platform } from '../platforms/Platform.js';
 import { type ScalarReference } from '../entity/Reference.js';
 import { type RawQueryFragmentSymbol } from './RawQueryFragment.js';
+/** Deeply compares two objects for equality, handling dates, regexes, and raw fragments. */
 export declare function compareObjects(a: any, b: any): boolean;
+/** Compares two arrays element-by-element for deep equality. */
 export declare function compareArrays(a: any[] | string, b: any[] | string): boolean;
+/** Compares two boolean values, treating numeric 0/1 as false/true. */
 export declare function compareBooleans(a: unknown, b: unknown): boolean;
+/** Compares two byte arrays element-by-element. */
 export declare function compareBuffers(a: Uint8Array, b: Uint8Array): boolean;
 /**
  * Checks if arguments are deeply (but not strictly) equal.
  */
 export declare function equals(a: any, b: any): boolean;
+/** Parses a JSON string safely, returning the original value if parsing fails. */
 export declare function parseJsonSafe<T = unknown>(value: unknown): T;
+/** Collection of general-purpose utility methods used throughout the ORM. */
 export declare class Utils {
     #private;
     static readonly PK_SEPARATOR = "~~~";

package/utils/Utils.js

@@ -14,6 +14,7 @@ function compareConstructors(a, b) {
     }
     return false;
 }
+/** Deeply compares two objects for equality, handling dates, regexes, and raw fragments. */
 export function compareObjects(a, b) {
     if (a === b || (a == null && b == null)) {
         return true;
@@ -59,6 +60,7 @@ export function compareObjects(a, b) {
     }
     return true;
 }
+/** Compares two arrays element-by-element for deep equality. */
 export function compareArrays(a, b) {
     const length = a.length;
     if (length !== b.length) {
@@ -72,11 +74,13 @@ export function compareArrays(a, b) {
     }
     return true;
 }
+/** Compares two boolean values, treating numeric 0/1 as false/true. */
 export function compareBooleans(a, b) {
     a = typeof a === 'number' ? Boolean(a) : a;
     b = typeof b === 'number' ? Boolean(b) : b;
     return a === b;
 }
+/** Compares two byte arrays element-by-element. */
 export function compareBuffers(a, b) {
     const length = a.length;
     if (length !== b.length) {
@@ -108,6 +112,7 @@ export function equals(a, b) {
     return Number.isNaN(a) && Number.isNaN(b);
 }
 const equalsFn = equals;
+/** Parses a JSON string safely, returning the original value if parsing fails. */
 export function parseJsonSafe(value) {
     if (typeof value === 'string') {
         /* v8 ignore next */
@@ -121,9 +126,10 @@ export function parseJsonSafe(value) {
     }
     return value;
 }
+/** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.2-dev.9';
+    static #ORM_VERSION = '7.0.3-dev.0';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */