@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.11

package/utils/QueryHelper.js

@@ -1,23 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryHelper = void 0;
-const Reference_1 = require("../entity/Reference");
-const Utils_1 = require("./Utils");
-const enums_1 = require("../enums");
-const JsonType_1 = require("../types/JsonType");
-const wrap_1 = require("../entity/wrap");
-const RawQueryFragment_1 = require("./RawQueryFragment");
-class QueryHelper {
+import { Reference } from '../entity/Reference.js';
+import { Utils } from './Utils.js';
+import { GroupOperator, ReferenceKind } from '../enums.js';
+import { JsonType } from '../types/JsonType.js';
+import { helper } from '../entity/wrap.js';
+import { RawQueryFragment, isRaw } from './RawQueryFragment.js';
+export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
     static processParams(params) {
-        if (Reference_1.Reference.isReference(params)) {
+        if (Reference.isReference(params)) {
             params = params.unwrap();
         }
-        if (Utils_1.Utils.isEntity(params)) {
-            if ((0, wrap_1.helper)(params).__meta.compositePK) {
-                return (0, wrap_1.helper)(params).__primaryKeys;
+        if (Utils.isEntity(params)) {
+            if (helper(params).__meta.compositePK) {
+                return helper(params).__primaryKeys;
             }
-            return (0, wrap_1.helper)(params).getPrimaryKey();
+            return helper(params).getPrimaryKey();
         }
         if (params === undefined) {
             return null;
@@ -25,13 +22,13 @@ class QueryHelper {
         if (Array.isArray(params)) {
             return params.map(item => QueryHelper.processParams(item));
         }
-        if (Utils_1.Utils.isPlainObject(params)) {
+        if (Utils.isPlainObject(params)) {
             QueryHelper.processObjectParams(params);
         }
         return params;
     }
     static processObjectParams(params = {}) {
-        Utils_1.Utils.keys(params).forEach(k => {
+        Utils.keys(params).forEach(k => {
             params[k] = QueryHelper.processParams(params[k]);
         });
         return params;
@@ -40,19 +37,19 @@ class QueryHelper {
         if (Array.isArray(where)) {
             where.forEach((item, i) => {
                 if (this.inlinePrimaryKeyObjects(item, meta, metadata, key)) {
-                    where[i] = Utils_1.Utils.getPrimaryKeyValues(item, meta.primaryKeys, false);
+                    where[i] = Utils.getPrimaryKeyValues(item, meta.primaryKeys, false);
                 }
             });
         }
-        if (!Utils_1.Utils.isPlainObject(where) || (key && meta.properties[key]?.customType instanceof JsonType_1.JsonType)) {
+        if (!Utils.isPlainObject(where) || (key && meta.properties[key]?.customType instanceof JsonType)) {
             return false;
         }
-        if (meta.primaryKeys.every(pk => pk in where) && Utils_1.Utils.getObjectKeysSize(where) === meta.primaryKeys.length) {
-            return !!key && !enums_1.GroupOperator[key] && Object.keys(where).every(k => !Utils_1.Utils.isPlainObject(where[k]) || Object.keys(where[k]).every(v => {
-                if (Utils_1.Utils.isOperator(v, false)) {
+        if (meta.primaryKeys.every(pk => pk in where) && Utils.getObjectKeysSize(where) === meta.primaryKeys.length) {
+            return !!key && !GroupOperator[key] && key !== '$not' && Object.keys(where).every(k => !Utils.isPlainObject(where[k]) || Object.keys(where[k]).every(v => {
+                if (Utils.isOperator(v, false)) {
                     return false;
                 }
-                if (meta.properties[k].primary && [enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(meta.properties[k].kind)) {
+                if (meta.properties[k].primary && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[k].kind)) {
                     return this.inlinePrimaryKeyObjects(where[k], meta.properties[k].targetMeta, metadata, v);
                 }
                 return true;
@@ -61,7 +58,7 @@ class QueryHelper {
         Object.keys(where).forEach(k => {
             const meta2 = metadata.find(meta.properties[k]?.type) || meta;
             if (this.inlinePrimaryKeyObjects(where[k], meta2, metadata, k)) {
-                where[k] = Utils_1.Utils.getPrimaryKeyValues(where[k], meta2.primaryKeys, true);
+                where[k] = Utils.getPrimaryKeyValues(where[k], meta2.primaryKeys, true);
             }
         });
         return false;
@@ -75,27 +72,27 @@ class QueryHelper {
             QueryHelper.inlinePrimaryKeyObjects(where, meta, metadata);
         }
         if (platform.getConfig().get('ignoreUndefinedInQuery') && where && typeof where === 'object') {
-            Utils_1.Utils.dropUndefinedProperties(where);
+            Utils.dropUndefinedProperties(where);
         }
         where = QueryHelper.processParams(where) ?? {};
-        /* istanbul ignore next */
-        if (!root && Utils_1.Utils.isPrimaryKey(where)) {
+        /* v8 ignore next 3 */
+        if (!root && Utils.isPrimaryKey(where)) {
             return where;
         }
-        if (meta && Utils_1.Utils.isPrimaryKey(where, meta.compositePK)) {
-            where = { [Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
+        if (meta && Utils.isPrimaryKey(where, meta.compositePK)) {
+            where = { [Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
         if (Array.isArray(where) && root) {
-            const rootPrimaryKey = meta ? Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys) : entityName;
+            const rootPrimaryKey = meta ? Utils.getPrimaryKeyHash(meta.primaryKeys) : entityName;
             let cond = { [rootPrimaryKey]: { $in: where } };
             // @ts-ignore
             // detect tuple comparison, use `$or` in case the number of constituents don't match
-            if (meta && !where.every(c => Utils_1.Utils.isPrimaryKey(c) || (Array.isArray(c) && c.length === meta.primaryKeys.length && c.every(i => Utils_1.Utils.isPrimaryKey(i))))) {
+            if (meta && !where.every(c => Utils.isPrimaryKey(c) || (Array.isArray(c) && c.length === meta.primaryKeys.length && c.every(i => Utils.isPrimaryKey(i))))) {
                 cond = { $or: where };
             }
             return QueryHelper.processWhere({ ...options, where: cond, root: false });
         }
-        if (!Utils_1.Utils.isPlainObject(where)) {
+        if (!Utils.isPlainObject(where)) {
             return where;
         }
         return Object.keys(where).reduce((o, key) => {
@@ -103,34 +100,34 @@ class QueryHelper {
             const prop = this.findProperty(key, options);
             const keys = prop?.joinColumns?.length ?? 0;
             const composite = keys > 1;
-            if (Array.isArray(value) && value.length === 0 && RawQueryFragment_1.RawQueryFragment.isKnownFragment(key)) {
+            if (Array.isArray(value) && value.length === 0 && RawQueryFragment.isKnownFragment(key)) {
                 o[key] = value;
                 return o;
             }
-            if (key in enums_1.GroupOperator) {
+            if (key in GroupOperator) {
                 o[key] = value.map((sub) => QueryHelper.processWhere({ ...options, where: sub, root }));
                 return o;
             }
             // wrap top level operators (except platform allowed operators) with PK
-            if (Utils_1.Utils.isOperator(key) && root && meta && !platform.isAllowedTopLevelOperator(key)) {
-                const rootPrimaryKey = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+            if (Utils.isOperator(key) && root && meta && !platform.isAllowedTopLevelOperator(key)) {
+                const rootPrimaryKey = Utils.getPrimaryKeyHash(meta.primaryKeys);
                 o[rootPrimaryKey] = { [key]: QueryHelper.processWhere({ ...options, where: value, root: false }) };
                 return o;
             }
-            if (prop?.customType && convertCustomTypes && !(0, RawQueryFragment_1.isRaw)(value)) {
+            if (prop?.customType && convertCustomTypes && !isRaw(value)) {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
-            const isJsonProperty = prop?.customType instanceof JsonType_1.JsonType && Utils_1.Utils.isPlainObject(value) && !(0, RawQueryFragment_1.isRaw)(value) && Object.keys(value)[0] !== '$eq';
+            const isJsonProperty = prop?.customType instanceof JsonType && Utils.isPlainObject(value) && !isRaw(value) && Object.keys(value)[0] !== '$eq';
             if (isJsonProperty) {
                 return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
             }
-            if (Array.isArray(value) && !Utils_1.Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?') && options.type !== 'orderBy') {
+            if (Array.isArray(value) && !Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?') && options.type !== 'orderBy') {
                 // comparing single composite key - use $eq instead of $in
                 const op = composite && !value.every(v => Array.isArray(v)) ? '$eq' : '$in';
                 o[key] = { [op]: value };
                 return o;
             }
-            if (Utils_1.Utils.isPlainObject(value)) {
+            if (Utils.isPlainObject(value)) {
                 o[key] = QueryHelper.processWhere({
                     ...options,
                     where: value,
@@ -152,7 +149,7 @@ class QueryHelper {
         if (Array.isArray(options)) {
             options.forEach(filter => opts[filter] = true);
         }
-        else if (Utils_1.Utils.isPlainObject(options)) {
+        else if (Utils.isPlainObject(options)) {
             Object.keys(options).forEach(filter => opts[filter] = options[filter]);
         }
         return Object.keys(filters)
@@ -172,9 +169,9 @@ class QueryHelper {
         return filter.default || filterName in options;
     }
     static processCustomType(prop, cond, platform, key, fromQuery) {
-        if (Utils_1.Utils.isPlainObject(cond)) {
-            return Utils_1.Utils.keys(cond).reduce((o, k) => {
-                if (Utils_1.Utils.isOperator(k, true) || prop.referencedPKs?.includes(k)) {
+        if (Utils.isPlainObject(cond)) {
+            return Utils.keys(cond).reduce((o, k) => {
+                if (Utils.isOperator(k, true) || prop.referencedPKs?.includes(k)) {
                     o[k] = QueryHelper.processCustomType(prop, cond[k], platform, k, fromQuery);
                 }
                 else {
@@ -183,15 +180,15 @@ class QueryHelper {
                 return o;
             }, {});
         }
-        if (key && Utils_1.Utils.isJsonKeyOperator(key)) {
+        if (key && Utils.isJsonKeyOperator(key)) {
             return Array.isArray(cond)
                 ? platform.marshallArray(cond)
                 : cond;
         }
-        if (Array.isArray(cond) && !(key && Utils_1.Utils.isArrayOperator(key))) {
+        if (Array.isArray(cond) && !(key && Utils.isArrayOperator(key))) {
             return cond.map(v => QueryHelper.processCustomType(prop, v, platform, key, fromQuery));
         }
-        if ((0, RawQueryFragment_1.isRaw)(cond)) {
+        if (isRaw(cond)) {
             return cond;
         }
         return prop.customType.convertToDatabaseValue(cond, platform, { fromQuery, key, mode: 'query' });
@@ -200,8 +197,8 @@ class QueryHelper {
         return !!QueryHelper.SUPPORTED_OPERATORS.find(op => key === op);
     }
     static processJsonCondition(o, value, path, platform, alias) {
-        if (Utils_1.Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils_1.Utils.isOperator(k))) {
-            Utils_1.Utils.keys(value).forEach(k => {
+        if (Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils.isOperator(k))) {
+            Utils.keys(value).forEach(k => {
                 this.processJsonCondition(o, value[k], [...path, k], platform, alias);
             });
             return o;
@@ -219,7 +216,7 @@ class QueryHelper {
         if (Array.isArray(value)) {
             return typeof value[0];
         }
-        if (Utils_1.Utils.isPlainObject(value) && Object.keys(value).every(k => Utils_1.Utils.isOperator(k))) {
+        if (Utils.isPlainObject(value) && Object.keys(value).every(k => Utils.isOperator(k))) {
             return this.getValueType(Object.values(value)[0]);
         }
         return typeof value;
@@ -233,4 +230,3 @@ class QueryHelper {
         return meta?.properties[propName];
     }
 }
-exports.QueryHelper = QueryHelper;

package/utils/RawQueryFragment.d.ts

@@ -1,5 +1,5 @@
 import { inspect } from 'node:util';
-import type { AnyString, Dictionary, EntityKey } from '../typings';
+import type { AnyString, Dictionary, EntityKey } from '../typings.js';
 export declare class RawQueryFragment {
     #private;
     readonly sql: string;

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;
@@ -24,7 +17,12 @@ class RawQueryFragment {
         this.#key = `[raw]: ${this.sql} (#${RawQueryFragment.#index++})`;
     }
     as(alias) {
-        return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
+        // TODO: to be removed in v7
+        /* istanbul ignore next */
+        if (alias.startsWith('`') || alias.startsWith('"')) {
+            return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
+        }
+        return new RawQueryFragment(`${this.sql} as ??`, [...this.params, alias]);
     }
     valueOf() {
         throw new Error(`Trying to modify raw SQL fragment: '${this.sql}'`);
@@ -93,27 +91,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 +148,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 +188,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;
 }