@mikro-orm/core 7.0.0-dev.70 → 7.0.0-dev.72

package/cache/FileCacheAdapter.d.ts

@@ -3,13 +3,12 @@ export declare class FileCacheAdapter implements SyncCacheAdapter {
     private readonly options;
     private readonly baseDir;
     private readonly pretty;
-    private readonly hashAlgorithm;
     private readonly VERSION;
     private cache;
     constructor(options: {
         cacheDir: string;
         combined?: boolean | string;
-    }, baseDir: string, pretty?: boolean, hashAlgorithm?: 'md5' | 'sha256');
+    }, baseDir: string, pretty?: boolean);
     /**
      * @inheritDoc
      */

package/cache/FileCacheAdapter.js

@@ -4,14 +4,12 @@ export class FileCacheAdapter {
     options;
     baseDir;
     pretty;
-    hashAlgorithm;
     VERSION = Utils.getORMVersion();
     cache = {};
-    constructor(options, baseDir, pretty = false, hashAlgorithm = 'md5') {
+    constructor(options, baseDir, pretty = false) {
         this.options = options;
         this.baseDir = baseDir;
         this.pretty = pretty;
-        this.hashAlgorithm = hashAlgorithm;
     }
     /**
      * @inheritDoc
@@ -78,6 +76,6 @@ export class FileCacheAdapter {
             return null;
         }
         const contents = readFileSync(origin);
-        return Utils.hash(contents.toString() + this.VERSION, undefined, this.hashAlgorithm);
+        return Utils.hash(contents.toString() + this.VERSION);
     }
 }

package/connections/Connection.js

@@ -1,4 +1,3 @@
-import { URL } from 'node:url';
 import { Utils } from '../utils/Utils.js';
 export class Connection {
     config;

package/metadata/MetadataStorage.js

@@ -15,7 +15,7 @@ export class MetadataStorage {
         this.metadata = Utils.copy(metadata, false);
     }
     static getMetadata(entity, path) {
-        const key = entity && path ? entity + '-' + Utils.hash(path, undefined, 'sha256') : null;
+        const key = entity && path ? entity + '-' + Utils.hash(path) : null;
         if (key && !MetadataStorage.metadata[key]) {
             MetadataStorage.metadata[key] = new EntityMetadata({ className: entity, path });
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.70",
+  "version": "7.0.0-dev.72",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",

package/unit-of-work/UnitOfWork.js

@@ -327,7 +327,8 @@ export class UnitOfWork {
             this.filterCollectionUpdates();
             // nothing to do, do not start transaction
             if (this.changeSets.size === 0 && this.collectionUpdates.size === 0 && this.extraUpdates.size === 0) {
-                return void (await this.eventManager.dispatchEvent(EventType.afterFlush, { em: this.em, uow: this }));
+                await this.eventManager.dispatchEvent(EventType.afterFlush, { em: this.em, uow: this });
+                return;
             }
             const groups = this.getChangeSetGroups();
             const platform = this.em.getPlatform();

package/utils/Configuration.d.ts

@@ -76,7 +76,6 @@ declare const DEFAULTS: {
     readonly ensureDatabase: true;
     readonly ensureIndexes: false;
     readonly batchSize: 300;
-    readonly hashAlgorithm: "md5";
     readonly debug: false;
     readonly ignoreDeprecations: false;
     readonly verbose: false;
@@ -407,7 +406,6 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
     seeder?: SeederOptions;
     preferReadReplicas?: boolean;
     dynamicImportProvider?: (id: string) => Promise<unknown>;
-    hashAlgorithm?: 'md5' | 'sha256';
 }
 type MarkRequired<T, D> = {
     [K in keyof T as Extract<K, keyof D>]-?: T[K];

package/utils/Configuration.js

@@ -68,7 +68,6 @@ const DEFAULTS = {
     ensureDatabase: true,
     ensureIndexes: false,
     batchSize: 300,
-    hashAlgorithm: 'md5',
     debug: false,
     ignoreDeprecations: false,
     verbose: false,
@@ -262,7 +261,7 @@ export class Configuration {
      * Gets instance of metadata CacheAdapter. (cached)
      */
     getMetadataCacheAdapter() {
-        return this.getCachedService(this.options.metadataCache.adapter, this.options.metadataCache.options, this.options.baseDir, this.options.metadataCache.pretty, this.options.hashAlgorithm);
+        return this.getCachedService(this.options.metadataCache.adapter, this.options.metadataCache.options, this.options.baseDir, this.options.metadataCache.pretty);
     }
     /**
      * Gets instance of CacheAdapter for result cache. (cached)

package/utils/ConfigurationLoader.js

@@ -7,78 +7,88 @@ import { colors } from '../logging/colors.js';
 export class ConfigurationLoader {
     static loadEnvironmentVars() {
         const ret = {};
+        const getEnvKey = (key, envPrefix = 'MIKRO_ORM_') => {
+            return envPrefix + key
+                .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+                .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+                .toUpperCase();
+        };
         const array = (v) => v.split(',').map(vv => vv.trim());
         const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
         const num = (v) => +v;
-        const read = (o, envKey, key, mapper = v => v) => {
-            if (!(envKey in process.env)) {
-                return;
+        const read = (o, envPrefix, key, mapper = v => v) => {
+            const envKey = getEnvKey(key, envPrefix);
+            if (envKey in process.env) {
+                o[key] = mapper(process.env[envKey]);
             }
-            const val = process.env[envKey];
-            o[key] = mapper(val);
         };
         const cleanup = (o, k) => Utils.hasObjectKeys(o[k]) ? {} : delete o[k];
-        read(ret, 'MIKRO_ORM_BASE_DIR', 'baseDir');
-        read(ret, 'MIKRO_ORM_ENTITIES', 'entities', array);
-        read(ret, 'MIKRO_ORM_ENTITIES_TS', 'entitiesTs', array);
-        read(ret, 'MIKRO_ORM_CLIENT_URL', 'clientUrl');
-        read(ret, 'MIKRO_ORM_HOST', 'host');
-        read(ret, 'MIKRO_ORM_PORT', 'port', num);
-        read(ret, 'MIKRO_ORM_USER', 'user');
-        read(ret, 'MIKRO_ORM_PASSWORD', 'password');
-        read(ret, 'MIKRO_ORM_DB_NAME', 'dbName');
-        read(ret, 'MIKRO_ORM_SCHEMA', 'schema');
-        read(ret, 'MIKRO_ORM_LOAD_STRATEGY', 'loadStrategy');
-        read(ret, 'MIKRO_ORM_BATCH_SIZE', 'batchSize', num);
-        read(ret, 'MIKRO_ORM_USE_BATCH_INSERTS', 'useBatchInserts', bool);
-        read(ret, 'MIKRO_ORM_USE_BATCH_UPDATES', 'useBatchUpdates', bool);
-        read(ret, 'MIKRO_ORM_STRICT', 'strict', bool);
-        read(ret, 'MIKRO_ORM_VALIDATE', 'validate', bool);
-        read(ret, 'MIKRO_ORM_ALLOW_GLOBAL_CONTEXT', 'allowGlobalContext', bool);
-        read(ret, 'MIKRO_ORM_AUTO_JOIN_ONE_TO_ONE_OWNER', 'autoJoinOneToOneOwner', bool);
-        read(ret, 'MIKRO_ORM_POPULATE_AFTER_FLUSH', 'populateAfterFlush', bool);
-        read(ret, 'MIKRO_ORM_FORCE_ENTITY_CONSTRUCTOR', 'forceEntityConstructor', bool);
-        read(ret, 'MIKRO_ORM_FORCE_UNDEFINED', 'forceUndefined', bool);
-        read(ret, 'MIKRO_ORM_FORCE_UTC_TIMEZONE', 'forceUtcTimezone', bool);
-        read(ret, 'MIKRO_ORM_TIMEZONE', 'timezone');
-        read(ret, 'MIKRO_ORM_ENSURE_INDEXES', 'ensureIndexes', bool);
-        read(ret, 'MIKRO_ORM_IMPLICIT_TRANSACTIONS', 'implicitTransactions', bool);
-        read(ret, 'MIKRO_ORM_DEBUG', 'debug', bool);
-        read(ret, 'MIKRO_ORM_COLORS', 'colors', bool);
+        const read0 = read.bind(null, ret, 'MIKRO_ORM_');
+        read0('baseDir');
+        read0('entities', array);
+        read0('entitiesTs', array);
+        read0('clientUrl');
+        read0('host');
+        read0('port', num);
+        read0('user');
+        read0('password');
+        read0('dbName');
+        read0('schema');
+        read0('loadStrategy');
+        read0('batchSize', num);
+        read0('useBatchInserts', bool);
+        read0('useBatchUpdates', bool);
+        read0('strict', bool);
+        read0('validate', bool);
+        read0('allowGlobalContext', bool);
+        read0('autoJoinOneToOneOwner', bool);
+        read0('populateAfterFlush', bool);
+        read0('forceEntityConstructor', bool);
+        read0('forceUndefined', bool);
+        read0('forceUtcTimezone', bool);
+        read0('timezone');
+        read0('ensureIndexes', bool);
+        read0('implicitTransactions', bool);
+        read0('debug', bool);
+        read0('colors', bool);
         ret.discovery = {};
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_WARN_WHEN_NO_ENTITIES', 'warnWhenNoEntities', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_CHECK_DUPLICATE_TABLE_NAMES', 'checkDuplicateTableNames', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_CHECK_DUPLICATE_FIELD_NAMES', 'checkDuplicateFieldNames', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_CHECK_DUPLICATE_ENTITIES', 'checkDuplicateEntities', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_CHECK_NON_PERSISTENT_COMPOSITE_PROPS', 'checkNonPersistentCompositeProps', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_INFER_DEFAULT_VALUES', 'inferDefaultValues', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_TS_CONFIG_PATH', 'tsConfigPath');
+        const read1 = read.bind(null, ret.discovery, 'MIKRO_ORM_DISCOVERY_');
+        read1('warnWhenNoEntities', bool);
+        read1('checkDuplicateTableNames', bool);
+        read1('checkDuplicateFieldNames', bool);
+        read1('checkDuplicateEntities', bool);
+        read1('checkNonPersistentCompositeProps', bool);
+        read1('inferDefaultValues', bool);
+        read1('tsConfigPath');
         cleanup(ret, 'discovery');
         ret.migrations = {};
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_TABLE_NAME', 'tableName');
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_PATH', 'path');
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_PATH_TS', 'pathTs');
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_GLOB', 'glob');
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_TRANSACTIONAL', 'transactional', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_DISABLE_FOREIGN_KEYS', 'disableForeignKeys', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_ALL_OR_NOTHING', 'allOrNothing', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_DROP_TABLES', 'dropTables', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SAFE', 'safe', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SILENT', 'silent', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_EMIT', 'emit');
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SNAPSHOT', 'snapshot', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SNAPSHOT_NAME', 'snapshotName');
+        const read2 = read.bind(null, ret.migrations, 'MIKRO_ORM_MIGRATIONS_');
+        read2('tableName');
+        read2('path');
+        read2('pathTs');
+        read2('glob');
+        read2('transactional', bool);
+        read2('disableForeignKeys', bool);
+        read2('allOrNothing', bool);
+        read2('dropTables', bool);
+        read2('safe', bool);
+        read2('silent', bool);
+        read2('emit');
+        read2('snapshot', bool);
+        read2('snapshotName');
         cleanup(ret, 'migrations');
         ret.schemaGenerator = {};
-        read(ret.schemaGenerator, 'MIKRO_ORM_SCHEMA_GENERATOR_DISABLE_FOREIGN_KEYS', 'disableForeignKeys', bool);
-        read(ret.schemaGenerator, 'MIKRO_ORM_SCHEMA_GENERATOR_CREATE_FOREIGN_KEY_CONSTRAINTS', 'createForeignKeyConstraints', bool);
+        const read3 = read.bind(null, ret.schemaGenerator, 'MIKRO_ORM_SCHEMA_GENERATOR_');
+        read3('disableForeignKeys', bool);
+        read3('createForeignKeyConstraints', bool);
         cleanup(ret, 'schemaGenerator');
         ret.seeder = {};
-        read(ret.seeder, 'MIKRO_ORM_SEEDER_PATH', 'path');
-        read(ret.seeder, 'MIKRO_ORM_SEEDER_PATH_TS', 'pathTs');
-        read(ret.seeder, 'MIKRO_ORM_SEEDER_GLOB', 'glob');
-        read(ret.seeder, 'MIKRO_ORM_SEEDER_EMIT', 'emit');
-        read(ret.seeder, 'MIKRO_ORM_SEEDER_DEFAULT_SEEDER', 'defaultSeeder');
+        const read4 = read.bind(null, ret.seeder, 'MIKRO_ORM_SEEDER_');
+        read4('path');
+        read4('pathTs');
+        read4('glob');
+        read4('emit');
+        read4('defaultSeeder');
         cleanup(ret, 'seeder');
         return ret;
     }

package/utils/Utils.d.ts

@@ -147,7 +147,7 @@ export declare class Utils {
      * If either `path` or `baseDir` are `file:` URLs, they are converted to local paths.
      */
     static absolutePath(path: string, baseDir?: string): string;
-    static hash(data: string, length?: number, algorithm?: 'md5' | 'sha256'): string;
+    static hash(data: string, length?: number): string;
     static runIfNotEmpty(clause: () => any, data: any): void;
     static defaultValue<T extends Dictionary>(prop: T, option: keyof T, defaultValue: any): void;
     static findDuplicates<T>(items: T[]): T[];
@@ -168,12 +168,6 @@ export declare class Utils {
      * @param [from] Location to start the node resolution
      */
     static requireFrom<T extends Dictionary>(id: string, from?: string): T;
-    /**
-     * Resolve path to a module.
-     * @param id The module to require
-     * @param [from] Location to start the node resolution
-     */
-    static resolveModulePath(id: string, from?: string): string;
     static dynamicImport<T = any>(id: string): Promise<T>;
     static ensureDir(path: string): void;
     static readJSONSync(path: string): Dictionary;

package/utils/Utils.js

@@ -2,7 +2,6 @@ import { createRequire } from 'node:module';
 import { extname, isAbsolute, join, normalize, relative, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { existsSync, globSync, statSync, mkdirSync, readFileSync } from 'node:fs';
-import { createHash } from 'node:crypto';
 import { clone } from './clone.js';
 import { GroupOperator, PlainObject, QueryOperator, ReferenceKind } from '../enums.js';
 import { helper } from '../entity/wrap.js';
@@ -649,9 +648,14 @@ export class Utils {
         }
         return Utils.normalizePath(path);
     }
-    static hash(data, length, algorithm) {
-        const hashAlgorithm = algorithm || 'sha256';
-        const hash = createHash(hashAlgorithm).update(data).digest('hex');
+    // FNV-1a 64-bit
+    static hash(data, length) {
+        let h1 = 0xcbf29ce484222325n;
+        for (let i = 0; i < data.length; i++) {
+            h1 ^= BigInt(data.charCodeAt(i));
+            h1 = (h1 * 0x100000001b3n) & 0xffffffffffffffffn;
+        }
+        const hash = h1.toString(16).padStart(16, '0');
         if (length) {
             return hash.substring(0, length);
         }
@@ -758,21 +762,6 @@ export class Utils {
         }
         return createRequire(resolve(from))(id);
     }
-    /**
-     * 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 */
         const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;