@mikro-orm/core 7.3.0-dev.2 → 7.3.0-dev.20

package/utils/RawQueryFragment.js

@@ -1,11 +1,6 @@
 import { Utils } from './Utils.js';
-// Brand lives on the prototype so JSON payloads — whose proto is
-// `Object.prototype` — cannot forge it. String key, not a `Symbol.for(...)`,
-// so each CJS/ESM copy of this module independently installs it on its own
-// prototype without publishing a global key for the marker that controls raw
-// SQL assembly. The string is namespaced so it does not collide with property
-// names users might independently install on their own prototypes.
-const RAW_FRAGMENT_BRAND = '__mikroOrmRawFragment';
+// Prototype brand of raw fragments; `Symbol.for` so package copies agree.
+const RAW_FRAGMENT_BRAND = Symbol.for('mikro-orm.raw-fragment');
 // Back-references from a fragment's symbol key to the fragment itself, shared
 // across CJS/ESM module copies via globalThis: when one copy creates a fragment
 // via `raw('…')` and stores its symbol in a where-clause object key, the other
@@ -13,6 +8,20 @@ const RAW_FRAGMENT_BRAND = '__mikroOrmRawFragment';
 const REGISTRY_KEY = Symbol.for('@mikro-orm/core/RawQueryFragment.references');
 const rawQueryReferences = (globalThis[REGISTRY_KEY] ??=
     new WeakMap());
