@mikro-orm/core 6.3.5-dev.8 → 6.3.5

package/README.md

@@ -143,7 +143,7 @@ There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit m
 - [Using `QueryBuilder`](https://mikro-orm.io/docs/query-builder)
 - [Preloading Deeply Nested Structures via populate](https://mikro-orm.io/docs/nested-populate)
 - [Property Validation](https://mikro-orm.io/docs/property-validation)
-- [Lifecycle Hooks](https://mikro-orm.io/docs/lifecycle-hooks)
+- [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
 - [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)
 - [Schema Generator](https://mikro-orm.io/docs/schema-generator)
 - [Entity Generator](https://mikro-orm.io/docs/entity-generator)
@@ -163,6 +163,7 @@ You can find example integrations for some popular frameworks in the [`mikro-orm
 - [NextJS + MySQL](https://github.com/jonahallibone/mikro-orm-nextjs)
 - [Accounts.js REST and GraphQL authentication + SQLite](https://github.com/darkbasic/mikro-orm-accounts-example)
 - [Nest + Shopify + PostgreSQL + GraphQL](https://github.com/Cloudshelf/Shopify_CSConnector)
+- [Elysia.js + libSQL + Bun](https://github.com/mikro-orm/elysia-bun-example-app)
 
 ### JavaScript Examples 
 

package/metadata/MetadataDiscovery.js

@@ -104,7 +104,7 @@ class MetadataDiscovery {
                 this.inferTypeFromDefault(prop);
                 this.initColumnType(prop);
                 // change tracking on scalars is used only for "auto" flushMode
-                if (this.config.get('flushMode') !== 'auto') {
+                if (this.config.get('flushMode') !== 'auto' && [enums_1.ReferenceKind.SCALAR, enums_1.ReferenceKind.EMBEDDED].includes(prop.kind)) {
                     prop.trackChanges = false;
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.3.5-dev.8",
+  "version": "6.3.5",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.3.5-dev.8",
+    "mikro-orm": "6.3.5",
     "reflect-metadata": "0.2.2"
   }
 }

package/platforms/Platform.d.ts

@@ -129,6 +129,14 @@ export declare abstract class Platform {
         length?: number;
     }): string;
     extractSimpleType(type: string): string;
+    /**
+     * This should be used only to compare types, it can strip some information like the length.
+     */
+    normalizeColumnType(type: string, options?: {
+        length?: number;
+        precision?: number;
+        scale?: number;
+    }): string;
     getMappedType(type: string): Type<unknown>;
     getDefaultMappedType(type: string): Type<unknown>;
     supportsMultipleCascadePaths(): boolean;

package/platforms/Platform.js

@@ -192,6 +192,12 @@ class Platform {
     extractSimpleType(type) {
         return type.toLowerCase().match(/[^(), ]+/)[0];
     }
+    /**
+     * This should be used only to compare types, it can strip some information like the length.
+     */
+    normalizeColumnType(type, options = {}) {
+        return type.toLowerCase();
+    }
     getMappedType(type) {
         const mappedType = this.config.get('discovery').getMappedType?.(type, this);
         return mappedType ?? this.getDefaultMappedType(type);

package/types/UnknownType.d.ts

@@ -1,8 +1,9 @@
-import { StringType } from './StringType';
 import type { EntityProperty } from '../typings';
 import type { Platform } from '../platforms/Platform';
-export declare class UnknownType extends StringType {
+import { Type } from './Type';
+export declare class UnknownType extends Type<unknown | null | undefined, unknown | null | undefined> {
     getColumnType(prop: EntityProperty, platform: Platform): string;
     get runtimeType(): string;
     compareAsType(): string;
+    ensureComparable(): boolean;
 }

package/types/UnknownType.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnknownType = void 0;
-const StringType_1 = require("./StringType");
-class UnknownType extends StringType_1.StringType {
+const Type_1 = require("./Type");
+class UnknownType extends Type_1.Type {
     getColumnType(prop, platform) {
         return prop.columnTypes?.[0] ?? platform.getVarcharTypeDeclarationSQL(prop);
     }
@@ -12,5 +12,8 @@ class UnknownType extends StringType_1.StringType {
     compareAsType() {
         return 'unknown';
     }
+    ensureComparable() {
+        return false;
+    }
 }
 exports.UnknownType = UnknownType;

package/typings.d.ts

@@ -108,9 +108,9 @@ export type OperatorMap<T> = {
     $re?: string;
     $ilike?: string;
     $fulltext?: string;
-    $overlap?: string[] | object;
-    $contains?: string[] | object;
-    $contained?: string[] | object;
+    $overlap?: string[] | string | object;
+    $contains?: string[] | string | object;
+    $contained?: string[] | string | object;
     $exists?: boolean;
     $hasKey?: string;
     $hasKeys?: string[];

package/utils/ConfigurationLoader.js

@@ -85,7 +85,8 @@ class ConfigurationLoader {
             paths.push(process.env.MIKRO_ORM_CLI_CONFIG);
         }
         paths.push(...(settings.configPaths || []));
-        if (settings.useTsNode !== false || settings.alwaysAllowTs) {
+        const alwaysAllowTs = settings.alwaysAllowTs ?? process.versions.bun;
+        if (settings.useTsNode !== false || alwaysAllowTs) {
             paths.push('./src/mikro-orm.config.ts');
             paths.push('./mikro-orm.config.ts');
         }
@@ -96,7 +97,7 @@ class ConfigurationLoader {
         paths.push(`./${path}/mikro-orm.config.js`);
         paths.push('./mikro-orm.config.js');
         const tsNode = Utils_1.Utils.detectTsNode();
-        return Utils_1.Utils.unique(paths).filter(p => p.endsWith('.js') || tsNode || settings.alwaysAllowTs);
+        return Utils_1.Utils.unique(paths).filter(p => p.endsWith('.js') || tsNode || alwaysAllowTs);
     }
     static isESM() {
         const config = ConfigurationLoader.getPackageConfig();
@@ -104,6 +105,10 @@ class ConfigurationLoader {
         return type === 'module';
     }
     static registerTsNode(configPath = 'tsconfig.json') {
+        /* istanbul ignore next */
+        if (process.versions.bun) {
+            return true;
+        }
         const tsConfigPath = (0, node_path_1.isAbsolute)(configPath) ? configPath : (0, node_path_1.join)(process.cwd(), configPath);
         const tsNode = Utils_1.Utils.tryRequire({
             module: 'ts-node',

package/utils/RequestContext.d.ts

@@ -16,8 +16,15 @@ export declare class RequestContext {
     /**
      * Creates new RequestContext instance and runs the code inside its domain.
      * If the handler is async, the return value needs to be awaited.
+     * Uses `AsyncLocalStorage.run()`, suitable for regular express style middlewares with a `next` callback.
      */
     static create<T>(em: EntityManager | EntityManager[], next: (...args: any[]) => T, options?: CreateContextOptions): T;
+    /**
+     * Creates new RequestContext instance and runs the code inside its domain.
+     * If the handler is async, the return value needs to be awaited.
+     * Uses `AsyncLocalStorage.enterWith()`, suitable for elysia style middlewares without a `next` callback.
+     */
+    static enter(em: EntityManager | EntityManager[], options?: CreateContextOptions): void;
     /**
      * Returns current RequestContext (if available).
      */

package/utils/RequestContext.js

@@ -22,11 +22,21 @@ class RequestContext {
     /**
      * Creates new RequestContext instance and runs the code inside its domain.
      * If the handler is async, the return value needs to be awaited.
+     * Uses `AsyncLocalStorage.run()`, suitable for regular express style middlewares with a `next` callback.
      */
     static create(em, next, options = {}) {
         const ctx = this.createContext(em, options);
         return this.storage.run(ctx, next);
     }
+    /**
+     * Creates new RequestContext instance and runs the code inside its domain.
+     * If the handler is async, the return value needs to be awaited.
+     * Uses `AsyncLocalStorage.enterWith()`, suitable for elysia style middlewares without a `next` callback.
+     */
+    static enter(em, options = {}) {
+        const ctx = this.createContext(em, options);
+        this.storage.enterWith(ctx);
+    }
     /**
      * Returns current RequestContext (if available).
      */

package/utils/Utils.js

@@ -46,7 +46,8 @@ function compareObjects(a, b) {
         return false;
     }
     if (isRawSql(a) && isRawSql(b)) {
-        return false;
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return a.sql === b.sql && compareArrays(a.params, b.params);
     }
     if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === 'function' && typeof b.valueOf === 'function') {
         return a.valueOf() === b.valueOf();
@@ -631,6 +632,7 @@ class Utils {
             || !!process[Symbol.for('ts-node.register.instance')] // check if internal ts-node symbol exists
             || !!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
             || (require.extensions && !!require.extensions['.ts']); // check if the extension is registered