@mikro-orm/core 7.0.0-rc.2 → 7.0.0-rc.3

package/unit-of-work/UnitOfWork.js

@@ -76,7 +76,8 @@ export class UnitOfWork {
             if (!prop) {
                 continue;
             }
-            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+                Utils.isPlainObject(data[prop.name])) {
                 // Skip polymorphic relations - they use PolymorphicRef wrapper
                 if (!prop.polymorphic) {
                     data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
@@ -86,12 +87,16 @@ export class UnitOfWork {
                 for (const p of prop.targetMeta.props) {
                     /* v8 ignore next */
                     const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
-                    data[prefix + p.name] = data[prop.name][p.name];
+                    data[(prefix + p.name)] = data[prop.name][p.name];
                 }
                 data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
             }
             if (prop.hydrate === false && prop.customType?.ensureComparable(meta, prop)) {
-                const converted = prop.customType.convertToJSValue(data[key], this.platform, { key, mode: 'hydration', force: true });
+                const converted = prop.customType.convertToJSValue(data[key], this.platform, {
+                    key,
+                    mode: 'hydration',
+                    force: true,
+                });
                 data[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { key, mode: 'hydration' });
             }
             if (forceUndefined) {
@@ -423,7 +428,10 @@ export class UnitOfWork {
                 if (Utils.isCollection(rel)) {
                     rel.removeWithoutPropagation(entity);
                 }
-                else if (rel && (prop.mapToPk ? helper(this.em.getReference(prop.targetMeta.class, rel)).getSerializedPrimaryKey() === serializedPK : rel === entity)) {
+                else if (rel &&
+                    (prop.mapToPk
+                        ? helper(this.em.getReference(prop.targetMeta.class, rel)).getSerializedPrimaryKey() === serializedPK
+                        : rel === entity)) {
                     if (prop.formula) {
                         delete referrer[prop.name];
                     }
@@ -512,7 +520,13 @@ export class UnitOfWork {
         if (!conflicts) {
             return;
         }
-        this.extraUpdates.add([changeSet.entity, props.map(p => p.name), props.map(p => changeSet.entity[p.name]), changeSet, type]);
+        this.extraUpdates.add([
+            changeSet.entity,
+            props.map(p => p.name),
+            props.map(p => changeSet.entity[p.name]),
+            changeSet,
+            type,
+        ]);
         for (const p of props) {
             delete changeSet.entity[p.name];
             delete changeSet.payload[p.name];
@@ -633,7 +647,7 @@ export class UnitOfWork {
         // when changing a unique nullable property (or a 1:1 relation), we can't do it in a single
         // query as it would cause unique constraint violations
         const uniqueProps = changeSet.meta.uniqueProps.filter(prop => {
-            return (prop.nullable || changeSet.type !== ChangeSetType.CREATE);
+            return prop.nullable || changeSet.type !== ChangeSetType.CREATE;
         });
         this.scheduleExtraUpdate(changeSet, uniqueProps);
         return changeSet.type === ChangeSetType.UPDATE && !Utils.hasObjectKeys(changeSet.payload);
@@ -643,25 +657,33 @@ export class UnitOfWork {
         if (!wrapped.__meta.hasUniqueProps) {
             return [];
         }
-        const simpleUniqueHashes = wrapped.__meta.uniqueProps.map(prop => {
+        const simpleUniqueHashes = wrapped.__meta.uniqueProps
+            .map(prop => {
             if (entity[prop.name] != null) {
-                return prop.kind === ReferenceKind.SCALAR || prop.mapToPk ? entity[prop.name] : helper(entity[prop.name]).getSerializedPrimaryKey();
+                return prop.kind === ReferenceKind.SCALAR || prop.mapToPk
+                    ? entity[prop.name]
+                    : helper(entity[prop.name]).getSerializedPrimaryKey();
             }
             if (wrapped.__originalEntityData?.[prop.name] != null) {
                 return Utils.getPrimaryKeyHash(Utils.asArray(wrapped.__originalEntityData[prop.name]));
             }
             return undefined;
-        }).filter(i => i);
-        const compoundUniqueHashes = wrapped.__meta.uniques.map(unique => {
+        })
+            .filter(i => i);
+        const compoundUniqueHashes = wrapped.__meta.uniques
+            .map(unique => {
             const props = Utils.asArray(unique.properties);
             if (props.every(prop => entity[prop] != null)) {
                 return Utils.getPrimaryKeyHash(props.map(p => {
                     const prop = wrapped.__meta.properties[p];
-                    return prop.kind === ReferenceKind.SCALAR || prop.mapToPk ? entity[prop.name] : helper(entity[prop.name]).getSerializedPrimaryKey();
+                    return prop.kind === ReferenceKind.SCALAR || prop.mapToPk
+                        ? entity[prop.name]
+                        : helper(entity[prop.name]).getSerializedPrimaryKey();
                 }));
             }
             return undefined;
-        }).filter(i => i);
+        })
+            .filter(i => i);
         return simpleUniqueHashes.concat(compoundUniqueHashes);
     }
     initIdentifier(entity) {
@@ -693,7 +715,8 @@ export class UnitOfWork {
             return this.processToOneReference(kind, visited, processed, idx);
         }
         if (Utils.isCollection(kind)) {
-            kind.getItems(false)
+            kind
+                .getItems(false)
                 .filter(item => !item.__helper.__originalEntityData)
                 .forEach(item => {
                 // propagate schema from parent
@@ -717,7 +740,8 @@ export class UnitOfWork {
             parent[prop.name] = coll;
             return;
         }
-        collection.getItems(false)
+        collection
+            .getItems(false)
             .filter(item => !item.__helper.__originalEntityData)
             .forEach(item => this.findNewEntities(item, visited, 0, processed));
     }
@@ -809,7 +833,8 @@ export class UnitOfWork {
         return filtered.some(items => processed.has(items));
     }
     shouldCascade(prop, type) {
-        if ([Cascade.REMOVE, Cascade.SCHEDULE_ORPHAN_REMOVAL, Cascade.CANCEL_ORPHAN_REMOVAL, Cascade.ALL].includes(type) && prop.orphanRemoval) {
+        if ([Cascade.REMOVE, Cascade.SCHEDULE_ORPHAN_REMOVAL, Cascade.CANCEL_ORPHAN_REMOVAL, Cascade.ALL].includes(type) &&
+            prop.orphanRemoval) {
             return true;
         }
         // ignore user settings for merge, it is kept only for back compatibility, this should have never been configurable
@@ -845,7 +870,9 @@ export class UnitOfWork {
         const target = Reference.unwrapReference(reference);
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && target && !prop.mapToPk) {
             if (!Utils.isEntity(target)) {
-                entity[prop.name] = this.em.getReference(prop.targetMeta.class, target, { wrapped: !!prop.ref });
+                entity[prop.name] = this.em.getReference(prop.targetMeta.class, target, {
+                    wrapped: !!prop.ref,
+                });
             }
             else if (!helper(target).__initialized && !helper(target).__em) {
                 const pk = helper(target).getPrimaryKey();
@@ -907,9 +934,9 @@ export class UnitOfWork {
             return;
         }
         const props = changeSets[0].meta.root.relations.filter(prop => {
-            return (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner)
-                || prop.kind === ReferenceKind.MANY_TO_ONE
-                || (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.platform.usesPivotTable());
+            return ((prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner) ||
+                prop.kind === ReferenceKind.MANY_TO_ONE ||
+                (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.platform.usesPivotTable()));
         });
         for (const changeSet of changeSets) {
             this.findExtraUpdates(changeSet, props);
@@ -984,7 +1011,8 @@ export class UnitOfWork {
             wrapped.__originalEntityData = this.comparator.prepareEntity(changeSet.entity);
             if (!wrapped.__initialized) {
                 for (const prop of changeSet.meta.relations) {
-                    if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) && changeSet.entity[prop.name] == null) {
+                    if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) &&
+                        changeSet.entity[prop.name] == null) {
                         changeSet.entity[prop.name] = Collection.create(changeSet.entity, prop.name, undefined, wrapped.isInitialized());
                     }
                 }
@@ -1013,7 +1041,7 @@ export class UnitOfWork {
                 continue;
             }
             if (Array.isArray(extraUpdate[1])) {
-                extraUpdate[1].forEach((p, i) => extraUpdate[0][p] = extraUpdate[2][i]);
+                extraUpdate[1].forEach((p, i) => (extraUpdate[0][p] = extraUpdate[2][i]));
             }
             else {
                 extraUpdate[0][extraUpdate[1]] = extraUpdate[2];
@@ -1075,7 +1103,8 @@ export class UnitOfWork {
         };
         const addToGroup = (cs) => {
             // Skip stub TPT changesets with empty payload (e.g. leaf with no own-property changes on UPDATE)
-            if ((cs.type === ChangeSetType.UPDATE || cs.type === ChangeSetType.UPDATE_EARLY) && !Utils.hasObjectKeys(cs.payload)) {
+            if ((cs.type === ChangeSetType.UPDATE || cs.type === ChangeSetType.UPDATE_EARLY) &&
+                !Utils.hasObjectKeys(cs.payload)) {
                 return;
             }
             const group = groups[cs.type];

package/utils/AbstractMigrator.d.ts

@@ -95,7 +95,7 @@ export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implem
     private filterDown;
     private getMigrationFilename;
     private prefix;
-    private runMigrations;
+    protected runMigrations(method: 'up' | 'down', options?: string | string[] | MigrateOptions): Promise<MigrationInfo[]>;
     private runInTransaction;
 }
 export {};

package/utils/AbstractMigrator.js

@@ -49,9 +49,7 @@ export class AbstractMigrator {
         await this.init();
         const all = await this.discoverMigrations();
         const executed = new Set(await this.storage.executed());
-        return all
-            .filter(m => !executed.has(m.name))
-            .map(m => ({ name: m.name, path: m.path }));
+        return all.filter(m => !executed.has(m.name)).map(m => ({ name: m.name, path: m.path }));
     }
     /**
      * @inheritDoc
@@ -74,7 +72,7 @@ export class AbstractMigrator {
             const { fs } = await import('@mikro-orm/core/fs-utils');
             this.detectSourceFolder(fs);
             /* v8 ignore next */
-            const key = (this.config.get('preferTs', Utils.detectTypeScriptSupport()) && this.options.pathTs) ? 'pathTs' : 'path';
+            const key = this.config.get('preferTs', Utils.detectTypeScriptSupport()) && this.options.pathTs ? 'pathTs' : 'path';
             this.absolutePath = fs.absolutePath(this.options[key], this.config.get('baseDir'));
             fs.ensureDir(this.absolutePath);
         }
@@ -132,7 +130,7 @@ export class AbstractMigrator {
         const buildDir = fs.pathExists(baseDir + '/build');
         // if neither `dist` nor `build` exist, we use the `src` folder as it might be a JS project without building, but with `src` folder
         /* v8 ignore next */
-        const path = distDir ? './dist' : (buildDir ? './build' : './src');
+        const path = distDir ? './dist' : buildDir ? './build' : './src';
         // only if the user did not provide any values and if the default path does not exist
         if (!this.options.path && !this.options.pathTs && !exists) {
             this.options.path = `${path}/migrations`;

package/utils/AbstractSchemaGenerator.js

@@ -112,7 +112,8 @@ export class AbstractSchemaGenerator {
             }
             meta = metadata.pop();
         }
-        return calc.sort()
+        return calc
+            .sort()
             .map(cls => this.metadata.getById(cls))
             .filter(meta => {
             const targetSchema = meta.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());

package/utils/AsyncContext.js

@@ -13,7 +13,7 @@ function createFallbackAsyncContext() {
     console.warn('AsyncLocalStorage not available');
     return {
         getStore: () => store,
-        enterWith: value => store = value,
+        enterWith: value => (store = value),
         run: (value, cb) => {
             const prev = store;
             store = value;

package/utils/Configuration.js

@@ -262,7 +262,10 @@ export class Configuration {
      * Gets instance of CacheAdapter for result cache. (cached)
      */
     getResultCacheAdapter() {
-        return this.getCachedService(this.options.resultCache.adapter, { expiration: this.options.resultCache.expiration, ...this.options.resultCache.options });
+        return this.getCachedService(this.options.resultCache.adapter, {
+            expiration: this.options.resultCache.expiration,
+            ...this.options.resultCache.options,
+        });
     }
     /**
      * Gets EntityRepository class to be instantiated.
@@ -338,10 +341,10 @@ export class Configuration {
     validateOptions() {
         /* v8 ignore next */
         if ('type' in this.options) {
-            throw new Error('The `type` option has been removed in v6, please fill in the `driver` option instead or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from \'@mikro-orm/mysql\'; export default defineConfig({ ... })`).');
+            throw new Error("The `type` option has been removed in v6, please fill in the `driver` option instead or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from '@mikro-orm/mysql'; export default defineConfig({ ... })`).");
         }
         if (!this.options.driver) {
-            throw new Error('No driver specified, please fill in the `driver` option or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from \'@mikro-orm/mysql\'; export defineConfig({ ... })`).');
+            throw new Error("No driver specified, please fill in the `driver` option or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from '@mikro-orm/mysql'; export defineConfig({ ... })`).");
         }
         if (!this.options.dbName && !this.options.clientUrl) {
             throw new Error('No database specified, please fill in `dbName` or `clientUrl` option');
@@ -349,7 +352,8 @@ export class Configuration {
         if (this.options.entities.length === 0 && this.options.discovery.warnWhenNoEntities) {
             throw new Error('No entities found, please use `entities` option');
         }
-        if (typeof this.options.driverOptions === 'function' && this.options.driverOptions.constructor.name === 'AsyncFunction') {
+        if (typeof this.options.driverOptions === 'function' &&
+            this.options.driverOptions.constructor.name === 'AsyncFunction') {
             throw new Error('`driverOptions` callback cannot be async');
         }
     }

package/utils/Cursor.js

@@ -118,7 +118,7 @@ export class Cursor {
                 value = value.unwrap();
             }
             if (object) {
-                return ({ [prop]: value });
+                return { [prop]: value };
             }
             return value;
         };
@@ -167,7 +167,9 @@ export class Cursor {
                 }
                 const prop = meta.properties[key];
                 /* v8 ignore next */
-                if (!prop || !([ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
+                if (!prop ||
+                    !([ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE].includes(prop.kind) ||
+                        (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
                     continue;
                 }
                 ret.push([prop.name, order[prop.name]]);

package/utils/DataloaderUtils.js

@@ -101,26 +101,27 @@ export class DataloaderUtils {
             const uniqueName = key.substring(0, key.indexOf('|'));
             const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
             const meta = em.getMetadata().getByUniqueName(uniqueName);
-            const res = await em.find(meta.class, opts?.where != null && Object.keys(opts.where).length > 0 ?
-                {
+            const res = await em.find(meta.class, opts?.where != null && Object.keys(opts.where).length > 0
+                ? {
                     $and: [
                         {
                             $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
-                                return ({ [prop]: Array.from(pks) });
+                                return { [prop]: Array.from(pks) };
                             }),
                         },
                         opts.where,
                     ],
-                } : {
-                // The entries of the filter Map will be used as the values of the $or operator
-                $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
-                    return ({ [prop]: Array.from(pks) });
-                }),
-            }, {
+                }
+                : {
+                    // The entries of the filter Map will be used as the values of the $or operator
+                    $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
+                        return { [prop]: Array.from(pks) };
+                    }),
+                }, {
                 ...opts,
                 // We need to populate the inverse side of the relationship in order to be able to later retrieve the PK(s) from its item(s)
                 populate: [
-                    ...(opts.populate === false ? [] : opts.populate ?? []),
+                    ...(opts.populate === false ? [] : (opts.populate ?? [])),
                     ...Array.from(filterMap.keys()).filter(
                     // We need to do so only if the inverse side is a collection, because we can already retrieve the PK from a reference without having to load it
                     prop => meta.properties[prop]?.ref !== true),
@@ -207,7 +208,9 @@ export class DataloaderUtils {
                     options.refresh ??= c[1]?.refresh;
                 }
                 options.where = wrap({ $or });
-                const r = await em.getEntityLoader().findChildrenFromPivotTable(owners, prop, options, orderBy, populate, group[0][1]?.ref);
+                const r = await em
+                    .getEntityLoader()
+                    .findChildrenFromPivotTable(owners, prop, options, orderBy, populate, group[0][1]?.ref);
                 ret.push(...r);
             }
             return ret;
@@ -224,7 +227,7 @@ export class DataloaderUtils {
         }
         catch {
             /* v8 ignore next */
-            throw new Error('DataLoader is not found, make sure `dataloader` package is installed in your project\'s dependencies.');
+            throw new Error("DataLoader is not found, make sure `dataloader` package is installed in your project's dependencies.");
         }
     }
 }

package/utils/EntityComparator.js

@@ -1,6 +1,6 @@
 import { clone } from './clone.js';
 import { ReferenceKind } from '../enums.js';
-import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils } from './Utils.js';
+import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils, } from './Utils.js';
 import { JsonType } from '../types/JsonType.js';
 import { Raw } from './RawQueryFragment.js';
 import { EntityIdentifier } from '../entity/EntityIdentifier.js';
@@ -91,8 +91,7 @@ export class EntityComparator {
             }
             lines.push(`  return entity${this.wrap(pk)};`);
         }
-        const code = `// compiled pk getter for entity ${meta.className}\n`
-            + `return function(entity) {\n${lines.join('\n')}\n}`;
+        const code = `// compiled pk getter for entity ${meta.className}\n` + `return function(entity) {\n${lines.join('\n')}\n}`;
         const fnKey = `pkGetter-${meta.uniqueName}`;
         const pkSerializer = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
         this.pkGetters.set(meta, pkSerializer);
@@ -142,8 +141,8 @@ export class EntityComparator {
                 lines.push(`  return entity${this.wrap(pk)};`);
             }
         }
-        const code = `// compiled pk getter (with converted custom types) for entity ${meta.className}\n`
-            + `return function(entity) {\n${lines.join('\n')}\n}`;
+        const code = `// compiled pk getter (with converted custom types) for entity ${meta.className}\n` +
+            `return function(entity) {\n${lines.join('\n')}\n}`;
         const fnKey = `pkGetterConverted-${meta.uniqueName}`;
         const pkSerializer = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
         this.pkGettersConverted.set(meta, pkSerializer);
@@ -195,8 +194,7 @@ export class EntityComparator {
                 lines.push(`  return '' + entity${this.wrap(pk)};`);
             }
         }
-        const code = `// compiled pk serializer for entity ${meta.className}\n`
-            + `return function(entity) {\n${lines.join('\n')}\n}`;
+        const code = `// compiled pk serializer for entity ${meta.className}\n` + `return function(entity) {\n${lines.join('\n')}\n}`;
         const fnKey = `pkSerializer-${meta.uniqueName}`;
         const pkSerializer = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
         this.pkSerializers.set(meta, pkSerializer);
@@ -359,7 +357,7 @@ export class EntityComparator {
                     context.set(`mapEmbeddedResult_${idx}`, (data) => {
                         const item = parseJsonSafe(data);
                         if (Array.isArray(item)) {
-                            return item.map(row => row == null ? row : this.getResultMapper(prop.targetMeta)(row));
+                            return item.map(row => (row == null ? row : this.getResultMapper(prop.targetMeta)(row)));
                         }
                         return item == null ? item : this.getResultMapper(prop.targetMeta)(item);
                     });
@@ -391,8 +389,8 @@ export class EntityComparator {
             mapEntityProperties(meta);
         }
         lines.push(`  for (let k in result) { if (Object.hasOwn(result, k) && !mapped[k] && ret[k] === undefined) ret[k] = result[k]; }`);
-        const code = `// compiled mapper for entity ${meta.className}\n`
-            + `return function(result) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
+        const code = `// compiled mapper for entity ${meta.className}\n` +
+            `return function(result) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
         const fnKey = `resultMapper-${meta.uniqueName}`;
         const resultMapper = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
         this.mappers.set(meta, resultMapper);
@@ -411,7 +409,7 @@ export class EntityComparator {
                 return '';
             }
             const mapped = `typeof entity${tail ? '.' + tail : ''}${this.wrap(k)} !== 'undefined'`;
-            tail += tail ? ('.' + k) : k;
+            tail += tail ? '.' + k : k;
             return mapped;
         })
             .filter(k => k)
@@ -453,12 +451,16 @@ export class EntityComparator {
         }
         else {
             ret += `${padding}if (${nullCond}) {\n`;
-            ret += meta.props.filter(p => p.embedded?.[0] === prop.name
-                // object for JSON embeddable
-                && (p.object || (p.persist !== false))).map(childProp => {
-                const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
-                return `${padding}  ret${childDataKey} = null;`;
-            }).join('\n') + `\n`;
+            ret +=
+                meta.props
+                    .filter(p => p.embedded?.[0] === prop.name &&
+                    // object for JSON embeddable
+                    (p.object || p.persist !== false))
+                    .map(childProp => {
+                    const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                    return `${padding}  ret${childDataKey} = null;`;
+                })
+                    .join('\n') + `\n`;
             ret += `${padding}}\n`;
         }
         const cond = `entity${path.map(k => this.wrap(k)).join('')} != null`;
@@ -475,28 +477,34 @@ export class EntityComparator {
             }
             return true;
         }
-        ret += meta.props.filter(p => p.embedded?.[0] === prop.name
-            // object for JSON embeddable
-            && (p.object || (p.persist !== false))).map(childProp => {
-            const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
-            const childEntityKey = [...path, childProp.embedded[1]].map(k => this.wrap(k)).join('');
-            const childCond = `typeof entity${childEntityKey} !== 'undefined'`;
-            if (childProp.kind === ReferenceKind.EMBEDDED) {
-                return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level + 1, prop.object);
-            }
-            if (childProp.kind !== ReferenceKind.SCALAR) {
-                return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level, prop.object)
-                    .split('\n').map(l => padding + l).join('\n');
-            }
-            if (shouldProcessCustomType(childProp)) {
-                const convertorKey = this.registerCustomType(childProp, context);
-                if (['number', 'string', 'boolean', 'bigint'].includes(childProp.customType.compareAsType().toLowerCase())) {
-                    return `${padding}  if (${childCond}) ret${childDataKey} = convertToDatabaseValue_${convertorKey}(entity${childEntityKey});`;
+        ret +=
+            meta.props
+                .filter(p => p.embedded?.[0] === prop.name &&
+                // object for JSON embeddable
+                (p.object || p.persist !== false))
+                .map(childProp => {
+                const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                const childEntityKey = [...path, childProp.embedded[1]].map(k => this.wrap(k)).join('');
+                const childCond = `typeof entity${childEntityKey} !== 'undefined'`;
+                if (childProp.kind === ReferenceKind.EMBEDDED) {
+                    return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level + 1, prop.object);
                 }
-                return `${padding}  if (${childCond}) ret${childDataKey} = clone(convertToDatabaseValue_${convertorKey}(entity${childEntityKey}));`;
-            }
-            return `${padding}  if (${childCond}) ret${childDataKey} = clone(entity${childEntityKey});`;
-        }).join('\n') + `\n`;
+                if (childProp.kind !== ReferenceKind.SCALAR) {
+                    return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level, prop.object)
+                        .split('\n')
+                        .map(l => padding + l)
+                        .join('\n');
+                }
+                if (shouldProcessCustomType(childProp)) {
+                    const convertorKey = this.registerCustomType(childProp, context);
+                    if (['number', 'string', 'boolean', 'bigint'].includes(childProp.customType.compareAsType().toLowerCase())) {
+                        return `${padding}  if (${childCond}) ret${childDataKey} = convertToDatabaseValue_${convertorKey}(entity${childEntityKey});`;
+                    }
+                    return `${padding}  if (${childCond}) ret${childDataKey} = clone(convertToDatabaseValue_${convertorKey}(entity${childEntityKey}));`;
+                }
+                return `${padding}  if (${childCond}) ret${childDataKey} = clone(entity${childEntityKey});`;
+            })
+                .join('\n') + `\n`;
         if (this.shouldSerialize(prop, dataKey)) {
             return `${ret + padding}  ret${dataKey} = cloneEmbeddable(ret${dataKey});\n${padding}}`;
         }
@@ -591,7 +599,7 @@ export class EntityComparator {
             if (['number', 'string', 'boolean', 'bigint'].includes(prop.customType.compareAsType().toLowerCase())) {
                 return ret + `    ret${dataKey} = convertToDatabaseValue_${convertorKey}(entity${entityKey}${unwrap});\n  }\n`;
             }
-            return ret + `    ret${dataKey} = clone(convertToDatabaseValue_${convertorKey}(entity${entityKey}${unwrap}));\n  }\n`;
+            return (ret + `    ret${dataKey} = clone(convertToDatabaseValue_${convertorKey}(entity${entityKey}${unwrap}));\n  }\n`);
         }
         if (prop.runtimeType === 'Date') {
             context.set('processDateProperty', this.platform.processDateProperty.bind(this.platform));
@@ -626,22 +634,22 @@ export class EntityComparator {
             }
         }
         lines.push(`}`);
-        const code = `// compiled comparator for entity ${meta.className}\n`
-            + `return function(last, current, options) {\n  const diff = {};\n${lines.join('\n')}\n  return diff;\n}`;
+        const code = `// compiled comparator for entity ${meta.className}\n` +
+            `return function(last, current, options) {\n  const diff = {};\n${lines.join('\n')}\n  return diff;\n}`;
         const fnKey = `comparator-${meta.uniqueName}`;
         const comparator = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
         this.comparators.set(meta, comparator);
         return comparator;
     }
     getGenericComparator(prop, cond) {
-        return `  if (current${prop} === null && last${prop} === undefined) {\n` +
+        return (`  if (current${prop} === null && last${prop} === undefined) {\n` +
             `    diff${prop} = current${prop};\n` +
             `  } else if (current${prop} == null && last${prop} == null) {\n\n` +
             `  } else if ((current${prop} != null && last${prop} == null) || (current${prop} == null && last${prop} != null)) {\n` +
             `    diff${prop} = current${prop};\n` +
             `  } else if (${cond}) {\n` +
             `    diff${prop} = current${prop};\n` +
-            `  }\n`;
+            `  }\n`);
     }
     getPropertyComparator(prop, context) {
         let type = prop.type.toLowerCase();