@mikro-orm/core 7.0.0-dev.5 → 7.0.0-dev.50

package/utils/Utils.js

@@ -1,7 +1,6 @@
 import { createRequire } from 'node:module';
-import globby from 'globby';
+import { glob, isDynamicPattern } from 'tinyglobby';
 import { extname, isAbsolute, join, normalize, relative, resolve } from 'node:path';
-import { platform } from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
@@ -435,7 +434,11 @@ export class Utils {
             return data;
         }
         if (Utils.isEntity(data, true)) {
-            return helper(data).getPrimaryKey();
+            const wrapped = helper(data);
+            if (wrapped.__meta.compositePK) {
+                return wrapped.getPrimaryKeys();
+            }
+            return wrapped.getPrimaryKey();
         }
         if (strict && meta && Utils.getObjectKeysSize(data) !== meta.primaryKeys.length) {
             return null;
@@ -483,6 +486,7 @@ export class Utils {
     static splitPrimaryKeys(key) {
         return key.split(this.PK_SEPARATOR);
     }
+    // TODO v7: remove support for `primaryKeys: string[]`
     static getPrimaryKeyValues(entity, primaryKeys, allowScalar = false, convertCustomTypes = false) {
         /* v8 ignore next 3 */
         if (entity == null) {
@@ -494,9 +498,24 @@ export class Utils {
             }
             return val;
         }
-        const pk = Utils.isEntity(entity, true)
-            ? helper(entity).getPrimaryKey(convertCustomTypes)
-            : primaryKeys.reduce((o, pk) => { o[pk] = entity[pk]; return o; }, {});
+        const meta = Array.isArray(primaryKeys) ? undefined : primaryKeys;
+        primaryKeys = Array.isArray(primaryKeys) ? primaryKeys : meta.primaryKeys;
+        let pk;
+        if (Utils.isEntity(entity, true)) {
+            pk = helper(entity).getPrimaryKey(convertCustomTypes);
+        }
+        else {
+            pk = primaryKeys.reduce((o, pk) => {
+                const targetMeta = meta?.properties[pk].targetMeta;
+                if (targetMeta && Utils.isPlainObject(entity[pk])) {
+                    o[pk] = Utils.getPrimaryKeyValues(entity[pk], targetMeta, allowScalar, convertCustomTypes);
+                }
+                else {
+                    o[pk] = entity[pk];
+                }
+                return o;
+            }, {});
+        }
         if (primaryKeys.length > 1) {
             return toArray(pk);
         }
@@ -546,7 +565,7 @@ export class Utils {
             return o;
         }, {});
     }
-    static getOrderedPrimaryKeys(id, meta, platform, convertCustomTypes = false) {
+    static getOrderedPrimaryKeys(id, meta, platform, convertCustomTypes = false, allowScalar = false) {
         const data = (Utils.isPrimaryKey(id) ? { [meta.primaryKeys[0]]: id } : id);
         const pks = meta.primaryKeys.map((pk, idx) => {
             const prop = meta.properties[pk];
@@ -556,11 +575,14 @@ export class Utils {
                 value = prop.customType.convertToJSValue(value, platform);
             }
             if (prop.kind !== ReferenceKind.SCALAR && prop.targetMeta) {
-                const value2 = this.getOrderedPrimaryKeys(value, prop.targetMeta, platform, convertCustomTypes);
+                const value2 = this.getOrderedPrimaryKeys(value, prop.targetMeta, platform, convertCustomTypes, allowScalar);
                 value = value2.length > 1 ? value2 : value2[0];
             }
             return value;
         });
+        if (allowScalar && pks.length === 1) {
+            return pks[0];
+        }
         // we need to flatten the PKs as composite PKs can be build from another composite PKs
         // and this method is used to get the PK hash in identity map, that expects flat array
         return Utils.flatten(pks);
@@ -625,8 +647,12 @@ export class Utils {
             || !!process.env.TS_JEST // check if ts-jest is used (works only with v27.0.4+)
             || !!process.env.VITEST // check if vitest is used
             || !!process.versions.bun // check if bun is used
-            || process.argv.slice(1).some(arg => arg.includes('ts-node')) // registering ts-node runner
-            || process.execArgv.some(arg => arg === 'ts-node/esm'); // check for ts-node/esm module loader
+            || process.argv.slice(1).some(arg => arg.match(/\.([mc]?ts|tsx)$/)) // executing `.ts` file
+            || process.execArgv.some(arg => {
+                return arg.includes('ts-node') // check for ts-node loader
+                    || arg.includes('@swc-node/register') // check for swc-node/register loader
+                    || arg.includes('node_modules/tsx/'); // check for tsx loader
+            });
     }
     /**
      * Uses some dark magic to get source path to caller where decorator is used.
@@ -644,7 +670,8 @@ export class Utils {
         // but those are also present in node, so we need to check this only if they weren't found.
         if (line === -1) {
             // here we handle bun which stack is different from nodejs so we search for reflect-metadata
-            const reflectLine = stack.findIndex(line => Utils.normalizePath(line).includes('node_modules/reflect-metadata/Reflect.js'));
+            // Different bun versions might have different stack traces. The "last index" works for both 1.2.6 and 1.2.7.
+            const reflectLine = stack.findLastIndex(line => Utils.normalizePath(line).includes('node_modules/reflect-metadata/Reflect.js'));
             if (reflectLine === -1 || reflectLine + 2 >= stack.length || !stack[reflectLine + 1].includes('bun:wrap')) {
                 return name;
             }
@@ -673,11 +700,11 @@ export class Utils {
             return simple;
         }
         const objectType = Object.prototype.toString.call(value);
-        const type = objectType.match(/\[object (\w+)]/)[1];
+        const type = objectType.match(/^\[object (.+)]$/)[1];
         if (type === 'Uint8Array') {
             return 'Buffer';
         }
-        return ['Date', 'Buffer', 'RegExp'].includes(type) ? type : type.toLowerCase();
+        return type;
     }
     /**
      * Checks whether the value is POJO (e.g. `{ foo: 'bar' }`, and not instance of `Foo`)
@@ -761,8 +788,9 @@ export class Utils {
         }
         return Utils.normalizePath(path);
     }
-    static hash(data, length) {
-        const hash = createHash('md5').update(data).digest('hex');
+    static hash(data, length, algorithm) {
+        const hashAlgorithm = algorithm || 'sha256';
+        const hash = createHash(hashAlgorithm).update(data).digest('hex');
         if (length) {
             return hash.substring(0, length);
         }
@@ -795,8 +823,8 @@ export class Utils {
         return Math.round(Math.random() * (max - min)) + min;
     }
     static async pathExists(path, options = {}) {
-        if (globby.hasMagic(path)) {
-            const found = await globby(path, options);
+        if (isDynamicPattern(path)) {
+            const found = await glob(path, options);
             return found.length > 0;
         }
         return this.pathExistsSync(path);
@@ -863,18 +891,25 @@ export class Utils {
         }
         return createRequire(resolve(from))(id);
     }
-    static async dynamicImport(id) {
-        /* v8 ignore next 7 */
-        if (platform() === 'win32') {
-            try {
-                id = pathToFileURL(id).toString();
-            }
-            catch {
-                // ignore
-            }
+    /**
+     * Resolve path to a module.
+     * @param id The module to require
+     * @param [from] Location to start the node resolution
+     */
+    static resolveModulePath(id, from = process.cwd()) {
+        if (!extname(from)) {
+            from = join(from, '__fake.js');
         }
+        const path = Utils.normalizePath(createRequire(resolve(from)).resolve(id));
+        const parts = path.split('/');
+        const idx = parts.lastIndexOf(id) + 1;
+        parts.splice(idx, parts.length - idx);
+        return parts.join('/');
+    }
+    static async dynamicImport(id) {
         /* v8 ignore next */
-        return this.dynamicImportProvider(id);
+        const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;
+        return this.dynamicImportProvider(specifier);
     }
     /* v8 ignore next 3 */
     static setDynamicImportProvider(provider) {
@@ -899,8 +934,13 @@ export class Utils {
             /* v8 ignore next 5 */
         }
         catch {
-            // this works in production build where we do not have the `src` folder
-            return this.requireFrom('../package.json', import.meta.dirname).version;
+            try {
+                // this works in production build where we do not have the `src` folder
+                return this.requireFrom('../package.json', import.meta.dirname).version;
+            }
+            catch {
+                return 'N/A';
+            }
         }
     }
     static createFunction(context, code) {
@@ -1035,8 +1075,10 @@ export class Utils {
         }
         catch (err) {
             if (err.message.includes(allowError)) {
-                // eslint-disable-next-line no-console
-                console.warn(warning);
+                if (warning) {
+                    // eslint-disable-next-line no-console
+                    console.warn(warning);
+                }
                 return undefined;
             }
             throw err;
@@ -1044,37 +1086,22 @@ export class Utils {
     }
     static async tryImport({ module, warning }) {
         try {
-            return await this.dynamicImport(module);
+            return await import(module);
         }
         catch (err) {
-            // eslint-disable-next-line no-console
-            console.warn(warning);
-            return undefined;
+            if (err.code === 'ERR_MODULE_NOT_FOUND') {
+                if (warning) {
+                    // eslint-disable-next-line no-console
+                    console.warn(warning);
+                }
+                return undefined;
+            }
+            throw err;
         }
     }
     static stripRelativePath(str) {
         return str.replace(/^(?:\.\.\/|\.\/)+/, '/');
     }
-    /**
-     * simple process.argv parser, supports only properties with long names, prefixed with `--`
-     */
-    static parseArgs() {
-        let lastKey;
-        return process.argv.slice(2).reduce((args, arg) => {
-            if (arg.includes('=')) {
-                const [key, value] = arg.split('=');
-                args[key.substring(2)] = value;
-            }
-            else if (lastKey) {
-                args[lastKey] = arg;
-                lastKey = undefined;
-            }
-            else if (arg.startsWith('--')) {
-                lastKey = arg.substring(2);
-            }
-            return args;
-        }, {});
-    }
     static xor(a, b) {
         return (a || b) && !(a && b);
     }

package/utils/index.d.ts

@@ -5,6 +5,7 @@ export * from './DataloaderUtils.js';
 export * from './Utils.js';
 export * from './RequestContext.js';
 export * from './TransactionContext.js';
+export * from './TransactionManager.js';
 export * from './QueryHelper.js';
 export * from './NullHighlighter.js';
 export * from './EntityComparator.js';

package/utils/index.js

@@ -5,6 +5,7 @@ export * from './DataloaderUtils.js';
 export * from './Utils.js';
 export * from './RequestContext.js';
 export * from './TransactionContext.js';
+export * from './TransactionManager.js';
 export * from './QueryHelper.js';
 export * from './NullHighlighter.js';
 export * from './EntityComparator.js';

package/utils/upsert-utils.d.ts

@@ -1,7 +1,12 @@
-import type { EntityData, EntityMetadata } from '../typings.js';
+import type { EntityData, EntityMetadata, FilterQuery } from '../typings.js';
 import type { UpsertOptions } from '../drivers/IDatabaseDriver.js';
-import type { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { type RawQueryFragment } from '../utils/RawQueryFragment.js';
 /** @internal */
 export declare function getOnConflictFields<T>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | RawQueryFragment, options: UpsertOptions<T>): (keyof T)[];
 /** @internal */
 export declare function getOnConflictReturningFields<T, P extends string>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | RawQueryFragment, options: UpsertOptions<T, P>): (keyof T)[] | '*';
+/** @internal */
+export declare function getWhereCondition<T extends object>(meta: EntityMetadata<T>, onConflictFields: (keyof T)[] | RawQueryFragment | undefined, data: EntityData<T>, where: FilterQuery<T>): {
+    where: FilterQuery<T>;
+    propIndex: number | false;
+};

package/utils/upsert-utils.js

@@ -1,3 +1,5 @@
+import { isRaw } from '../utils/RawQueryFragment.js';
+import { Utils } from './Utils.js';
 function expandEmbeddedProperties(prop, key) {
     if (prop.object) {
         return [prop.name];
@@ -71,7 +73,15 @@ export function getOnConflictReturningFields(meta, data, uniqueFields, options)
     if (!meta) {
         return '*';
     }
-    const keys = meta.comparableProps.filter(p => !p.lazy && !p.embeddable && Array.isArray(uniqueFields) && !uniqueFields.includes(p.name)).map(p => p.name);
+    const keys = meta.comparableProps.filter(p => {
+        if (p.lazy || p.embeddable) {
+            return false;
+        }
+        if (p.autoincrement) {
+            return true;
+        }
+        return Array.isArray(uniqueFields) && !uniqueFields.includes(p.name);
+    }).map(p => p.name);
     if (meta.versionProperty) {
         keys.push(meta.versionProperty);
     }
@@ -88,3 +98,44 @@ export function getOnConflictReturningFields(meta, data, uniqueFields, options)
     }
     return keys.filter(key => !(key in data));
 }
+function getPropertyValue(obj, key) {
+    if (key.indexOf('.') === -1) {
+        return obj[key];
+    }
+    const parts = key.split('.');
+    let curr = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        curr[parts[i]] ??= {};
+        curr = curr[parts[i]];
+    }
+    return curr[parts[parts.length - 1]];
+}
+/** @internal */
+export function getWhereCondition(meta, onConflictFields, data, where) {
+    const unique = onConflictFields ?? meta.props.filter(p => p.unique).map(p => p.name);
+    const propIndex = !isRaw(unique) && unique.findIndex(p => data[p] ?? data[p.substring(0, p.indexOf('.'))] != null);
+    if (onConflictFields || where == null) {
+        if (propIndex !== false && propIndex >= 0) {
+            let key = unique[propIndex];
+            if (key.includes('.')) {
+                const prop = meta.properties[key.substring(0, key.indexOf('.'))];
+                if (prop) {
+                    key = `${prop.fieldNames[0]}${key.substring(key.indexOf('.'))}`;
+                }
+            }
+            where = { [key]: getPropertyValue(data, unique[propIndex]) };
+        }
+        else if (meta.uniques.length > 0) {
+            for (const u of meta.uniques) {
+                if (Utils.asArray(u.properties).every(p => data[p] != null)) {
+                    where = Utils.asArray(u.properties).reduce((o, key) => {
+                        o[key] = data[key];
+                        return o;
+                    }, {});
+                    break;
+                }
+            }
+        }
+    }
+    return { where, propIndex };
+}