@mikro-orm/core 7.2.0-dev.10 → 7.2.0-dev.12

package/EntityManager.d.ts

@@ -375,12 +375,10 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      */
     nativeDelete<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: DeleteOptions<Entity>): Promise<number>;
     /**
-     * Maps raw database result to an entity and merges it to this EntityManager.
+     * Maps raw database result to an entity and merges it to this EntityManager by default.
+     * Use `disableIdentityMap` to return an isolated entity without affecting the current context.
      */
-    map<Entity extends object>(entityName: EntityName<Entity>, result: EntityDictionary<Entity>, options?: {
-        schema?: string;
-        mapped?: boolean;
-    }): Entity;
+    map<Entity extends object>(entityName: EntityName<Entity>, result: EntityDictionary<Entity>, options?: MapOptions): Entity;
     /**
      * Merges given entity to this EntityManager so it becomes managed. You can force refreshing of existing entities
      * via second parameter. By default, it will return already loaded entities without modifying them.
@@ -667,6 +665,14 @@ export interface CreateOptions<Convert extends boolean> {
      */
     processOnCreateHooksEarly?: boolean;
 }
+export interface MapOptions {
+    /** schema to use when mapping the entity */
+    schema?: string;
+    /** set to true when the result is already mapped to entity property names */
+    mapped?: boolean;
+    /** map the entity in an isolated context without adding it to the identity map */
+    disableIdentityMap?: boolean;
+}
 export interface MergeOptions {
     refresh?: boolean;
     convertCustomTypes?: boolean;

package/EntityManager.js

@@ -1399,10 +1399,18 @@ export class EntityManager {
         return res.affectedRows;
     }
     /**
-     * Maps raw database result to an entity and merges it to this EntityManager.
+     * Maps raw database result to an entity and merges it to this EntityManager by default.
+     * Use `disableIdentityMap` to return an isolated entity without affecting the current context.
      */
     map(entityName, result, options = {}) {
-        const { mapped, ...rest } = options;
+        if (options.disableIdentityMap ?? this.config.get('disableIdentityMap')) {
+            const em = this.getContext(false);
+            const fork = em.fork({ keepTransactionContext: true });
+            const ret = fork.map(entityName, result, { ...options, disableIdentityMap: false });
+            fork.clear();
+            return ret;
+        }
+        const { mapped, disableIdentityMap, ...rest } = options;
         const meta = this.metadata.get(entityName);
         const data = (mapped ? result : this.driver.mapResult(result, meta));
         for (const k of Object.keys(data)) {

package/entity/EntityRepository.d.ts

@@ -1,5 +1,5 @@
 import type { PopulatePath } from '../enums.js';
-import type { CreateOptions, EntityManager, MergeOptions } from '../EntityManager.js';
+import type { CreateOptions, EntityManager, MapOptions, MergeOptions } from '../EntityManager.js';
 import type { AssignOptions } from './EntityAssigner.js';
 import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityName, FilterQuery, Loaded, Primary, AutoPath, RequiredEntityData, Ref, EntityType, EntityDTO, MergeSelected, FromEntityType, IsSubset, MergeLoaded, ArrayElement, IndexFilterQuery, WithUsingOptions } from '../typings.js';
 import type { CountByOptions, CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, NativeInsertUpdateOptions, StreamOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from '../drivers/IDatabaseDriver.js';
@@ -115,11 +115,10 @@ export declare class EntityRepository<Entity extends object> {
      */
     nativeDelete(where: FilterQuery<Entity>, options?: DeleteOptions<Entity>): Promise<number>;
     /**
-     * Maps raw database result to an entity and merges it to this EntityManager.
+     * Maps raw database result to an entity and merges it to this EntityManager by default.
+     * Use `disableIdentityMap` to return an isolated entity without affecting the current context.
      */
-    map(result: EntityDictionary<Entity>, options?: {
-        schema?: string;
-    }): Entity;
+    map(result: EntityDictionary<Entity>, options?: Omit<MapOptions, 'mapped'>): Entity;
     /**
      * Gets a reference to the entity identified by the given type and alternate key property without actually loading it.
      * The key option specifies which property to use for identity map lookup instead of the primary key.

package/entity/EntityRepository.js

@@ -131,7 +131,8 @@ export class EntityRepository {
         return this.getEntityManager().nativeDelete(this.entityName, where, options);
     }
     /**
-     * Maps raw database result to an entity and merges it to this EntityManager.
+     * Maps raw database result to an entity and merges it to this EntityManager by default.
+     * Use `disableIdentityMap` to return an isolated entity without affecting the current context.
      */
     map(result, options) {
         return this.getEntityManager().map(this.entityName, result, options);

package/entity/defineEntity.d.ts

@@ -570,6 +570,13 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
 export interface EmptyOptions extends Partial<Record<UniversalPropertyKeys, unknown>> {
 }
 /** @internal */
+export declare class StringPropertyOptionsBuilder<Value, Options> extends UniversalPropertyOptionsBuilder<Value, Options, IncludeKeysForProperty> {
+    trim(): StringPropertyOptionsBuilder<Value, Options>;
+    lowercase(): StringPropertyOptionsBuilder<Value, Options>;
+    uppercase(): StringPropertyOptionsBuilder<Value, Options>;
+    private withOptions;
+}
+/** @internal */
 export declare class OneToManyOptionsBuilderOnlyMappedBy<Value extends object> extends UniversalPropertyOptionsBuilder<Value, EmptyOptions & {
     kind: '1:m';
 }, IncludeKeysForOneToManyOptions> {
@@ -582,7 +589,7 @@ type EntityTarget = {
     '~entity': any;
 } | EntityClass;
 declare const propertyBuilders: PropertyBuilders;
-type PropertyBuildersOverrideKeys = 'bigint' | 'array' | 'decimal' | 'json' | 'datetime' | 'time' | 'enum';
+type PropertyBuildersOverrideKeys = 'bigint' | 'array' | 'decimal' | 'json' | 'string' | 'text' | 'datetime' | 'time' | 'enum';
 /** Map of factory functions for creating type-safe property builders (scalars, enums, embeddables, and relations). */
 export type PropertyBuilders = {
     [K in Exclude<keyof typeof types, PropertyBuildersOverrideKeys>]: () => UniversalPropertyOptionsBuilder<InferPropertyValueType<(typeof types)[K]>, EmptyOptions, IncludeKeysForProperty>;
@@ -591,6 +598,8 @@ export type PropertyBuilders = {
     array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.array<T>>, EmptyOptions, IncludeKeysForProperty>;
     decimal: <Mode extends 'number' | 'string' = 'string'>(mode?: Mode) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.decimal<Mode>>, EmptyOptions, IncludeKeysForProperty>;
     json: <T>() => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
+    string: () => StringPropertyOptionsBuilder<InferPropertyValueType<typeof types.string>, EmptyOptions>;
+    text: () => StringPropertyOptionsBuilder<InferPropertyValueType<typeof types.text>, EmptyOptions>;
     formula: <T>(formula: string | FormulaCallback<any>) => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
     datetime: (length?: number) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.datetime>, EmptyOptions, IncludeKeysForProperty>;
     time: (length?: number) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.time>, EmptyOptions, IncludeKeysForProperty>;

package/entity/defineEntity.js

@@ -472,6 +472,27 @@ export class UniversalPropertyOptionsBuilder {
     }
 }
 /** @internal */
+export class StringPropertyOptionsBuilder extends UniversalPropertyOptionsBuilder {
+    trim() {
+        return this.withOptions({ trim: true });
+    }
+    lowercase() {
+        return this.withOptions({ case: 'lower' });
+    }
+    uppercase() {
+        return this.withOptions({ case: 'upper' });
+    }
+    withOptions(options) {
+        const type = this['~options'].type;
+        const TypeClass = typeof type === 'function' ? type : type.constructor;
+        const currentOptions = typeof type === 'function' ? {} : type.options;
+        return new StringPropertyOptionsBuilder({
+            ...this['~options'],
+            type: new TypeClass({ ...currentOptions, ...options }),
+        });
+    }
+}
+/** @internal */
 export class OneToManyOptionsBuilderOnlyMappedBy extends UniversalPropertyOptionsBuilder {
     /** Point to the owning side property name. */
     mappedBy(mappedBy) {
@@ -487,6 +508,12 @@ const propertyBuilders = {
     array: (toJsValue = i => i, toDbValue = i => i) => new UniversalPropertyOptionsBuilder({ type: new types.array(toJsValue, toDbValue) }),
     decimal: (mode) => new UniversalPropertyOptionsBuilder({ type: new types.decimal(mode) }),
     json: () => new UniversalPropertyOptionsBuilder({ type: types.json }),
+    string: () => new StringPropertyOptionsBuilder({
+        type: types.string,
+    }),
+    text: () => new StringPropertyOptionsBuilder({
+        type: types.text,
+    }),
     formula: (formula) => new UniversalPropertyOptionsBuilder({ formula }),
     datetime: (length) => new UniversalPropertyOptionsBuilder({ type: types.datetime, length }),
     time: (length) => new UniversalPropertyOptionsBuilder({ type: types.time, length }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.0-dev.10",
+  "version": "7.2.0-dev.12",
   "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/types/StringType.d.ts

@@ -1,10 +1,21 @@
 import { Type } from './Type.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { EntityProperty } from '../typings.js';
-/** Maps a database VARCHAR column to a JS `string`. */
-export declare class StringType extends Type<string | null | undefined, string | null | undefined> {
-    getColumnType(prop: EntityProperty, platform: Platform): string;
+export interface StringTypeOptions {
+    trim?: boolean;
+    case?: 'upper' | 'lower';
+}
+/** @internal */
+export declare abstract class BaseStringType extends Type<string | null | undefined, string | null | undefined> {
+    readonly options: StringTypeOptions;
+    constructor(options?: StringTypeOptions);
+    convertToDatabaseValue(value: string | null | undefined): string | null | undefined;
     compareAsType(): string;
     ensureComparable(): boolean;
+    private normalize;
+}
+/** Maps a database VARCHAR column to a JS `string`. */
+export declare class StringType extends BaseStringType {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
     getDefaultLength(platform: Platform): number;
 }

package/types/StringType.js

@@ -1,8 +1,17 @@
 import { Type } from './Type.js';
-/** Maps a database VARCHAR column to a JS `string`. */
-export class StringType extends Type {
-    getColumnType(prop, platform) {
-        return platform.getVarcharTypeDeclarationSQL(prop);
+/** @internal */
+export class BaseStringType extends Type {
+    options;
+    constructor(options = {}) {
+        super();
+        this.options = options;
+        // a defined `compareValues` replaces the inline `!==` comparator, so only provide it when normalization is configured
+        if (options.trim || options.case) {
+            this.compareValues = (a, b) => this.normalize(a) === this.normalize(b);
+        }
+    }
+    convertToDatabaseValue(value) {
+        return this.normalize(value);
     }
     compareAsType() {
         return 'string';
@@ -10,6 +19,27 @@ export class StringType extends Type {
     ensureComparable() {
         return false;
     }
+    normalize(value) {
+        if (value == null) {
+            return value;
+        }
+        if (this.options.trim) {
+            value = value.trim();
+        }
+        if (this.options.case === 'upper') {
+            return value.toUpperCase();
+        }
+        if (this.options.case === 'lower') {
+            return value.toLowerCase();
+        }
+        return value;
+    }
+}
+/** Maps a database VARCHAR column to a JS `string`. */
+export class StringType extends BaseStringType {
+    getColumnType(prop, platform) {
+        return platform.getVarcharTypeDeclarationSQL(prop);
+    }
     getDefaultLength(platform) {
         return platform.getDefaultVarcharLength();
     }

package/types/TextType.d.ts

@@ -1,9 +1,7 @@
-import { Type } from './Type.js';
+import { BaseStringType } from './StringType.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { EntityProperty } from '../typings.js';
 /** Maps a database TEXT column (unbounded length) to a JS `string`. */
-export declare class TextType extends Type<string | null | undefined, string | null | undefined> {
+export declare class TextType extends BaseStringType {
     getColumnType(prop: EntityProperty, platform: Platform): string;
-    compareAsType(): string;
-    ensureComparable(): boolean;
 }

package/types/TextType.js

@@ -1,13 +1,7 @@
-import { Type } from './Type.js';
+import { BaseStringType } from './StringType.js';
 /** Maps a database TEXT column (unbounded length) to a JS `string`. */
-export class TextType extends Type {
+export class TextType extends BaseStringType {
     getColumnType(prop, platform) {
         return platform.getTextTypeDeclarationSQL(prop);
     }
-    compareAsType() {
-        return 'string';
-    }
-    ensureComparable() {
-        return false;
-    }
 }

package/types/index.d.ts

@@ -15,7 +15,7 @@ import { IntervalType } from './IntervalType.js';
 import { JsonType } from './JsonType.js';
 import { MediumIntType } from './MediumIntType.js';
 import { SmallIntType } from './SmallIntType.js';
-import { StringType } from './StringType.js';
+import { type StringTypeOptions, StringType } from './StringType.js';
 import { TextType } from './TextType.js';
 import { TimeType } from './TimeType.js';
 import { TinyIntType } from './TinyIntType.js';
@@ -23,7 +23,7 @@ import { type IType, type TransformContext, Type } from './Type.js';
 import { Uint8ArrayType } from './Uint8ArrayType.js';
 import { UnknownType } from './UnknownType.js';
 import { UuidType } from './UuidType.js';
-export type { TransformContext, IType };
+export type { TransformContext, IType, StringTypeOptions };
 export { Type, DateType, TimeType, DateTimeType, BigIntType, BlobType, Uint8ArrayType, ArrayType, EnumArrayType, EnumType, JsonType, IntegerType, SmallIntType, TinyIntType, MediumIntType, FloatType, DoubleType, BooleanType, DecimalType, StringType, UuidType, TextType, UnknownType, IntervalType, CharacterType, };
 /** Registry of all built-in type constructors, keyed by their short name (e.g., `types.integer`, `types.uuid`). */
 export declare const types: {

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.2.0-dev.10';
+    static #ORM_VERSION = '7.2.0-dev.12';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */