@mikro-orm/core 7.0.0-dev.99 → 7.0.0-rc.1

package/utils/fs-utils.js

@@ -1,9 +1,25 @@
-import { existsSync, globSync, mkdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { existsSync, globSync as nodeGlobSync, mkdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { isAbsolute, join, normalize, relative } from 'node:path';
+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 });
+    return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+};
 export const fs = {
+    async init() {
+        const tinyGlobby = await import('tinyglobby').catch(() => null);
+        if (tinyGlobby) {
+            globSync = (patterns, options) => {
+                patterns = Utils.asArray(patterns).map(p => p.replace(/\\/g, '/'));
+                if (options?.cwd) {
+                    options = { ...options, cwd: options.cwd.replace(/\\/g, '/') };
+                }
+                return tinyGlobby.globSync(patterns, { ...options, expandDirectories: false });
+            };
+        }
+    },
     pathExists(path) {
         if (/[*?[\]]/.test(path)) {
             return globSync(path).length > 0;
@@ -20,30 +36,49 @@ export const fs = {
         return JSON.parse(file.toString());
     },
     glob(input, cwd) {
+        const patterns = Array.isArray(input) ? input : [input];
+        const positive = [];
+        const negative = [];
+        for (const p of patterns) {
+            if (p.startsWith('!')) {
+                negative.push(p.slice(1));
+            }
+            else {
+                positive.push(p);
+            }
+        }
+        const included = new Set(this.resolveGlob(positive, cwd));
+        if (included.size > 0 && negative.length > 0) {
+            const excluded = this.resolveGlob(negative, cwd);
+            for (const file of excluded) {
+                included.delete(file);
+            }
+        }
+        return [...included];
+    },
+    resolveGlob(input, cwd) {
         if (Array.isArray(input)) {
-            return input.flatMap(paths => this.glob(paths, cwd));
+            return input.flatMap(paths => this.resolveGlob(paths, cwd));
         }
         const hasGlobChars = /[*?[\]]/.test(input);
         if (!hasGlobChars) {
             try {
-                const s = statSync(cwd ? Utils.normalizePath(cwd, input) : input);
+                const s = statSync(cwd ? this.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));
+                    return globSync(join(input, '**'), { cwd });
                 }
             }
             catch {
                 // ignore
             }
         }
-        const files = globSync(input, { cwd, withFileTypes: true });
-        return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+        return globSync(input, { cwd });
     },
     getPackageConfig(basePath = process.cwd()) {
         if (this.pathExists(`${basePath}/package.json`)) {
             try {
-                const path = import.meta.resolve(`${basePath}/package.json`);
-                return this.readJSONSync(fileURLToPath(path));
+                const path = this.normalizePath(import.meta.resolve(`${basePath}/package.json`));
+                return this.readJSONSync(path);
             }
             catch (e) {
                 /* v8 ignore next */
@@ -93,5 +128,65 @@ export const fs = {
             }
         }
     },
+    /**
+     * Resolves and normalizes a series of path parts relative to each preceding part.
+     * If any part is a `file:` URL, it is converted to a local path. If any part is an
+     * absolute path, it replaces preceding paths (similar to `path.resolve` in NodeJS).
+     * Trailing directory separators are removed, and all directory separators are converted
+     * to POSIX-style separators (`/`).
+     */
+    normalizePath(...parts) {
+        let start = 0;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            if (isAbsolute(part)) {
+                start = i;
+            }
+            else if (part.startsWith('file:')) {
+                start = i;
+                parts[i] = fileURLToPath(part);
+            }
+        }
+        if (start > 0) {
+            parts = parts.slice(start);
+        }
+        let path = parts.join('/').replace(/\\/g, '/').replace(/\/$/, '');
+        path = normalize(path).replace(/\\/g, '/');
+        return (path.match(/^[/.]|[a-zA-Z]:/) || path.startsWith('!')) ? path : './' + path;
+    },
+    /**
+     * Determines the relative path between two paths. If either path is a `file:` URL,
+     * it is converted to a local path.
+     */
+    relativePath(path, relativeTo) {
+        if (!path) {
+            return path;
+        }
+        path = this.normalizePath(path);
+        if (path.startsWith('.')) {
+            return path;
+        }
+        path = relative(this.normalizePath(relativeTo), path);
+        return this.normalizePath(path);
+    },
+    /**
+     * Computes the absolute path to for the given path relative to the provided base directory.
+     * If either `path` or `baseDir` are `file:` URLs, they are converted to local paths.
+     */
+    absolutePath(path, baseDir = process.cwd()) {
+        if (!path) {
+            return this.normalizePath(baseDir);
+        }
+        if (!isAbsolute(path) && !path.startsWith('file://')) {
+            path = baseDir + '/' + path;
+        }
+        return this.normalizePath(path);
+    },
+    async dynamicImport(id) {
+        /* v8 ignore next */
+        const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;
+        const dynamicImportProvider = globalThis.dynamicImportProvider ?? ((id) => import(id));
+        return dynamicImportProvider(specifier);
+    },
 };
 export * from '../cache/FileCacheAdapter.js';

package/utils/upsert-utils.d.ts

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