@mikro-orm/core 7.3.0-dev.17 → 7.3.0-dev.18

package/unit-of-work/ChangeSetPersister.js

@@ -196,10 +196,17 @@ export class ChangeSetPersister {
     }
     async persistManagedEntities(meta, changeSets, options) {
         const size = this.#config.get('batchSize');
-        for (let i = 0; i < changeSets.length; i += size) {
-            const chunk = changeSets.slice(i, i + size);
-            await this.persistManagedEntitiesBatch(meta, chunk, options);
-            await this.reloadVersionValues(meta, chunk, options);
+        // a batch checks the version in all rows or none, so references without a loaded version go separately
+        const hasVersion = (cs) => cs.entity[meta.versionProperty] != null;
+        const groups = meta.ownsVersionProperty()
+            ? [changeSets.filter(hasVersion), changeSets.filter(cs => !hasVersion(cs))]
+            : [changeSets];
+        for (const group of groups) {
+            for (let i = 0; i < group.length; i += size) {
+                const chunk = group.slice(i, i + size);
+                await this.persistManagedEntitiesBatch(meta, chunk, options);
+                await this.reloadVersionValues(meta, chunk, options);
+            }
         }
     }
     checkConcurrencyKeys(meta, changeSet, cond) {
@@ -223,9 +230,14 @@ export class ChangeSetPersister {
         });
         const cond = [];
         const payload = [];
+        // like in `updateEntity()`, but the batch needs the version in all rows or none
+        const versioned = meta.ownsVersionProperty() && changeSets.every(cs => cs.entity[meta.versionProperty] != null);
         for (const changeSet of changeSets) {
             const where = changeSet.getPrimaryKey(true);
             this.checkConcurrencyKeys(meta, changeSet, where);
+            if (versioned) {
+                where[meta.versionProperty] = this.#platform.convertVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
+            }
             cond.push(where);
             payload.push(changeSet.payload);
         }
@@ -235,6 +247,12 @@ export class ChangeSetPersister {
         // from those to be able to match them with `getSerializedPrimaryKey()` of the entity
         const pkFields = meta.getPrimaryProps().flatMap(prop => prop.fieldNames);
         res.rows?.forEach(item => map.set(Utils.getPrimaryKeyHash(pkFields.map(field => item[field])), item));
+        if ((meta.ownsVersionProperty() || meta.getOwnConcurrencyCheckKeys().length > 0) &&
+            res.affectedRows < changeSets.length) {
+            // without `returning`, the stale entity can't be identified, so we report the first one
+            const failed = changeSets.find(cs => !map.has(helper(cs.entity).getSerializedPrimaryKey())) ?? changeSets[0];
+            throw OptimisticLockError.lockFailed(failed.entity);
+        }
         for (const changeSet of changeSets) {
             if (res.rows) {
                 const row = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
@@ -484,7 +502,8 @@ export class ChangeSetPersister {
         }
         if (upsert) {
             for (const prop of meta.props) {
-                if (prop.customType && prop.name in mapped) {
+                // null is not converted, the same way the hydrator handles it
+                if (prop.customType && mapped[prop.name] != null) {
                     mapped[prop.name] = prop.customType.convertToJSValue(mapped[prop.name], this.#platform);
                 }
             }

package/unit-of-work/CommitOrderCalculator.js

@@ -44,7 +44,8 @@ export class CommitOrderCalculator {
         if (!toOneOwner && !toManyOwner) {
             return;
         }
-        const propertyType = prop.targetMeta?.root._id;
+        // TPT tables are separate nodes and the FK references the target's own table, not the root
+        const propertyType = (prop.targetMeta?.inheritanceType === 'tpt' ? prop.targetMeta : prop.targetMeta?.root)?._id;
         if (propertyType == null || !this.hasNode(propertyType)) {
             return;
         }

package/unit-of-work/UnitOfWork.js

@@ -600,19 +600,27 @@ export class UnitOfWork {
                 this.findEarlyUpdates(cs, inserts[cs.meta.uniqueName]);
             }
         }
+        // hashes of the inserts' PKs and unique values per type, built lazily, so matching a removed entity is a set lookup
+        const insertHashes = {};
         for (const entity of this.#removeStack) {
             const wrapped = helper(entity);
             /* v8 ignore next */
             if (wrapped.__processing) {
                 continue;
             }
-            const deletePkHash = [wrapped.getSerializedPrimaryKey(), ...this.expandUniqueProps(entity)];
-            let type = ChangeSetType.DELETE;
-            for (const cs of inserts[wrapped.__meta.uniqueName] ?? []) {
-                if (deletePkHash.some(hash => hash === cs.getSerializedPrimaryKey() || this.expandUniqueProps(cs.entity).find(child => hash === child))) {
-                    type = ChangeSetType.DELETE_EARLY;
+            const uniqueName = wrapped.__meta.uniqueName;
+            let hashes = insertHashes[uniqueName];
+            if (!hashes) {
+                hashes = insertHashes[uniqueName] = new Set();
+                for (const cs of inserts[uniqueName] ?? []) {
+                    hashes.add(cs.getSerializedPrimaryKey());
+                    for (const hash of this.expandUniqueProps(cs.entity)) {
+                        hashes.add(hash);
+                    }
                 }
             }
+            const deletePkHash = [wrapped.getSerializedPrimaryKey(), ...this.expandUniqueProps(entity)];
+            const type = deletePkHash.some(hash => hashes.has(hash)) ? ChangeSetType.DELETE_EARLY : ChangeSetType.DELETE;
             this.computeChangeSet(entity, type);
         }
     }
@@ -1283,6 +1291,13 @@ export class UnitOfWork {
                         calc.discoverProperty({ ...prop, targetMeta }, meta._id);
                     }
                 }
+                else if (prop.targetMeta?.inheritanceType === 'tpt') {
+                    calc.discoverProperty(prop, meta._id);
+                    // a TPT subclass delete has only a leaf change set that also removes the target row; weak edge so it can't break insert order
+                    for (const targetMeta of this.#metadata.find(prop.targetMeta.class).allTPTDescendants ?? []) {
+                        calc.discoverProperty({ ...prop, targetMeta, nullable: true }, meta._id);
+                    }
+                }
                 else {
                     calc.discoverProperty(prop, meta._id);
                 }

package/utils/EntityComparator.d.ts

@@ -19,6 +19,11 @@ export declare class EntityComparator {
     diffEntities<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>, options?: {
         includeInverseSides?: boolean;
     }): EntityData<T>;
+    /**
+     * Returns true if the comparator checks this property with `!==`, so matching values are identical primitives.
+     * @internal
+     */
+    isStrictlyCompared<T>(prop: EntityProperty<T>): boolean;
     /** Returns true if two entity snapshots are identical (no differences). */
     matching<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>): boolean;
     /**

package/utils/EntityComparator.js

@@ -1,6 +1,7 @@
 import { clone } from './clone.js';
 import { ReferenceKind } from '../enums.js';
 import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils, } from './Utils.js';
+import { DateType } from '../types/DateType.js';
 import { JsonType } from '../types/JsonType.js';
 import { Raw } from './RawQueryFragment.js';
 import { EntityIdentifier } from '../entity/EntityIdentifier.js';
@@ -29,6 +30,17 @@ export class EntityComparator {
         const comparator = this.getEntityComparator(entityName);
         return Utils.callCompiledFunction(comparator, a, b, options);
     }
+    /**
+     * Returns true if the comparator checks this property with `!==`, so matching values are identical primitives.
+     * @internal
+     */
+    isStrictlyCompared(prop) {
+        if (prop.kind !== ReferenceKind.SCALAR || prop.customType?.compareValues) {
+            return false;
+        }
+        const type = (prop.customType ? prop.customType.compareAsType() : prop.type).toLowerCase();
+        return ['string', 'number', 'bigint'].includes(type);
+    }
     /** Returns true if two entity snapshots are identical (no differences). */
     matching(entityName, a, b) {
         const diff = this.diffEntities(entityName, a, b);
@@ -355,8 +367,16 @@ export class EntityComparator {
                 if (prop.renamedFrom) {
                     lines.push(`${padding}  ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     defined = `${this.propName(prop.fieldNames[0])} != null`;
-                    // a column shared with a differently typed subtype is left for each subtype's hydrator to convert
-                    if (meta.props.some(p => p !== prop && p.name === prop.name && p.fieldNames?.[0] === prop.fieldNames[0])) {
+                    const sharesColumn = meta.props.some(p => p !== prop && p.name === prop.name && p.fieldNames?.[0] === prop.fieldNames[0]);
+                    // hydrators expect mapped embeddable keys, so a shared object embeddable is mapped only for its own subtypes
+                    if (sharesColumn && prop.kind === ReferenceKind.EMBEDDED && prop.object && meta.discriminatorMap) {
+                        const owners = Object.entries(meta.discriminatorMap)
+                            .filter(([, cls]) => this.#metadata.find(cls)?.properties[prop.name]?.targetMeta === prop.targetMeta)
+                            .map(([value]) => `${this.propName(meta.discriminatorColumn)} == ${JSON.stringify(value)}`);
+                        defined += ` && (${owners.join(' || ')})`;
+                    }
+                    else if (sharesColumn) {
+                        // a column shared with a differently typed subtype is left for each subtype's hydrator to convert
                         lines.push(`${padding}  if (${defined}) {`);
                         lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])};`);
                         lines.push(`${padding}  }`);
@@ -376,6 +396,14 @@ export class EntityComparator {
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     lines.push(`${padding}  }`);
                 }
+                else if (prop.customType instanceof DateType) {
+                    // tedious returns DATE columns as `Date`, map them to the string the entity holds, so the snapshot matches it
+                    context.set('convertDateToJSValue', (value) => this.#platform.convertDateToJSValue(value));
+                    lines.push(`${padding}  if (${defined}) {`);
+                    lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} instanceof Date ? convertDateToJSValue(${this.propName(prop.fieldNames[0])}) : ${this.propName(prop.fieldNames[0])};`);
+                    lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
+                    lines.push(`${padding}  }`);
+                }
                 else if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
                     const idx = this.#tmpIndex++;
                     context.set(`mapEmbeddedResult_${idx}`, (data) => {
@@ -512,11 +540,22 @@ export class EntityComparator {
             }
             return true;
         }
+        // a same-named property of a different kind in another polymorphic variant applies only to its own variants
+        const guard = (childProp, code) => {
+            const variants = prop.targetMeta?.polymorphs?.filter(m => m.properties[childProp.embedded[1]]) ?? [];
+            const owners = variants.filter(m => Utils.isSameKind(m.properties[childProp.embedded[1]], childProp));
+            if (owners.length === variants.length) {
+                return code;
+            }
+            const discriminator = `entity${[...path, prop.targetMeta.discriminatorColumn].map(k => this.wrap(k)).join('')}`;
+            const conds = owners.map(m => `${discriminator} == ${JSON.stringify(m.discriminatorValue)}`);
+            return `${padding}  if (${conds.join(' || ')}) {\n${code}\n${padding}  }`;
+        };
+        const childProps = meta.props.filter(p => p.embedded?.[0] === prop.name &&
+            // object for JSON embeddable
+            (p.object || p.persist !== false));
         ret +=
-            meta.props
-                .filter(p => p.embedded?.[0] === prop.name &&
-                // object for JSON embeddable
-                (p.object || p.persist !== false))
+            childProps
                 .map(childProp => {
                 const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
                 const childEntityKey = [...path, childProp.embedded[1]].map(k => this.wrap(k)).join('');
@@ -539,6 +578,7 @@ export class EntityComparator {
                 }
                 return `${padding}  if (${childCond}) ret${childDataKey} = clone(entity${childEntityKey});`;
             })
+                .map((code, i) => guard(childProps[i], code))
                 .join('\n') + `\n`;
         if (this.shouldSerialize(prop, dataKey)) {
             return `${ret + padding}  ret${dataKey} = cloneEmbeddable(ret${dataKey});\n${padding}}`;

package/utils/QueryHelper.js

@@ -3,7 +3,7 @@ import { DANGEROUS_PROPERTY_NAMES, Utils } from './Utils.js';
 import { ARRAY_OPERATORS, GroupOperator, JSON_KEY_OPERATORS, ReferenceKind } from '../enums.js';
 import { JsonType } from '../types/JsonType.js';
 import { helper } from '../entity/wrap.js';
-import { isRaw, Raw } from './RawQueryFragment.js';
+import { isRaw, isSubquery, Raw } from './RawQueryFragment.js';
 import { MetadataError, ValidationError } from '../errors.js';
 /** @internal */
 export class QueryHelper {
@@ -313,6 +313,13 @@ export class QueryHelper {
                 o[key] = { [op]: value };
                 return o;
             }
+            // `$all` items are matched like separate `$some` payloads, so they need the same processing
+            if (key === '$all' && Array.isArray(value)) {
+                o[key] = value.map(item => Utils.isPlainObject(item)
+                    ? QueryHelper.processWhere({ ...options, where: item, entityName, root: false })
+                    : item);
+                return o;
+            }
             if (Utils.isPlainObject(value)) {
                 const targetMeta = customExpression ? undefined : QueryHelper.findTargetMeta(prop, key);
                 o[key] = QueryHelper.processWhere({
@@ -546,7 +553,8 @@ export class QueryHelper {
         if (Array.isArray(cond) && !(key && ARRAY_OPERATORS.includes(key))) {
             return cond.map(v => QueryHelper.processCustomType(prop, v, platform, key, fromQuery));
         }
-        if (isRaw(cond)) {
+        // a query builder renders as a sub-query, not as a value of the property type
+        if (isRaw(cond) || isSubquery(cond)) {
             return cond;
         }
         return prop.customType.convertToDatabaseValue(cond, platform, { fromQuery, key, mode: 'query' });

package/utils/RawQueryFragment.d.ts

@@ -1,11 +1,15 @@
-import type { AnyString, Dictionary, EntityKey } from '../typings.js';
+import type { AnyString, Dictionary, EntityKey, Subquery } from '../typings.js';
 declare const rawFragmentSymbolBrand: unique symbol;
 /** Branded symbol type used as a unique key for tracking raw SQL fragments in object properties. */
 export type RawQueryFragmentSymbol = symbol & {
     readonly [rawFragmentSymbolBrand]: true;
 };
+/** Prototype brand of query builders usable as sub-queries; a symbol so JSON payloads cannot carry it, `Symbol.for` so package copies agree. */
+export declare const SUBQUERY_BRAND: unique symbol;
 /** Checks whether the given value is a `RawQueryFragment` instance. */
 export declare function isRaw(value: unknown): value is RawQueryFragment;
+/** Checks whether the given value is a query builder usable as a sub-query (its prototype carries the `SUBQUERY_BRAND`). */
+export declare function isSubquery(value: unknown): value is Subquery;
 /** Represents a raw SQL fragment with optional parameters, usable as both a value and an object key via Symbol coercion. */
 export declare class RawQueryFragment<Alias extends string = string> {
     #private;

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/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.17';
+    static #ORM_VERSION = '7.3.0-dev.18';
     /** 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/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