@mikro-orm/core 7.0.0-dev.0 → 7.0.0-dev.2

package/utils/RawQueryFragment.js

@@ -1,18 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALIAS_REPLACEMENT_RE = exports.ALIAS_REPLACEMENT = exports.Raw = exports.RawQueryFragment = void 0;
-exports.isRaw = isRaw;
-exports.raw = raw;
-exports.sql = sql;
-exports.createSqlFunction = createSqlFunction;
-const node_async_hooks_1 = require("node:async_hooks");
-const node_util_1 = require("node:util");
-const Utils_1 = require("./Utils");
-class RawQueryFragment {
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { inspect } from 'node:util';
+import { Utils } from './Utils.js';
+export class RawQueryFragment {
     sql;
     params;
     static #rawQueryCache = new Map();
-    static #storage = new node_async_hooks_1.AsyncLocalStorage();
+    static #storage = new AsyncLocalStorage();
     static #index = 0n;
     static cloneRegistry;
     #assigned = false;
@@ -93,27 +86,26 @@ class RawQueryFragment {
             }
         }
     }
-    /* istanbul ignore next */
+    /* v8 ignore next 8 */
     /** @ignore */
-    [node_util_1.inspect.custom]() {
+    [inspect.custom]() {
         if (this.params) {
             return { sql: this.sql, params: this.params };
         }
         return { sql: this.sql };
     }
 }
-exports.RawQueryFragment = RawQueryFragment;
-exports.Raw = RawQueryFragment;
+export { RawQueryFragment as Raw };
 Object.defineProperties(RawQueryFragment.prototype, {
     __raw: { value: true, enumerable: false },
 });
