@mikro-orm/core 7.0.0-dev.12 → 7.0.0-dev.120

package/naming-strategy/UnderscoreNamingStrategy.d.ts

@@ -1,9 +1,9 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 export declare class UnderscoreNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName: string): string;
+    classToTableName(entityName: string, tableName?: string): string;
     joinColumnName(propertyName: string): string;
-    joinKeyColumnName(entityName: string, referencedColumnName?: string): string;
-    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean, tableName?: string): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string, tableName?: string): string;
     propertyToColumnName(propertyName: string, object?: boolean): string;
     referenceColumnName(): string;
     private underscore;

package/naming-strategy/UnderscoreNamingStrategy.js

@@ -1,16 +1,16 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 export class UnderscoreNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName) {
-        return this.underscore(entityName);
+    classToTableName(entityName, tableName) {
+        return tableName ?? this.underscore(entityName);
     }
     joinColumnName(propertyName) {
         return this.underscore(propertyName) + '_' + this.referenceColumnName();
     }
-    joinKeyColumnName(entityName, referencedColumnName) {
-        return this.classToTableName(entityName) + '_' + (referencedColumnName || this.referenceColumnName());
+    joinKeyColumnName(entityName, referencedColumnName, composite, tableName) {
+        return this.classToTableName(entityName, tableName) + '_' + (referencedColumnName || this.referenceColumnName());
     }
-    joinTableName(sourceEntity, targetEntity, propertyName) {
-        return this.classToTableName(sourceEntity) + '_' + this.classToTableName(propertyName);
+    joinTableName(sourceEntity, targetEntity, propertyName, tableName) {
+        return this.classToTableName(sourceEntity, tableName) + '_' + this.classToTableName(propertyName);
     }
     propertyToColumnName(propertyName, object) {
         return this.underscore(propertyName);

package/not-supported.d.ts

@@ -0,0 +1,2 @@
+export declare function discoverEntities(): void;
+export declare const fs: {};

package/not-supported.js

@@ -0,0 +1,4 @@
+export function discoverEntities() {
+    throw new Error('Folder-based discovery is not supported in this environment.');
+}
+export const fs = new Proxy({}, { get: () => { throw new Error('File system is not supported in this environment.'); } });

package/package.json

@@ -1,11 +1,19 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.12",
+  "version": "7.0.0-dev.120",
   "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",
-    ".": "./index.js"
+    ".": "./index.js",
+    "./file-discovery": {
+      "node": "./metadata/discover-entities.js",
+      "browser": "./not-supported.js"
+    },
+    "./fs-utils": {
+      "node": "./utils/fs-utils.js",
+      "browser": "./not-supported.js"
+    }
   },
   "repository": {
     "type": "git",
@@ -39,10 +47,10 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 22.11.0"
+    "node": ">= 22.17.0"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
@@ -50,12 +58,12 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "dataloader": "2.2.3",
-    "dotenv": "16.5.0",
-    "esprima": "4.0.1",
-    "globby": "11.1.0",
-    "mikro-orm": "7.0.0-dev.12",
-    "reflect-metadata": "0.2.2"
+  "peerDependencies": {
+    "dataloader": "2.2.3"
+  },
+  "peerDependenciesMeta": {
+    "dataloader": {
+      "optional": true
+    }
   }
 }

package/platforms/ExceptionConverter.js

@@ -1,6 +1,6 @@
 import { DriverException } from '../exceptions.js';
 export class ExceptionConverter {
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     convertException(exception) {
         return new DriverException(exception);
     }

package/platforms/Platform.d.ts

@@ -1,7 +1,6 @@
-import { inspect } from 'node:util';
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { type NamingStrategy } from '../naming-strategy/NamingStrategy.js';
-import type { Constructor, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, EntityMetadata, SimpleColumnMeta } from '../typings.js';
+import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta } from '../typings.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { Configuration } from '../utils/Configuration.js';
@@ -30,7 +29,6 @@ export declare abstract class Platform {
     usesEnumCheckConstraints(): boolean;
     getSchemaHelper(): unknown;
     indexForeignKeys(): boolean;
-    allowsMultiInsert(): boolean;
     /**
      * Whether or not the driver supports retuning list of created PKs back when multi-inserting
      */
@@ -48,11 +46,6 @@ export declare abstract class Platform {
      * Converts scalar primary key representation to native driver wrapper (e.g. string to mongodb's ObjectId)
      */
     denormalizePrimaryKey(data: IPrimaryKey): IPrimaryKey;
-    /**
-     * Used when serializing via toObject and toJSON methods, allows to use different PK field name (like `id` instead of `_id`)
-     */
-    getSerializedPrimaryKeyField(field: string): string;
-    usesDifferentSerializedPrimaryKey(): boolean;
     /**
      * Returns the SQL specific for the platform to get the current timestamp
      */
@@ -158,7 +151,7 @@ export declare abstract class Platform {
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
     convertsJsonAutomatically(): boolean;
     convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
-    convertJsonToJSValue(value: unknown, prop: EntityProperty): unknown;
+    convertJsonToJSValue(value: unknown, context?: TransformContext): unknown;
     convertDateToJSValue(value: string | Date): string;
     convertIntervalToJSValue(value: string): unknown;
     convertIntervalToDatabaseValue(value: unknown): unknown;
@@ -175,7 +168,9 @@ export declare abstract class Platform {
     getExtension<T>(extensionName: string, extensionKey: string, moduleName: string, em: EntityManager): T;
     getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): ISchemaGenerator;
     processDateProperty(value: unknown): string | number | Date;
-    quoteIdentifier(id: string, quote?: string): string;
+    quoteIdentifier(id: string | {
+        toString: () => string;
+    }, quote?: string): string;
     quoteValue(value: any): string;
     escape(value: any): string;
     formatQuery(sql: string, params: readonly any[]): string;
@@ -193,7 +188,7 @@ export declare abstract class Platform {
     getDefaultPrimaryName(tableName: string, columns: string[]): string;
     supportsCustomPrimaryKeyNames(): boolean;
     isPopulated<T>(key: string, populate: readonly PopulateOptions<T>[] | boolean): boolean;
-    shouldHaveColumn<T>(prop: EntityProperty<T>, populate: readonly PopulateOptions<T>[] | boolean, exclude?: string[], includeFormulas?: boolean): boolean;
+    shouldHaveColumn<T>(prop: EntityProperty<T>, populate: readonly PopulateOptions<T>[] | boolean, exclude?: string[], includeFormulas?: boolean, ignoreInlineEmbeddables?: boolean): boolean;
     /**
      * Currently not supported due to how knex does complex sqlite diffing (always based on current schema)
      */
@@ -225,6 +220,4 @@ export declare abstract class Platform {
      * @internal
      */
     clone(): this;
-    /** @ignore */
-    [inspect.custom](): string;
 }

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 { parseJsonSafe, Utils } from '../utils/Utils.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 { 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();
@@ -48,9 +47,6 @@ export class Platform {
     indexForeignKeys() {
         return false;
     }
-    allowsMultiInsert() {
-        return true;
-    }
     /**
      * Whether or not the driver supports retuning list of created PKs back when multi-inserting
      */
@@ -78,15 +74,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
      */
@@ -133,7 +120,7 @@ export class Platform {
         return true;
     }
     isBigIntProperty(prop) {
-        return prop.columnTypes && prop.columnTypes[0] === 'bigint';
+        return prop.columnTypes?.[0] === 'bigint';
     }
     getDefaultSchemaName() {
         return undefined;
@@ -169,7 +156,7 @@ export class Platform {
         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);
@@ -269,7 +256,7 @@ export class Platform {
     getSearchJsonPropertyKey(path, type, aliased, value) {
         return path.join('.');
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     getJsonIndexDefinition(index) {
         return index.columnNames;
     }
@@ -288,11 +275,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) {
@@ -306,7 +289,7 @@ export class Platform {
     }
     parseDate(value) {
         const date = new Date(value);
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (isNaN(date.getTime())) {
             return value;
         }
@@ -336,19 +319,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 +330,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 +339,7 @@ export class Platform {
     quoteValue(value) {
         return value;
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     escape(value) {
         return value;
     }
@@ -455,7 +429,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 +449,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 +496,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

@@ -4,6 +4,7 @@ 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>>;
     private static propertyName;
     private static processProperty;
+    private static processCustomType;
     private static extractChildOptions;
     private static processEntity;
     private static processCollection;
@@ -17,10 +18,14 @@ export interface SerializeOptions<T, P extends string = never, E extends string
     forceObject?: boolean;
     /** Ignore custom property serializers. */
     ignoreSerializers?: boolean;
+    /** Include properties marked as `hidden`. */
+    includeHidden?: boolean;
     /** Skip properties with `null` value. */
     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.

package/serialization/EntitySerializer.js

@@ -15,8 +15,8 @@ function isVisible(meta, propName, options) {
     if (options.exclude?.find(item => item === propName)) {
         return false;
     }
-    const visible = prop && !prop.hidden;
-    const prefixed = prop && !prop.primary && propName.startsWith('_'); // ignore prefixed properties, if it's not a PK
+    const visible = prop && !(prop.hidden && !options.includeHidden);
+    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) {
@@ -41,23 +41,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 +85,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 +99,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 +137,7 @@ export class EntitySerializer {
             }
             return returnValue;
         }
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!options.ignoreSerializers && serializer) {
             return serializer(value);
         }
@@ -132,7 +150,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,12 +159,20 @@ 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,
@@ -165,10 +191,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 +215,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);
             }

package/serialization/EntityTransformer.js

@@ -6,7 +6,7 @@ import { isRaw } from '../utils/RawQueryFragment.js';
 function isVisible(meta, propName, ignoreFields = []) {
     const prop = meta.properties[propName];
     const visible = prop && !prop.hidden;
-    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 && !ignoreFields.includes(propName);
 }
 export class EntityTransformer {
@@ -27,39 +27,49 @@ export class EntityTransformer {
         const root = wrapped.__serializationContext.root;
         const meta = wrapped.__meta;
         const ret = {};
-        const keys = new Set();
+        const props = new Set();
         if (meta.serializedPrimaryKey && !meta.compositePK) {
-            keys.add(meta.serializedPrimaryKey);
+            props.add(meta.serializedPrimaryKey);
         }
         else {
-            meta.primaryKeys.forEach(pk => keys.add(pk));
+            meta.primaryKeys.forEach(pk => props.add(pk));
         }
         if (wrapped.isInitialized() || !wrapped.hasPrimaryKey()) {
-            Utils.keys(entity).forEach(prop => keys.add(prop));
+            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);
         const includePrimaryKeys = wrapped.__config.get('serialization').includePrimaryKeys;
         if (!visited) {
             root.visited.add(entity);
         }
-        for (const prop of keys) {
+        for (const prop of props) {
             const visible = raw ? meta.properties[prop] : isVisible(meta, prop, ignoreFields);
             if (!visible) {
                 continue;
             }
-            const populated = root.isMarkedAsPopulated(meta.className, prop);
-            const partiallyLoaded = root.isPartiallyLoaded(meta.className, prop);
+            const populated = root.isMarkedAsPopulated(meta.class, prop);
+            const partiallyLoaded = root.isPartiallyLoaded(meta.class, prop);
             const isPrimary = includePrimaryKeys && meta.properties[prop].primary;
             if (!partiallyLoaded && !populated && !isPrimary) {
                 continue;
             }
-            const cycle = root.visit(meta.className, prop);
+            const cycle = root.visit(meta.class, prop);
             if (cycle && visited) {
                 continue;
             }
             const val = EntityTransformer.processProperty(prop, entity, raw, populated);
             if (!cycle) {
-                root.leave(meta.className, prop);
+                root.leave(meta.class, prop);
             }
             if (isRaw(val)) {
                 throw new Error(`Trying to serialize raw SQL fragment: '${val.sql}'`);
@@ -67,7 +77,7 @@ export class EntityTransformer {
             if (typeof val === 'undefined') {
                 continue;
             }
-            ret[this.propertyName(meta, prop, wrapped.__platform, raw)] = val;
+            ret[this.propertyName(meta, prop, raw)] = val;
         }
         if (!wrapped.isInitialized() && wrapped.hasPrimaryKey()) {
             return ret;
@@ -76,17 +86,17 @@ export class EntityTransformer {
             // decorated get methods
             if (prop.getterName != null) {
                 const visible = !prop.hidden && entity[prop.getterName] instanceof Function;
-                const populated = root.isMarkedAsPopulated(meta.className, prop.name);
+                const populated = root.isMarkedAsPopulated(meta.class, prop.name);
                 if (visible) {
-                    ret[this.propertyName(meta, prop.name, wrapped.__platform, raw)] = this.processProperty(prop.getterName, entity, raw, populated);
+                    ret[this.propertyName(meta, prop.name, raw)] = this.processProperty(prop.getterName, entity, raw, populated);
                 }
             }
             else {
                 // decorated getters
                 const visible = !prop.hidden && typeof entity[prop.name] !== 'undefined';
-                const populated = root.isMarkedAsPopulated(meta.className, prop.name);
+                const populated = root.isMarkedAsPopulated(meta.class, prop.name);
                 if (visible) {
-                    ret[this.propertyName(meta, prop.name, wrapped.__platform, raw)] = this.processProperty(prop.name, entity, raw, populated);
+                    ret[this.propertyName(meta, prop.name, raw)] = this.processProperty(prop.name, entity, raw, populated);
                 }
             }
         }
@@ -95,15 +105,15 @@ export class EntityTransformer {
         }
         return ret;
     }
-    static propertyName(meta, prop, platform, raw) {
+    static propertyName(meta, prop, raw) {
         if (raw) {
             return prop;
         }
         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;
     }