+/** Prototype brand of query builders usable as sub-queries; a symbol so JSON payloads cannot carry it, `Symbol.for` so package copies agree. */
+export const SUBQUERY_BRAND = Symbol.for('mikro-orm.subquery');
+function hasPrototypeBrand(value, brand) {
+    // Walk the prototype chain starting from the *prototype* (not the value) so
+    // own-property spoofing from JSON payloads cannot forge the brand. Stop at
+    // `Object.prototype`, which is never branded — that bails plain objects,
+    // JSON payloads, and built-ins like `Date`/`Array`/`Map` at depth 1.
+    for (let p = Object.getPrototypeOf(value); p != null && p !== Object.prototype; p = Object.getPrototypeOf(p)) {
+        if (Object.hasOwn(p, brand)) {
+            return true;
+        }
+    }
+    return false;
+}
 /** Checks whether the given value is a `RawQueryFragment` instance. */
 export function isRaw(value) {
     if (value == null || typeof value !== 'object') {
@@ -23,16 +32,11 @@ export function isRaw(value) {
     if (value instanceof RawQueryFragment) {
         return true;
     }
-    // Walk the prototype chain starting from the *prototype* (not the value) so
-    // own-property spoofing from JSON payloads cannot forge the brand. Stop at
-    // `Object.prototype`, which is never branded — that bails plain objects,
-    // JSON payloads, and built-ins like `Date`/`Array`/`Map` at depth 1.
-    for (let p = Object.getPrototypeOf(value); p != null && p !== Object.prototype; p = Object.getPrototypeOf(p)) {
-        if (Object.hasOwn(p, RAW_FRAGMENT_BRAND)) {
-            return true;
-        }
-    }
-    return false;
+    return hasPrototypeBrand(value, RAW_FRAGMENT_BRAND);
+}
+/** Checks whether the given value is a query builder usable as a sub-query (its prototype carries the `SUBQUERY_BRAND`). */
+export function isSubquery(value) {
+    return value != null && typeof value === 'object' && hasPrototypeBrand(value, SUBQUERY_BRAND);
 }
 /** Represents a raw SQL fragment with optional parameters, usable as both a value and an object key via Symbol coercion. */
 export class RawQueryFragment {
@@ -121,6 +125,10 @@ export { RawQueryFragment as Raw };
 export const ALIAS_REPLACEMENT = '[::alias::]';
 /** @internal */
 export const ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
+// a query builder param is embedded as a sub-query instead of being bound as a value
+function toRawParam(param) {
+    return isSubquery(param) ? param.toRaw() : param;
+}
 /**
  * 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
@@ -204,12 +212,12 @@ export function raw(sql, params) {
             if (!Object.hasOwn(dict, key)) {
                 return match;
             }
-            objectParams.push(dict[key]);
+            objectParams.push(toRawParam(dict[key]));
             return identifier ? '??' : '?';
         });
         return new RawQueryFragment(sql, objectParams);
     }
-    return new RawQueryFragment(sql, params);
+    return new RawQueryFragment(sql, params?.map(toRawParam));
 }
 /**
  * Alternative to the `raw()` helper allowing to use it as a tagged template function for the simple cases.

package/utils/TransactionManager.js

@@ -189,6 +189,10 @@ export class TransactionManager {
                 if (wrapped.__originalEntityData) {
                     parentWrapped.__originalEntityData = originalEntityData;
                 }
+                // index a merged `targetKey` value, `getByKey` ignores the old one as stale
+                if (meta.root.targetKeys) {
+                    parentUoW.getIdentityMap().store(parentEntity);
+                }
             }
             else {
                 parentUoW.merge(entity, new Set([entity]));

package/utils/Utils.d.ts

@@ -175,6 +175,8 @@ export declare class Utils {
     static getORMVersion(): string;
     static createFunction(context: Map<string, any>, code: string, compiledFunctions?: CompiledFunctions, key?: string): any;
     static callCompiledFunction<T extends unknown[], R>(fn: (...args: T) => R, ...args: T): R;
+    /** @internal Same-named properties of polymorphic embeddable variants conflict when their kinds differ, to-one kinds share the column. */
+    static isSameKind(a: EntityProperty, b: EntityProperty): boolean;
     static unwrapProperty<T>(entity: T, meta: EntityMetadata<T>, prop: EntityProperty<T>, payload?: boolean): [unknown, number[]][];
     static setPayloadProperty<T>(entity: EntityDictionary<T>, meta: EntityMetadata<T>, prop: EntityProperty<T>, value: unknown, idx: number[]): void;
     static tryImport<T extends Dictionary = any>({ module, warning, }: {

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.3.0-dev.2';
+    static #ORM_VERSION = '7.3.0-dev.20';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;
@@ -244,7 +244,7 @@ export class Utils {
     /**
      * Merges all sources into the target recursively.
      */
-    static _merge(target, sources, ignoreUndefined) {
+    static _merge(target, sources, ignoreUndefined, copies) {
         if (!sources.length) {
             return target;
         }
@@ -259,7 +259,13 @@ export class Utils {
                 }
                 if (Utils.isPlainObject(value)) {
                     if (!Utils.isObject(target[key])) {
-                        target[key] = Utils.copy(value);
+                        // copy plain objects but keep class instances by reference, tracking copies so cycles terminate
+                        const seen = copies ?? new WeakMap();
+                        if (!seen.has(value)) {
+                            seen.set(value, {});
+                            Utils._merge(seen.get(value), [value], ignoreUndefined, seen);
+                        }
+                        target[key] = seen.get(value);
                         continue;
                     }
                     /* v8 ignore next */
@@ -651,14 +657,19 @@ export class Utils {
     static isCollection(item) {
         return Collection.isCollection(item);
     }
-    // FNV-1a 64-bit
+    // FNV-1a 64-bit, computed on two uint32 halves instead of a BigInt. The prime is 2^40 + 0x1b3, so
+    // `h * prime mod 2^64` is `h * 0x1b3` plus the low half shifted up by 40 bits. Every partial product
+    // stays below 2^41, so the double arithmetic is exact.
     static hash(data, length) {
-        let h1 = 0xcbf29ce484222325n;
+        let hi = 0xcbf29ce4;
+        let lo = 0x84222325;
         for (let i = 0; i < data.length; i++) {
-            h1 ^= BigInt(data.charCodeAt(i));
-            h1 = (h1 * 0x100000001b3n) & 0xffffffffffffffffn;
+            lo = (lo ^ data.charCodeAt(i)) >>> 0;
+            const loProduct = lo * 0x1b3;
+            hi = (((hi * 0x1b3) >>> 0) + Math.floor(loProduct / 0x100000000) + ((lo << 8) >>> 0)) >>> 0;
+            lo = loProduct >>> 0;
         }
-        const hash = h1.toString(16).padStart(16, '0');
+        const hash = hi.toString(16).padStart(8, '0') + lo.toString(16).padStart(8, '0');
         if (length) {
             return hash.substring(0, length);
         }
@@ -775,6 +786,11 @@ export class Utils {
             throw e;
         }
     }
+    /** @internal Same-named properties of polymorphic embeddable variants conflict when their kinds differ, to-one kinds share the column. */
+    static isSameKind(a, b) {
+        const toOne = (p) => p.kind === ReferenceKind.MANY_TO_ONE || p.kind === ReferenceKind.ONE_TO_ONE;
+        return a.kind === b.kind || (toOne(a) && toOne(b));
+    }
     static unwrapProperty(entity, meta, prop, payload = false) {
         let p = prop;
         const path = [];

package/utils/clone.js

@@ -22,8 +22,8 @@ function getPropertyDescriptor(obj, prop) {
 }
 const TypedArray = Object.getPrototypeOf(Uint8Array);
 export function clone(parent, respectCustomCloneMethod = true) {
-    const allParents = [];
-    const allChildren = [];
+    // already cloned objects, so shared references and cycles map to a single clone
+    const clones = new Map();
     function _clone(parent) {
         // cloning null always returns null
         if (parent === null) {
@@ -92,12 +92,10 @@ export function clone(parent, respectCustomCloneMethod = true) {
             proto = Object.getPrototypeOf(parent);
             child = Object.create(proto);
         }
-        const index = allParents.indexOf(parent);
-        if (index !== -1) {
-            return allChildren[index];
+        if (clones.has(parent)) {
+            return clones.get(parent);
         }
-        allParents.push(parent);
-        allChildren.push(child);
+        clones.set(parent, child);
         if (parent instanceof Map) {
             parent.forEach((value, key) => {
                 const keyChild = _clone(key);

package/utils/env-vars.js

@@ -74,6 +74,8 @@ export function loadEnvironmentVars() {
     read2('transactional', bool);
     read2('disableForeignKeys', bool);
     read2('allOrNothing', bool);
+    read2('lock', bool);
+    read2('lockTimeout', num);
     read2('dropTables', bool);
     read2('safe', bool);
     read2('silent', bool);

package/utils/fs-utils.js

@@ -5,7 +5,8 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { Utils } from './Utils.js';
 import { colors } from '../logging/colors.js';
 let globSync = (patterns, options) => {
-    const files = nodeGlobSync(patterns, { ...options, withFileTypes: true });
+    const cwd = options?.dir ? join(options.cwd ?? '', options.dir) : options?.cwd;
+    const files = nodeGlobSync(patterns, { cwd, withFileTypes: true });
     return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
 };
 export const fs = {
@@ -13,7 +14,8 @@ export const fs = {
         const tinyGlobby = await import('tinyglobby').catch(() => null);
         if (tinyGlobby) {
             globSync = (patterns, options) => {
-                patterns = Utils.asArray(patterns).map(p => p.replace(/\\/g, '/'));
+                const dir = options?.dir ? tinyGlobby.escapePath(options.dir.replace(/\\/g, '/')) + '/' : '';
+                patterns = Utils.asArray(patterns).map(p => dir + p.replace(/\\/g, '/'));
                 // never forward `cwd: undefined` — tinyglobby >= 0.2.16 calls `path.resolve(undefined)` and throws
                 return tinyGlobby.globSync(patterns, {
                     expandDirectories: false,
@@ -23,10 +25,10 @@ export const fs = {
         }
     },
     pathExists(path) {
-        if (/[*?[\]]/.test(path)) {
-            return globSync(path).length > 0;
+        if (existsSync(path)) {
+            return true;
         }
-        return existsSync(path);
+        return /[*?[\]]/.test(path) && this.resolveGlob(path).length > 0;
     },
     ensureDir(path) {
         if (!existsSync(path)) {
@@ -62,18 +64,20 @@ export const fs = {
         if (Array.isArray(input)) {
             return input.flatMap(paths => this.resolveGlob(paths, cwd));
         }
-        const hasGlobChars = /[*?[\]]/.test(input);
-        if (!hasGlobChars) {
-            try {
-                const s = statSync(cwd ? this.normalizePath(cwd, input) : input);
-                if (s.isDirectory()) {
-                    return globSync(join(input, '**'), { cwd });
-                }
-            }
-            catch {
-                // ignore
+        // an absolute path repeats the cwd, which may contain glob characters (e.g. `~/Dropbox (Team)/app`)
+        if (isAbsolute(input)) {
+            cwd ??= process.cwd();
+            input = relative(cwd, input).replace(/\\/g, '/') || '.';
+        }
+        try {
+            const s = statSync(cwd ? this.normalizePath(cwd, input) : input);
+            if (s.isDirectory()) {
+                return globSync('**', { cwd, dir: input });
             }
         }
+        catch {
+            // ignore
+        }
         return globSync(input, { cwd });
     },
     getPackageConfig(basePath = process.cwd()) {

package/utils/upsert-utils.js

@@ -103,7 +103,8 @@ export function getOnConflictReturningFields(meta, data, uniqueFields, options,
         if (p.lazy || p.embeddable) {
             return false;
         }
-        if (p.autoincrement) {
+        // a PK missing in the data is generated by the database
+        if (p.autoincrement || (p.primary && data[p.name] == null)) {
             return true;
         }
         // for a raw `onConflictFields` fragment we can't introspect which columns form the conflict