-function isRaw(value) {
+export function isRaw(value) {
     return typeof value === 'object' && value !== null && '__raw' in value;
 }
 /** @internal */
-exports.ALIAS_REPLACEMENT = '[::alias::]';
+export const ALIAS_REPLACEMENT = '[::alias::]';
 /** @internal */
-exports.ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
+export const ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
 /**
  * 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
@@ -151,19 +143,19 @@ exports.ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
  * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
  * ```
  */
-function raw(sql, params) {
+export function raw(sql, params) {
     if (sql instanceof RawQueryFragment) {
         return sql;
     }
     if (sql instanceof Function) {
-        sql = sql(exports.ALIAS_REPLACEMENT);
+        sql = sql(ALIAS_REPLACEMENT);
     }
     if (sql === '??' && Array.isArray(params)) {
         return new RawQueryFragment(sql, params);
     }
     if (Array.isArray(sql)) {
         // for composite FK we return just a simple string
-        return Utils_1.Utils.getPrimaryKeyHash(sql);
+        return Utils.getPrimaryKeyHash(sql);
     }
     if (typeof params === 'object' && !Array.isArray(params)) {
         const pairs = Object.entries(params);
@@ -191,14 +183,14 @@ function raw(sql, params) {
  * await em.find(User, { [sql`(select 1 = 1)`]: [] });
  * ```
  */
-function sql(sql, ...values) {
+export function sql(sql, ...values) {
     return raw(sql.reduce((query, queryPart, i) => {
         const valueExists = i < values.length;
         const text = query + queryPart;
         return valueExists ? text + '?' : text;
     }, ''), values);
 }
-function createSqlFunction(func, key) {
+export function createSqlFunction(func, key) {
     if (typeof key === 'string') {
         return raw(`${func}(${key})`);
     }

package/utils/RequestContext.d.ts

@@ -1,5 +1,5 @@
-import type { EntityManager } from '../EntityManager';
-import { type LoggingOptions } from '../logging/Logger';
+import type { EntityManager } from '../EntityManager.js';
+import { type LoggingOptions } from '../logging/Logger.js';
 /**
  * Uses `AsyncLocalStorage` to create async context that holds the current EM fork.
  */

package/utils/RequestContext.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequestContext = void 0;
-const node_async_hooks_1 = require("node:async_hooks");
+import { AsyncLocalStorage } from 'node:async_hooks';
 /**
  * Uses `AsyncLocalStorage` to create async context that holds the current EM fork.
  */
-class RequestContext {
+export class RequestContext {
     map;
-    static storage = new node_async_hooks_1.AsyncLocalStorage();
+    static storage = new AsyncLocalStorage();
     static counter = 1;
     id = RequestContext.counter++;
     constructor(map) {
@@ -61,4 +58,3 @@ class RequestContext {
         return new RequestContext(forks);
     }
 }
-exports.RequestContext = RequestContext;

package/utils/TransactionContext.d.ts

@@ -1,4 +1,4 @@
-import type { EntityManager } from '../EntityManager';
+import type { EntityManager } from '../EntityManager.js';
 export declare class TransactionContext {
     readonly em: EntityManager;
     private static storage;

package/utils/TransactionContext.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionContext = void 0;
-const node_async_hooks_1 = require("node:async_hooks");
-class TransactionContext {
+import { AsyncLocalStorage } from 'node:async_hooks';
+export class TransactionContext {
     em;
-    static storage = new node_async_hooks_1.AsyncLocalStorage();
+    static storage = new AsyncLocalStorage();
     id;
     constructor(em) {
         this.em = em;
@@ -26,9 +23,8 @@ class TransactionContext {
     /**
      * Returns current EntityManager (if available).
      */
-    static getEntityManager(name = /* istanbul ignore next */ 'default') {
+    static getEntityManager(name = 'default') {
         const context = TransactionContext.currentTransactionContext();
         return context?.em.name === name ? context.em : undefined;
     }
 }
-exports.TransactionContext = TransactionContext;

package/utils/Utils.d.ts

@@ -1,8 +1,8 @@
 import { type GlobbyOptions } from 'globby';
-import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings';
-import type { Collection } from '../entity/Collection';
-import type { Platform } from '../platforms';
-import type { ScalarReference } from '../entity/Reference';
+import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings.js';
+import type { Collection } from '../entity/Collection.js';
+import type { Platform } from '../platforms/Platform.js';
+import type { ScalarReference } from '../entity/Reference.js';
 export declare const ObjectBindingPattern: unique symbol;
 export declare function compareObjects(a: any, b: any): boolean;
 export declare function compareArrays(a: any[] | string, b: any[] | string): boolean;
@@ -153,7 +153,9 @@ export declare class Utils {
     /**
      * Checks whether the argument is ObjectId instance
      */
-    static isObjectID(key: any): boolean;
+    static isObjectID(key: any): key is {
+        toHexString: () => string;
+    };
     /**
      * Checks whether the argument is empty (array without items, object without keys or falsy value).
      */
@@ -164,9 +166,9 @@ export declare class Utils {
     static className<T>(classOrName: EntityName<T>): string;
     static extractChildElements(items: string[], prefix: string, allSymbol?: string): string[];
     /**
-     * Tries to detect `ts-node` runtime.
+     * Tries to detect TypeScript support.
      */
-    static detectTsNode(): boolean;
+    static detectTypeScriptSupport(): boolean;
     /**
      * Uses some dark magic to get source path to caller where decorator is used.
      * Analyses stack trace of error created inside the function call.
@@ -230,6 +232,9 @@ export declare class Utils {
     static requireFrom<T extends Dictionary>(id: string, from?: string): T;
     static dynamicImport<T = any>(id: string): Promise<T>;
     static setDynamicImportProvider(provider: (id: string) => Promise<unknown>): void;
+    static ensureDir(path: string): void;
+    static pathExistsSync(path: string): boolean;
+    static readJSONSync(path: string): Dictionary;
     static getORMVersion(): string;
     static createFunction(context: Map<string, any>, code: string): any;
     static callCompiledFunction<T extends unknown[], R>(fn: (...args: T) => R, ...args: T): R;
@@ -245,6 +250,10 @@ export declare class Utils {
         from?: string;
         allowError?: string;
     }): T | undefined;
+    static tryImport<T extends Dictionary = any>({ module, warning }: {
+        module: string;
+        warning: string;
+    }): Promise<T | undefined>;
     static stripRelativePath(str: string): string;
     /**
      * simple process.argv parser, supports only properties with long names, prefixed with `--`
@@ -254,10 +263,5 @@ export declare class Utils {
     static keys<T extends object>(obj: T): (keyof T)[];
     static values<T extends object>(obj: T): T[keyof T][];
     static entries<T extends object>(obj: T): [keyof T, T[keyof T]][];
-    static isRawSql<T = {
-        sql: string;
-        params: unknown[];
-        use: () => void;
-    }>(value: unknown): value is T;
     static primaryKeyToObject<T>(meta: EntityMetadata<T>, primaryKey: Primary<T> | T, visible?: (keyof T)[]): T;
 }