@mikro-orm/core 7.0.0-dev.6 → 7.0.0-dev.61

package/utils/Utils.js

@@ -1,15 +1,11 @@
 import { createRequire } from 'node:module';
-import globby from 'globby';
 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 { existsSync, globSync, statSync, mkdirSync, readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { tokenize } from 'esprima';
 import { clone } from './clone.js';
-import { ARRAY_OPERATORS, JSON_KEY_OPERATORS, GroupOperator, PlainObject, QueryOperator, ReferenceKind } from '../enums.js';
+import { ARRAY_OPERATORS, GroupOperator, JSON_KEY_OPERATORS, PlainObject, QueryOperator, ReferenceKind, } from '../enums.js';
 import { helper } from '../entity/wrap.js';
-export const ObjectBindingPattern = Symbol('ObjectBindingPattern');
 function compareConstructors(a, b) {
     if (a.constructor === b.constructor) {
         return true;
@@ -359,53 +355,37 @@ export class Utils {
         }
     }
     /**
-     * Returns array of functions argument names. Uses `esprima` for source code analysis.
+     * Returns array of functions argument names. Uses basic regex for source code analysis, might not work with advanced syntax.
      */
-    static tokenize(func) {
-        if (Array.isArray(func)) {
-            return func;
-        }
-        /* v8 ignore next 5 */
-        try {
-            return tokenize(func.toString(), { tolerant: true });
+    static getConstructorParams(func) {
+        const source = func.toString();
+        const i = source.indexOf('constructor');
+        if (i === -1) {
+            return undefined;
         }
-        catch {
-            return [];
+        const start = source.indexOf('(', i);
+        if (start === -1) {
+            return undefined;
         }
-    }
-    /**
-     * Returns array of functions argument names. Uses `esprima` for source code analysis.
-     */
-    static getParamNames(func, methodName) {
-        const ret = [];
-        const tokens = this.tokenize(func);
-        let inside = 0;
-        let currentBlockStart = 0;
-        for (let i = 0; i < tokens.length; i++) {
-            const token = tokens[i];
-            if (token.type === 'Identifier' && token.value === methodName) {
-                inside = 1;
-                currentBlockStart = i;
-                continue;
+        let depth = 0;
+        let end = start;
+        for (; end < source.length; end++) {
+            if (source[end] === '(') {
+                depth++;
             }
-            if (inside === 1 && token.type === 'Punctuator' && token.value === '(') {
-                inside = 2;
-                currentBlockStart = i;
-                continue;
+            if (source[end] === ')') {
+                depth--;
             }
-            if (inside === 2 && token.type === 'Punctuator' && token.value === ')') {
+            if (depth === 0) {
                 break;
             }
-            if (inside === 2 && token.type === 'Punctuator' && token.value === '{' && i === currentBlockStart + 1) {
-                ret.push(ObjectBindingPattern);
-                i = tokens.findIndex((t, idx) => idx > i + 2 && t.type === 'Punctuator' && t.value === '}');
-                continue;
-            }
-            if (inside === 2 && token.type === 'Identifier') {
-                ret.push(token.value);
-            }
         }
-        return ret;
+        const raw = source.slice(start + 1, end);
+        return raw
+            .split(',')
+            .map(s => s.trim().replace(/=.*$/, '').trim())
+            .filter(Boolean)
+            .map(raw => raw.startsWith('{') && raw.endsWith('}') ? '' : raw);
     }
     /**
      * Checks whether the argument looks like primary key (string, number or ObjectId).
@@ -435,7 +415,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;
@@ -444,7 +428,7 @@ export class Utils {
             if (meta.compositePK) {
                 return this.getCompositeKeyValue(data, meta);
             }
-            return data[meta.primaryKeys[0]] || data[meta.serializedPrimaryKey] || null;
+            return data[meta.primaryKeys[0]] ?? data[meta.serializedPrimaryKey] ?? null;
         }
         return null;
     }
@@ -483,7 +467,7 @@ export class Utils {
     static splitPrimaryKeys(key) {
         return key.split(this.PK_SEPARATOR);
     }
-    static getPrimaryKeyValues(entity, primaryKeys, allowScalar = false, convertCustomTypes = false) {
+    static getPrimaryKeyValues(entity, meta, allowScalar = false, convertCustomTypes = false) {
         /* v8 ignore next 3 */
         if (entity == null) {
             return entity;
@@ -494,15 +478,28 @@ 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; }, {});
-        if (primaryKeys.length > 1) {
+        let pk;
+        if (Utils.isEntity(entity, true)) {
+            pk = helper(entity).getPrimaryKey(convertCustomTypes);
+        }
+        else {
+            pk = meta.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 (meta.primaryKeys.length > 1) {
             return toArray(pk);
         }
         if (allowScalar) {
             if (Utils.isPlainObject(pk)) {
-                return pk[primaryKeys[0]];
+                return pk[(meta.primaryKeys)[0]];
             }
             return pk;
         }
@@ -546,7 +543,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 +553,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 +625,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 +648,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 +678,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 +766,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);
         }
@@ -794,12 +800,32 @@ export class Utils {
     static randomInt(min, max) {
         return Math.round(Math.random() * (max - min)) + min;
     }
-    static async pathExists(path, options = {}) {
-        if (globby.hasMagic(path)) {
-            const found = await globby(path, options);
+    static glob(input, cwd) {
+        if (Array.isArray(input)) {
+            return input.flatMap(paths => this.glob(paths, cwd));
+        }
+        const hasGlobChars = /[*?[\]]/.test(input);
+        if (!hasGlobChars) {
+            try {
+                const s = statSync(cwd ? Utils.normalizePath(cwd, input) : input);
+                if (s.isDirectory()) {
+                    const files = globSync(join(input, '**'), { cwd, withFileTypes: true });
+                    return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        const files = globSync(input, { cwd, withFileTypes: true });
+        return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+    }
+    static pathExists(path) {
+        if (/[*?[\]]/.test(path)) {
+            const found = globSync(path);
             return found.length > 0;
         }
-        return this.pathExistsSync(path);
+        return existsSync(path);
     }
     /**
      * Extracts all possible values of a TS enum. Works with both string and numeric enums.
@@ -863,18 +889,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) {
@@ -885,9 +918,6 @@ export class Utils {
             mkdirSync(path, { recursive: true });
         }
     }
-    static pathExistsSync(path) {
-        return existsSync(path);
-    }
     static readJSONSync(path) {
         const file = readFileSync(path);
         return JSON.parse(file.toString());
@@ -899,8 +929,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 +1070,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 +1081,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 };
+}