@mikro-orm/core 7.0.0-dev.312 → 7.0.0-dev.314

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL and SQLite (including libSQL) databases. 
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases. 
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -181,6 +181,7 @@ yarn add @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 yarn add @mikro-orm/core @mikro-orm/mssql         # for mssql
+yarn add @mikro-orm/core @mikro-orm/oracledb      # for oracle
 yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```

package/entity/EntityLoader.js

@@ -522,16 +522,14 @@ export class EntityLoader {
         const options2 = { ...options, fields, exclude, populateFilter };
         ['limit', 'offset', 'first', 'last', 'before', 'after', 'overfetch'].forEach(prop => delete options2[prop]);
         options2.populate = populate?.children ?? [];
-        if (prop.customType) {
-            ids.forEach((id, idx) => (ids[idx] = QueryHelper.processCustomType(prop, id, this.driver.getPlatform())));
-        }
         if (!Utils.isEmpty(prop.where)) {
             where = { $and: [where, prop.where] };
         }
         const map = await this.driver.loadFromPivotTable(prop, ids, where, orderBy, this.em.getTransactionContext(), options2, pivotJoin);
         const children = [];
-        for (const entity of filtered) {
-            const items = map[entity.__helper.getSerializedPrimaryKey()].map(item => {
+        for (let i = 0; i < filtered.length; i++) {
+            const entity = filtered[i];
+            const items = map[Utils.getPrimaryKeyHash(ids[i])].map(item => {
                 if (pivotJoin) {
                     return this.em.getReference(prop.targetMeta.class, item, {
                         convertCustomTypes: true,

package/exceptions.js

@@ -12,12 +12,14 @@ export class DriverException extends Error {
         Object.getOwnPropertyNames(previous).forEach(k => (this[k] = previous[k]));
         this.name = this.constructor.name;
         Error.captureStackTrace(this, this.constructor);
-        this.stack +=
-            '\n\n' +
-                previous
-                    .stack.split('\n')
-                    .filter(l => l.trim().startsWith('at '))
-                    .join('\n');
+        if (previous.stack) {
+            this.stack +=
+                '\n\n' +
+                    previous.stack
+                        .split('\n')
+                        .filter(l => l.trim().startsWith('at '))
+                        .join('\n');
+        }
     }
 }
 /**

package/metadata/MetadataDiscovery.js

@@ -842,6 +842,7 @@ export class MetadataDiscovery {
         const primaryProp = {
             name: pk,
             type: 'number',
+            runtimeType: 'number',
             kind: ReferenceKind.SCALAR,
             primary: true,
             autoincrement: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.0-dev.312",
+  "version": "7.0.0-dev.314",
   "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.",
   "keywords": [
     "data-mapper",

package/platforms/Platform.d.ts

@@ -1,6 +1,6 @@
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { type NamingStrategy } from '../naming-strategy/NamingStrategy.js';
-import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta } from '../typings.js';
+import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta, FilterQuery, EntityValue, EntityKey } from '../typings.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { Configuration } from '../utils/Configuration.js';
@@ -61,6 +61,13 @@ export declare abstract class Platform {
     getDateTypeDeclarationSQL(length?: number): string;
     getTimeTypeDeclarationSQL(length?: number): string;
     getRegExpOperator(val?: unknown, flags?: string): string;
+    mapRegExpCondition(mappedKey: string, value: {
+        $re: string;
+        $flags?: string;
+    }): {
+        sql: string;
+        params: unknown[];
+    };
     getRegExpValue(val: RegExp): {
         $re: string;
         $flags?: string;
@@ -139,6 +146,11 @@ export declare abstract class Platform {
     getMappedType(type: string): Type<unknown>;
     getDefaultMappedType(type: string): Type<unknown>;
     supportsMultipleCascadePaths(): boolean;
+    /**
+     * Returns true if the platform supports ON UPDATE foreign key rules.
+     * Oracle doesn't support ON UPDATE rules.
+     */
+    supportsOnUpdate(): boolean;
     supportsMultipleStatements(): boolean;
     supportsUnionWhere(): boolean;
     getArrayDeclarationSQL(): string;
@@ -148,6 +160,8 @@ export declare abstract class Platform {
     getJsonDeclarationSQL(): string;
     getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string | Raw;
     getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | Raw;
+    processJsonCondition<T extends object>(o: FilterQuery<T>, value: EntityValue<T>, path: EntityKey<T>[], alias: boolean): FilterQuery<T>;
+    protected getJsonValueType(value: unknown): string;
     getJsonIndexDefinition(index: {
         columnNames: string[];
     }): string[];
@@ -160,6 +174,14 @@ export declare abstract class Platform {
     convertDateToJSValue(value: string | Date): string;
     convertIntervalToJSValue(value: string): unknown;
     convertIntervalToDatabaseValue(value: unknown): unknown;
+    usesAsKeyword(): boolean;
+    /**
+     * Determines how UUID values are compared in the change set tracking.
+     * Return `'string'` for inline string comparison (fast), or `'any'` for deep comparison via type methods.
+     */
+    compareUuids(): string;
+    convertUuidToJSValue(value: unknown): unknown;
+    convertUuidToDatabaseValue(value: unknown): unknown;
     parseDate(value: string | number): Date;
     getRepositoryClass<T extends object>(): Constructor<EntityRepository<T>>;
     getDefaultCharset(): string;

package/platforms/Platform.js

@@ -3,7 +3,7 @@ import { EntityRepository } from '../entity/EntityRepository.js';
 import { UnderscoreNamingStrategy } from '../naming-strategy/UnderscoreNamingStrategy.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
 import { ArrayType, BigIntType, BlobType, BooleanType, CharacterType, DateTimeType, DateType, DecimalType, DoubleType, EnumType, FloatType, IntegerType, IntervalType, JsonType, MediumIntType, SmallIntType, StringType, TextType, TimeType, TinyIntType, Type, Uint8ArrayType, UnknownType, UuidType, } from '../types/index.js';
-import { parseJsonSafe } from '../utils/Utils.js';
+import { parseJsonSafe, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
 import { Raw } from '../utils/RawQueryFragment.js';
 export const JsonProperty = Symbol('JsonProperty');
@@ -104,6 +104,11 @@ export class Platform {
     getRegExpOperator(val, flags) {
         return 'regexp';
     }
+    mapRegExpCondition(mappedKey, value) {
+        const operator = this.getRegExpOperator(value.$re, value.$flags);
+        const quotedKey = this.quoteIdentifier(mappedKey);
+        return { sql: `${quotedKey} ${operator} ?`, params: [value.$re] };
+    }
     getRegExpValue(val) {
         if (val.flags.includes('i')) {
             return { $re: `(?i)${val.source}` };
@@ -156,7 +161,7 @@ export class Platform {
         return 'interval' + (column.length ? `(${column.length})` : '');
     }
     getTextTypeDeclarationSQL(_column) {
-        return `text`;
+        return 'text';
     }
     getEnumTypeDeclarationSQL(column) {
         if (column.items?.every(item => typeof item === 'string')) {
@@ -255,6 +260,13 @@ export class Platform {
     supportsMultipleCascadePaths() {
         return true;
     }
+    /**
+     * Returns true if the platform supports ON UPDATE foreign key rules.
+     * Oracle doesn't support ON UPDATE rules.
+     */
+    supportsOnUpdate() {
+        return true;
+    }
     supportsMultipleStatements() {
         return this.config.get('multipleStatements');
     }
@@ -285,6 +297,31 @@ export class Platform {
     getSearchJsonPropertyKey(path, type, aliased, value) {
         return path.join('.');
     }
+    processJsonCondition(o, value, path, alias) {
+        if (Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils.isOperator(k))) {
+            Utils.keys(value).forEach(k => {
+                this.processJsonCondition(o, value[k], [...path, k], alias);
+            });
+            return o;
+        }
+        if (path.length === 1) {
+            o[path[0]] = value;
+            return o;
+        }
+        const type = this.getJsonValueType(value);
+        const k = this.getSearchJsonPropertyKey(path, type, alias, value);
+        o[k] = value;
+        return o;
+    }
+    getJsonValueType(value) {
+        if (Array.isArray(value)) {
+            return typeof value[0];
+        }
+        if (Utils.isPlainObject(value) && Object.keys(value).every(k => Utils.isOperator(k))) {
+            return this.getJsonValueType(Object.values(value)[0]);
+        }
+        return typeof value;
+    }
     /* v8 ignore next */
     getJsonIndexDefinition(index) {
         return index.columnNames;
@@ -316,6 +353,22 @@ export class Platform {
     convertIntervalToDatabaseValue(value) {
         return value;
     }
+    usesAsKeyword() {
+        return true;
+    }
+    /**
+     * Determines how UUID values are compared in the change set tracking.
+     * Return `'string'` for inline string comparison (fast), or `'any'` for deep comparison via type methods.
+     */
+    compareUuids() {
+        return 'string';
+    }
+    convertUuidToJSValue(value) {
+        return value;
+    }
+    convertUuidToDatabaseValue(value) {
+        return value;
+    }
     parseDate(value) {
         const date = new Date(value);
         /* v8 ignore next */

package/types/UuidType.d.ts

@@ -4,5 +4,7 @@ import type { EntityProperty } from '../typings.js';
 export declare class UuidType extends Type<string | null | undefined> {
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
+    convertToDatabaseValue(value: string | null | undefined, platform: Platform): string | null;
+    convertToJSValue(value: string | null | undefined, platform: Platform): string | null | undefined;
     ensureComparable(): boolean;
 }

package/types/UuidType.js

@@ -4,9 +4,21 @@ export class UuidType extends Type {
         return platform.getUuidTypeDeclarationSQL(prop);
     }
     compareAsType() {
-        return 'string';
+        return this.platform?.compareUuids() ?? 'string';
+    }
+    convertToDatabaseValue(value, platform) {
+        if (value == null) {
+            return value;
+        }
+        return platform.convertUuidToDatabaseValue(value);
+    }
+    convertToJSValue(value, platform) {
+        if (value == null) {
+            return value;
+        }
+        return platform.convertUuidToJSValue(value);
     }
     ensureComparable() {
-        return false;
+        return this.platform?.compareUuids() !== 'string';
     }
 }

package/unit-of-work/ChangeSetPersister.js

@@ -123,7 +123,7 @@ export class ChangeSetPersister {
         // Use changeSet's own meta for STI entities to get correct field mappings
         const res = await this.driver.nativeInsertMany(changeSet.meta.class, [changeSet.payload], options);
         if (!wrapped.hasPrimaryKey()) {
-            this.mapPrimaryKey(meta, res.insertId, changeSet);
+            this.mapPrimaryKey(meta, res.insertId ?? res.row?.[meta.primaryKeys[0]], changeSet);
         }
         this.mapReturnedValues(changeSet.entity, changeSet.payload, res.row, meta);
         this.markAsPopulated(changeSet, meta);

package/utils/Configuration.d.ts

@@ -891,6 +891,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
          * When not set, no rule is emitted and the database uses its native default (NO ACTION/RESTRICT).
          */
         defaultDeleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | 'restrict';
+        tableSpace?: string;
     };
     /**
      * Embeddable entity configuration options.

package/utils/QueryHelper.d.ts

@@ -25,7 +25,6 @@ export declare class QueryHelper {
     static processCustomType<T extends object>(prop: EntityProperty<T>, cond: FilterQuery<T>, platform: Platform, key?: string, fromQuery?: boolean): FilterQuery<T>;
     private static isSupportedOperator;
     private static processJsonCondition;
-    private static getValueType;
     static findProperty<T>(fieldName: string, options: ProcessWhereOptions<T>): EntityProperty<T> | undefined;
     /**
      * Converts entity references for composite FK properties into flat arrays

package/utils/QueryHelper.js

@@ -186,7 +186,7 @@ export class QueryHelper {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
             // oxfmt-ignore
-            const isJsonProperty = prop?.customType instanceof JsonType && Utils.isPlainObject(value) && !isRaw(value) && Object.keys(value)[0] !== '$eq';
+            const isJsonProperty = prop?.customType instanceof JsonType && !isRaw(value) && (Utils.isPlainObject(value) ? Object.keys(value)[0] !== '$eq' : !Array.isArray(value));
             if (isJsonProperty && prop?.kind !== ReferenceKind.EMBEDDED) {
                 return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
             }
@@ -283,29 +283,7 @@ export class QueryHelper {
         return !!QueryHelper.SUPPORTED_OPERATORS.find(op => key === op);
     }
     static processJsonCondition(o, value, path, platform, alias) {
-        if (Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils.isOperator(k))) {
-            Utils.keys(value).forEach(k => {
-                this.processJsonCondition(o, value[k], [...path, k], platform, alias);
-            });
-            return o;
-        }
-        if (path.length === 1) {
-            o[path[0]] = value;
-            return o;
-        }
-        const type = this.getValueType(value);
-        const k = platform.getSearchJsonPropertyKey(path, type, alias, value);
-        o[k] = value;
-        return o;
-    }
-    static getValueType(value) {
-        if (Array.isArray(value)) {
-            return typeof value[0];
-        }
-        if (Utils.isPlainObject(value) && Object.keys(value).every(k => Utils.isOperator(k))) {
-            return this.getValueType(Object.values(value)[0]);
-        }
-        return typeof value;
+        return platform.processJsonCondition(o, value, path, alias);
     }
     static findProperty(fieldName, options) {
         const parts = fieldName.split('.');

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.312';
+    static #ORM_VERSION = '7.0.0-dev.314';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */