@mikro-orm/core 7.0.0-dev.32 → 7.0.0-dev.321

package/platforms/Platform.js

@@ -1,12 +1,11 @@
-import { inspect } from 'node:util';
 import { clone } from '../utils/clone.js';
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { UnderscoreNamingStrategy } from '../naming-strategy/UnderscoreNamingStrategy.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
-import { ArrayType, BigIntType, BlobType, Uint8ArrayType, BooleanType, CharacterType, DateType, DecimalType, DoubleType, JsonType, SmallIntType, TimeType, TinyIntType, Type, UuidType, StringType, IntegerType, FloatType, DateTimeType, TextType, EnumType, UnknownType, MediumIntType, IntervalType, } from '../types/index.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, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
-import { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 export const JsonProperty = Symbol('JsonProperty');
 export class Platform {
     exceptionConverter = new ExceptionConverter();
@@ -42,15 +41,15 @@ export class Platform {
     usesEnumCheckConstraints() {
         return false;
     }
+    supportsMaterializedViews() {
+        return false;
+    }
     getSchemaHelper() {
         return undefined;
     }
     indexForeignKeys() {
         return false;
     }
-    allowsMultiInsert() {
-        return true;
-    }
     /**
      * Whether or not the driver supports retuning list of created PKs back when multi-inserting
      */
@@ -78,15 +77,6 @@ export class Platform {
     denormalizePrimaryKey(data) {
         return data;
     }
-    /**
-     * Used when serializing via toObject and toJSON methods, allows to use different PK field name (like `id` instead of `_id`)
-     */
-    getSerializedPrimaryKeyField(field) {
-        return field;
-    }
-    usesDifferentSerializedPrimaryKey() {
-        return false;
-    }
     /**
      * Returns the SQL specific for the platform to get the current timestamp
      */
@@ -114,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}` };
@@ -123,7 +118,7 @@ export class Platform {
     isAllowedTopLevelOperator(operator) {
         return operator === '$not';
     }
-    quoteVersionValue(value, prop) {
+    convertVersionValue(value, prop) {
         return value;
     }
     getDefaultVersionLength() {
@@ -133,7 +128,7 @@ export class Platform {
         return true;
     }
     isBigIntProperty(prop) {
-        return prop.columnTypes && prop.columnTypes[0] === 'bigint';
+        return prop.columnTypes?.[0] === 'bigint';
     }
     getDefaultSchemaName() {
         return undefined;
@@ -166,10 +161,10 @@ export class Platform {
         return 'interval' + (column.length ? `(${column.length})` : '');
     }
     getTextTypeDeclarationSQL(_column) {
-        return `text`;
+        return 'text';
     }
     getEnumTypeDeclarationSQL(column) {
-        if (column.items?.every(item => Utils.isString(item))) {
+        if (column.items?.every(item => typeof item === 'string')) {
             return `enum('${column.items.join("','")}')`;
         }
         return this.getTinyIntTypeDeclarationSQL(column);
@@ -190,7 +185,7 @@ export class Platform {
         return this.getVarcharTypeDeclarationSQL(column);
     }
     extractSimpleType(type) {
-        return type.toLowerCase().match(/[^(), ]+/)[0];
+        return /[^(), ]+/.exec(type.toLowerCase())[0];
     }
     /**
      * This should be used only to compare types, it can strip some information like the length.
@@ -208,43 +203,76 @@ export class Platform {
         }
         switch (this.extractSimpleType(type)) {
             case 'character':
-            case 'char': return Type.getType(CharacterType);
+            case 'char':
+                return Type.getType(CharacterType);
             case 'string':
-            case 'varchar': return Type.getType(StringType);
-            case 'interval': return Type.getType(IntervalType);
-            case 'text': return Type.getType(TextType);
+            case 'varchar':
+                return Type.getType(StringType);
+            case 'interval':
+                return Type.getType(IntervalType);
+            case 'text':
+                return Type.getType(TextType);
             case 'int':
-            case 'number': return Type.getType(IntegerType);
-            case 'bigint': return Type.getType(BigIntType);
-            case 'smallint': return Type.getType(SmallIntType);
-            case 'tinyint': return Type.getType(TinyIntType);
-            case 'mediumint': return Type.getType(MediumIntType);
-            case 'float': return Type.getType(FloatType);
-            case 'double': return Type.getType(DoubleType);
-            case 'integer': return Type.getType(IntegerType);
+            case 'number':
+                return Type.getType(IntegerType);
+            case 'bigint':
+                return Type.getType(BigIntType);
+            case 'smallint':
+                return Type.getType(SmallIntType);
+            case 'tinyint':
+                return Type.getType(TinyIntType);
+            case 'mediumint':
+                return Type.getType(MediumIntType);
+            case 'float':
+                return Type.getType(FloatType);
+            case 'double':
+                return Type.getType(DoubleType);
+            case 'integer':
+                return Type.getType(IntegerType);
             case 'decimal':
-            case 'numeric': return Type.getType(DecimalType);
-            case 'boolean': return Type.getType(BooleanType);
+            case 'numeric':
+                return Type.getType(DecimalType);
+            case 'boolean':
+                return Type.getType(BooleanType);
             case 'blob':
-            case 'buffer': return Type.getType(BlobType);
-            case 'uint8array': return Type.getType(Uint8ArrayType);
-            case 'uuid': return Type.getType(UuidType);
-            case 'date': return Type.getType(DateType);
+            case 'buffer':
+                return Type.getType(BlobType);
+            case 'uint8array':
+                return Type.getType(Uint8ArrayType);
+            case 'uuid':
+                return Type.getType(UuidType);
+            case 'date':
+                return Type.getType(DateType);
             case 'datetime':
-            case 'timestamp': return Type.getType(DateTimeType);
-            case 'time': return Type.getType(TimeType);
+            case 'timestamp':
+                return Type.getType(DateTimeType);
+            case 'time':
+                return Type.getType(TimeType);
             case 'object':
-            case 'json': return Type.getType(JsonType);
-            case 'enum': return Type.getType(EnumType);
-            default: return Type.getType(UnknownType);
+            case 'json':
+                return Type.getType(JsonType);
+            case 'enum':
+                return Type.getType(EnumType);
+            default:
+                return Type.getType(UnknownType);
         }
     }
     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');
     }
+    supportsUnionWhere() {
+        return false;
+    }
     getArrayDeclarationSQL() {
         return 'text';
     }
@@ -269,7 +297,32 @@ export class Platform {
     getSearchJsonPropertyKey(path, type, aliased, value) {
         return path.join('.');
     }
-    /* v8 ignore next 3 */
+    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;
     }
@@ -288,11 +341,7 @@ export class Platform {
     convertJsonToDatabaseValue(value, context) {
         return JSON.stringify(value);
     }
-    convertJsonToJSValue(value, prop) {
-        const isObjectEmbedded = prop.embedded && prop.object;
-        if ((this.convertsJsonAutomatically() || isObjectEmbedded) && ['json', 'jsonb', this.getJsonDeclarationSQL()].includes(prop.columnTypes[0])) {
-            return value;
-        }
+    convertJsonToJSValue(value, context) {
         return parseJsonSafe(value);
     }
     convertDateToJSValue(value) {
@@ -304,9 +353,25 @@ 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 3 */
+        /* v8 ignore next */
         if (isNaN(date.getTime())) {
             return value;
         }
@@ -336,19 +401,10 @@ export class Platform {
         if (extension) {
             return extension;
         }
-        /* v8 ignore next 4 */
-        const module = Utils.tryRequire({
-            module: moduleName,
-            warning: `Please install ${moduleName} package.`,
-        });
-        /* v8 ignore next 3 */
-        if (module) {
-            return this.config.getCachedService(module[extensionName], em);
-        }
-        /* v8 ignore next 2 */
-        throw new Error(`${extensionName} extension not registered.`);
+        /* v8 ignore next */
+        throw new Error(`${extensionName} extension not registered. Provide it in the ORM config, or use the async \`MikroORM.init()\` method to load extensions automatically.`);
     }
-    /* v8 ignore next 3: kept for type inference only */
+    /* v8 ignore next: kept for type inference only */
     getSchemaGenerator(driver, em) {
         throw new Error(`${driver.constructor.name} does not support SchemaGenerator`);
     }
@@ -356,7 +412,7 @@ export class Platform {
         return value;
     }
     quoteIdentifier(id, quote = '`') {
-        const raw = RawQueryFragment.getKnownFragment(id);
+        const raw = Raw.getKnownFragment(id);
         if (raw) {
             return this.formatQuery(raw.sql, raw.params);
         }
@@ -365,7 +421,7 @@ export class Platform {
     quoteValue(value) {
         return value;
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     escape(value) {
         return value;
     }
@@ -377,7 +433,7 @@ export class Platform {
         let j = 0;
         let pos = 0;
         let ret = '';
-        if (sql[0] === '?') {
+        if (sql.startsWith('?')) {
             if (sql[1] === '?') {
                 ret += this.quoteIdentifier(params[j++]);
                 pos = 2;
@@ -455,7 +511,7 @@ export class Platform {
     isPopulated(key, populate) {
         return populate === true || (populate !== false && populate.some(p => p.field === key || p.all));
     }
-    shouldHaveColumn(prop, populate, exclude, includeFormulas = true) {
+    shouldHaveColumn(prop, populate, exclude, includeFormulas = true, ignoreInlineEmbeddables = true) {
         if (exclude?.includes(prop.name)) {
             return false;
         }
@@ -475,7 +531,7 @@ export class Platform {
             return true;
         }
         if (prop.kind === ReferenceKind.EMBEDDED) {
-            return !!prop.object;
+            return prop.object || ignoreInlineEmbeddables;
         }
         return prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner;
     }
@@ -522,9 +578,9 @@ export class Platform {
     clone() {
         return this;
     }
-    /* v8 ignore next 4 */
     /** @ignore */
-    [inspect.custom]() {
+    /* v8 ignore next */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
         return `[${this.constructor.name}]`;
     }
 }

package/serialization/EntitySerializer.d.ts

@@ -1,9 +1,10 @@
-import type { ArrayElement, AutoPath, CleanTypeConfig, EntityDTO, FromEntityType, Loaded, TypeConfig, UnboxArray } from '../typings.js';
+import type { ArrayElement, AutoPath, CleanTypeConfig, SerializeDTO, FromEntityType, TypeConfig, UnboxArray } from '../typings.js';
 import { type PopulatePath } from '../enums.js';
 export declare class EntitySerializer {
-    static serialize<T extends object, P extends string = never, E extends string = never>(entity: T, options?: SerializeOptions<T, P, E>): EntityDTO<Loaded<T, P>>;
+    static serialize<T extends object, P extends string = never, E extends string = never>(entity: T, options?: SerializeOptions<T, P, E>): SerializeDTO<T, P, E>;
     private static propertyName;
     private static processProperty;
+    private static processCustomType;
     private static extractChildOptions;
     private static processEntity;
     private static processCollection;
@@ -23,6 +24,8 @@ export interface SerializeOptions<T, P extends string = never, E extends string
     skipNull?: boolean;
     /** Only include properties for a specific group. If a property does not specify any group, it will be included, otherwise only properties with a matching group are included. */
     groups?: string[];
+    /** Convert custom types to their database representation. By default, the `Type.toJSON` method is invoked instead. */
+    convertCustomTypes?: boolean;
 }
 /**
  * Converts entity instance to POJO, converting the `Collection`s to arrays and unwrapping the `Reference` wrapper, while respecting the serialization options.
@@ -36,4 +39,4 @@ export interface SerializeOptions<T, P extends string = never, E extends string
  * const dto2 = wrap(user).serialize({ exclude: ['id', 'email'], forceObject: true });
  * ```
  */
-export declare function serialize<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Populate extends string = never, Exclude extends string = never, Config extends TypeConfig = never>(entity: Entity, options?: Config & SerializeOptions<UnboxArray<Entity>, Populate, Exclude>): Naked extends object[] ? EntityDTO<Loaded<ArrayElement<Naked>, Populate>, CleanTypeConfig<Config>>[] : EntityDTO<Loaded<Naked, Populate>, CleanTypeConfig<Config>>;
+export declare function serialize<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Populate extends string = never, Exclude extends string = never, Config extends TypeConfig = never>(entity: Entity, options?: Config & SerializeOptions<UnboxArray<Entity>, Populate, Exclude>): Naked extends object[] ? SerializeDTO<ArrayElement<Naked>, Populate, Exclude, CleanTypeConfig<Config>>[] : SerializeDTO<Naked, Populate, Exclude, CleanTypeConfig<Config>>;

package/serialization/EntitySerializer.js

@@ -9,18 +9,20 @@ function isVisible(meta, propName, options) {
     if (options.groups && prop?.groups) {
         return prop.groups.some(g => options.groups.includes(g));
     }
-    if (Array.isArray(options.populate) && options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
+    if (Array.isArray(options.populate) &&
+        options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
         return true;
     }
     if (options.exclude?.find(item => item === propName)) {
         return false;
     }
     const visible = prop && !(prop.hidden && !options.includeHidden);
-    const prefixed = prop && !prop.primary && propName.startsWith('_'); // ignore prefixed properties, if it's not a PK
+    const prefixed = prop && !prop.primary && !prop.accessor && propName.startsWith('_'); // ignore prefixed properties, if it's not a PK
     return visible && !prefixed;
 }
 function isPopulated(propName, options) {
-    if (typeof options.populate !== 'boolean' && options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
+    if (typeof options.populate !== 'boolean' &&
+        options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
         return true;
     }
     if (typeof options.populate === 'boolean') {
@@ -41,23 +43,41 @@ export class EntitySerializer {
         }
         const root = wrapped.__serializationContext.root;
         const ret = {};
-        const keys = new Set(meta.primaryKeys);
-        Utils.keys(entity).forEach(prop => keys.add(prop));
+        const props = new Set();
+        if (meta.serializedPrimaryKey && !meta.compositePK) {
+            props.add(meta.serializedPrimaryKey);
+        }
+        else {
+            meta.primaryKeys.forEach(pk => props.add(pk));
+        }
+        if (wrapped.isInitialized() || !wrapped.hasPrimaryKey()) {
+            const entityKeys = new Set(Object.keys(entity));
+            for (const prop of meta.props) {
+                if (entityKeys.has(prop.name) || (prop.getter && prop.accessor === prop.name)) {
+                    props.add(prop.name);
+                }
+            }
+            for (const key of entityKeys) {
+                if (!meta.properties[key]) {
+                    props.add(key);
+                }
+            }
+        }
         const visited = root.visited.has(entity);
         if (!visited) {
             root.visited.add(entity);
         }
-        for (const prop of keys) {
+        for (const prop of props) {
             if (!isVisible(meta, prop, options)) {
                 continue;
             }
-            const cycle = root.visit(meta.className, prop);
+            const cycle = root.visit(meta.class, prop);
             if (cycle && visited) {
                 continue;
             }
             const val = this.processProperty(prop, entity, options);
             if (!cycle) {
-                root.leave(meta.className, prop);
+                root.leave(meta.class, prop);
             }
             if (options.skipNull && Utils.isPlainObject(val)) {
                 Utils.dropUndefinedProperties(val, null);
@@ -67,7 +87,7 @@ export class EntitySerializer {
             }
             const visible = typeof val !== 'undefined' && !(val === null && options.skipNull);
             if (visible) {
-                ret[this.propertyName(meta, prop, wrapped.__platform)] = val;
+                ret[this.propertyName(meta, prop)] = val;
             }
         }
         if (contextCreated) {
@@ -81,26 +101,26 @@ export class EntitySerializer {
             if (prop.getterName != null) {
                 const visible = entity[prop.getterName] instanceof Function && isVisible(meta, prop.name, options);
                 if (visible) {
-                    ret[this.propertyName(meta, prop.name, wrapped.__platform)] = this.processProperty(prop.getterName, entity, options);
+                    ret[this.propertyName(meta, prop.name)] = this.processProperty(prop.getterName, entity, options);
                 }
             }
             else {
                 // decorated getters
                 const visible = typeof entity[prop.name] !== 'undefined' && isVisible(meta, prop.name, options);
                 if (visible) {
-                    ret[this.propertyName(meta, prop.name, wrapped.__platform)] = this.processProperty(prop.name, entity, options);
+                    ret[this.propertyName(meta, prop.name)] = this.processProperty(prop.name, entity, options);
                 }
             }
         }
         return ret;
     }
-    static propertyName(meta, prop, platform) {
-        /* v8 ignore next 3 */
+    static propertyName(meta, prop) {
+        /* v8 ignore next */
         if (meta.properties[prop]?.serializedName) {
             return meta.properties[prop].serializedName;
         }
-        if (meta.properties[prop]?.primary && platform) {
-            return platform.getSerializedPrimaryKeyField(prop);
+        if (meta.properties[prop]?.primary && meta.serializedPrimaryKey) {
+            return meta.serializedPrimaryKey;
         }
         return prop;
     }
@@ -119,7 +139,7 @@ export class EntitySerializer {
             }
             return returnValue;
         }
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!options.ignoreSerializers && serializer) {
             return serializer(value);
         }
@@ -132,7 +152,7 @@ export class EntitySerializer {
         if (Utils.isScalarReference(value)) {
             return value.unwrap();
         }
-        /* v8 ignore next 9 */
+        /* v8 ignore next */
         if (property?.kind === ReferenceKind.EMBEDDED) {
             if (Array.isArray(value)) {
                 return value.map(item => helper(item).toJSON());
@@ -141,16 +161,26 @@ export class EntitySerializer {
                 return helper(value).toJSON();
             }
         }
-        const customType = property?.customType;
-        if (customType) {
-            return customType.toJSON(value, wrapped.__platform);
+        if (property.customType) {
+            return this.processCustomType(value, property, wrapped.__platform, options.convertCustomTypes);
         }
         return wrapped.__platform.normalizePrimaryKey(value);
     }
+    static processCustomType(value, prop, platform, convertCustomTypes) {
+        if (!prop.customType) {
+            return value;
+        }
+        if (convertCustomTypes) {
+            return prop.customType.convertToDatabaseValue(value, platform, { mode: 'serialization' });
+        }
+        return prop.customType.toJSON(value, platform);
+    }
     static extractChildOptions(options, prop) {
         return {
             ...options,
-            populate: Array.isArray(options.populate) ? Utils.extractChildElements(options.populate, prop, '*') : options.populate,
+            populate: Array.isArray(options.populate)
+                ? Utils.extractChildElements(options.populate, prop, '*')
+                : options.populate,
             exclude: Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop) : options.exclude,
         };
     }
@@ -165,10 +195,7 @@ export class EntitySerializer {
         if (expand) {
             return this.serialize(child, childOptions);
         }
-        let pk = wrapped.getPrimaryKey();
-        if (prop.customType) {
-            pk = prop.customType.toJSON(pk, wrapped.__platform);
-        }
+        const pk = this.processCustomType(wrapped.getPrimaryKey(), prop, wrapped.__platform, options.convertCustomTypes);
         if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
             return Utils.primaryKeyToObject(meta, pk, visible);
         }
@@ -192,10 +219,7 @@ export class EntitySerializer {
             if (populated || !wrapped.__managed) {
                 return this.serialize(item, this.extractChildOptions(options, prop.name));
             }
-            let pk = wrapped.getPrimaryKey();
-            if (prop.customType) {
-                pk = prop.customType.toJSON(pk, wrapped.__platform);
-            }
+            const pk = this.processCustomType(wrapped.getPrimaryKey(), prop, wrapped.__platform, options.convertCustomTypes);
             if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
                 return Utils.primaryKeyToObject(wrapped.__meta, pk);
             }