@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.100

package/serialization/EntitySerializer.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntitySerializer = void 0;
-exports.serialize = serialize;
-const wrap_1 = require("../entity/wrap");
-const Utils_1 = require("../utils/Utils");
-const enums_1 = require("../enums");
-const Reference_1 = require("../entity/Reference");
-const SerializationContext_1 = require("./SerializationContext");
-const RawQueryFragment_1 = require("../utils/RawQueryFragment");
+import { helper } from '../entity/wrap.js';
+import { Utils } from '../utils/Utils.js';
+import { ReferenceKind } from '../enums.js';
+import { Reference } from '../entity/Reference.js';
+import { SerializationContext } from './SerializationContext.js';
+import { isRaw } from '../utils/RawQueryFragment.js';
 function isVisible(meta, propName, options) {
     const prop = meta.properties[propName];
     if (options.groups && prop?.groups) {
@@ -19,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) {
@@ -32,26 +28,44 @@ function isPopulated(propName, options) {
     }
     return false;
 }
-class EntitySerializer {
+export class EntitySerializer {
     static serialize(entity, options = {}) {
-        const wrapped = (0, wrap_1.helper)(entity);
+        const wrapped = helper(entity);
         const meta = wrapped.__meta;
         let contextCreated = false;
         if (!wrapped.__serializationContext.root) {
-            const root = new SerializationContext_1.SerializationContext(wrapped.__config);
-            SerializationContext_1.SerializationContext.propagate(root, entity, (meta, prop) => meta.properties[prop]?.kind !== enums_1.ReferenceKind.SCALAR);
-            options.populate = (options.populate ? Utils_1.Utils.asArray(options.populate) : options.populate);
+            const root = new SerializationContext(wrapped.__config);
+            SerializationContext.propagate(root, entity, (meta, prop) => meta.properties[prop]?.kind !== ReferenceKind.SCALAR);
+            options.populate = (options.populate ? Utils.asArray(options.populate) : options.populate);
             contextCreated = true;
         }
         const root = wrapped.__serializationContext.root;
         const ret = {};
-        const keys = new Set(meta.primaryKeys);
-        Utils_1.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;
             }
@@ -63,15 +77,15 @@ class EntitySerializer {
             if (!cycle) {
                 root.leave(meta.className, prop);
             }
-            if (options.skipNull && Utils_1.Utils.isPlainObject(val)) {
-                Utils_1.Utils.dropUndefinedProperties(val, null);
+            if (options.skipNull && Utils.isPlainObject(val)) {
+                Utils.dropUndefinedProperties(val, null);
             }
-            if ((0, RawQueryFragment_1.isRaw)(val)) {
+            if (isRaw(val)) {
                 throw new Error(`Trying to serialize raw SQL fragment: '${val.sql}'`);
             }
             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) {
@@ -85,33 +99,33 @@ 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) {
-        /* istanbul ignore next */
+    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;
     }
     static processProperty(prop, entity, options) {
         const parts = prop.split('.');
         prop = parts[0];
-        const wrapped = (0, wrap_1.helper)(entity);
+        const wrapped = helper(entity);
         const property = wrapped.__meta.properties[prop] ?? { name: prop };
         const serializer = property?.serializer;
         const value = entity[prop];
@@ -123,26 +137,26 @@ class EntitySerializer {
             }
             return returnValue;
         }
-        /* istanbul ignore next */
+        /* v8 ignore next */
         if (!options.ignoreSerializers && serializer) {
             return serializer(value);
         }
-        if (Utils_1.Utils.isCollection(value)) {
+        if (Utils.isCollection(value)) {
             return this.processCollection(property, entity, options);
         }
-        if (Utils_1.Utils.isEntity(value, true)) {
+        if (Utils.isEntity(value, true)) {
             return this.processEntity(property, entity, wrapped.__platform, options);
         }
-        if (Utils_1.Utils.isScalarReference(value)) {
+        if (Utils.isScalarReference(value)) {
             return value.unwrap();
         }
-        /* istanbul ignore next */
-        if (property?.kind === enums_1.ReferenceKind.EMBEDDED) {
+        /* v8 ignore next */
+        if (property?.kind === ReferenceKind.EMBEDDED) {
             if (Array.isArray(value)) {
-                return value.map(item => (0, wrap_1.helper)(item).toJSON());
+                return value.map(item => helper(item).toJSON());
             }
-            if (Utils_1.Utils.isObject(value)) {
-                return (0, wrap_1.helper)(value).toJSON();
+            if (Utils.isObject(value)) {
+                return helper(value).toJSON();
             }
         }
         const customType = property?.customType;
@@ -154,13 +168,13 @@ class EntitySerializer {
     static extractChildOptions(options, prop) {
         return {
             ...options,
-            populate: Array.isArray(options.populate) ? Utils_1.Utils.extractChildElements(options.populate, prop, '*') : options.populate,
-            exclude: Array.isArray(options.exclude) ? Utils_1.Utils.extractChildElements(options.exclude, prop) : options.exclude,
+            populate: Array.isArray(options.populate) ? Utils.extractChildElements(options.populate, prop, '*') : options.populate,
+            exclude: Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop) : options.exclude,
         };
     }
     static processEntity(prop, entity, platform, options) {
-        const child = Reference_1.Reference.unwrapReference(entity[prop.name]);
-        const wrapped = (0, wrap_1.helper)(child);
+        const child = Reference.unwrapReference(entity[prop.name]);
+        const wrapped = helper(child);
         const populated = isPopulated(prop.name, options) && wrapped.isInitialized();
         const expand = populated || !wrapped.__managed;
         const meta = wrapped.__meta;
@@ -174,10 +188,10 @@ class EntitySerializer {
             pk = prop.customType.toJSON(pk, wrapped.__platform);
         }
         if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
-            return Utils_1.Utils.primaryKeyToObject(meta, pk, visible);
+            return Utils.primaryKeyToObject(meta, pk, visible);
         }
-        if (Utils_1.Utils.isPlainObject(pk)) {
-            const pruned = Utils_1.Utils.primaryKeyToObject(meta, pk, visible);
+        if (Utils.isPlainObject(pk)) {
+            const pruned = Utils.primaryKeyToObject(meta, pk, visible);
             if (visible.length === 1) {
                 return platform.normalizePrimaryKey(pruned[visible[0]]);
             }
@@ -192,7 +206,7 @@ class EntitySerializer {
         }
         return col.getItems(false).map(item => {
             const populated = isPopulated(prop.name, options);
-            const wrapped = (0, wrap_1.helper)(item);
+            const wrapped = helper(item);
             if (populated || !wrapped.__managed) {
                 return this.serialize(item, this.extractChildOptions(options, prop.name));
             }
@@ -201,13 +215,12 @@ class EntitySerializer {
                 pk = prop.customType.toJSON(pk, wrapped.__platform);
             }
             if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
-                return Utils_1.Utils.primaryKeyToObject(wrapped.__meta, pk);
+                return Utils.primaryKeyToObject(wrapped.__meta, pk);
             }
             return pk;
         });
     }
 }
-exports.EntitySerializer = EntitySerializer;
 /**
  * Converts entity instance to POJO, converting the `Collection`s to arrays and unwrapping the `Reference` wrapper, while respecting the serialization options.
  * This method accepts either a single entity or an array of entities, and returns the corresponding POJO or an array of POJO.
@@ -220,7 +233,7 @@ exports.EntitySerializer = EntitySerializer;
  * const dto2 = wrap(user).serialize({ exclude: ['id', 'email'], forceObject: true });
  * ```
  */
-function serialize(entities, options) {
+export function serialize(entities, options) {
     if (Array.isArray(entities)) {
         return entities.map(e => EntitySerializer.serialize(e, options));
     }

package/serialization/EntityTransformer.d.ts

@@ -1,4 +1,4 @@
-import type { EntityDTO, EntityKey } from '../typings';
+import type { EntityDTO, EntityKey } from '../typings.js';
 export declare class EntityTransformer {
     static toObject<Entity extends object, Ignored extends EntityKey<Entity> = never>(entity: Entity, ignoreFields?: Ignored[], raw?: boolean): Omit<EntityDTO<Entity>, Ignored>;
     private static propertyName;

package/serialization/EntityTransformer.js

@@ -1,51 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityTransformer = void 0;
-const wrap_1 = require("../entity/wrap");
-const Utils_1 = require("../utils/Utils");
-const enums_1 = require("../enums");
-const SerializationContext_1 = require("./SerializationContext");
-const RawQueryFragment_1 = require("../utils/RawQueryFragment");
+import { helper, wrap } from '../entity/wrap.js';
+import { Utils } from '../utils/Utils.js';
+import { ReferenceKind } from '../enums.js';
+import { SerializationContext } from './SerializationContext.js';
+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);
 }
-class EntityTransformer {
+export class EntityTransformer {
     static toObject(entity, ignoreFields = [], raw = false) {
         if (!Array.isArray(ignoreFields)) {
             ignoreFields = [];
         }
-        const wrapped = (0, wrap_1.helper)(entity);
+        const wrapped = helper(entity);
         let contextCreated = false;
         if (!wrapped) {
             return entity;
         }
         if (!wrapped.__serializationContext.root) {
-            const root = new SerializationContext_1.SerializationContext(wrapped.__config, wrapped.__serializationContext.populate, wrapped.__serializationContext.fields, wrapped.__serializationContext.exclude);
-            SerializationContext_1.SerializationContext.propagate(root, entity, isVisible);
+            const root = new SerializationContext(wrapped.__config, wrapped.__serializationContext.populate, wrapped.__serializationContext.fields, wrapped.__serializationContext.exclude);
+            SerializationContext.propagate(root, entity, isVisible);
             contextCreated = true;
         }
         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_1.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;
@@ -64,13 +71,13 @@ class EntityTransformer {
             if (!cycle) {
                 root.leave(meta.className, prop);
             }
-            if ((0, RawQueryFragment_1.isRaw)(val)) {
+            if (isRaw(val)) {
                 throw new Error(`Trying to serialize raw SQL fragment: '${val.sql}'`);
             }
             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;
@@ -81,7 +88,7 @@ class EntityTransformer {
                 const visible = !prop.hidden && entity[prop.getterName] instanceof Function;
                 const populated = root.isMarkedAsPopulated(meta.className, 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 {
@@ -89,7 +96,7 @@ class EntityTransformer {
                 const visible = !prop.hidden && typeof entity[prop.name] !== 'undefined';
                 const populated = root.isMarkedAsPopulated(meta.className, 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);
                 }
             }
         }
@@ -98,20 +105,20 @@ 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;
     }
     static processProperty(prop, entity, raw, populated) {
-        const wrapped = (0, wrap_1.helper)(entity);
+        const wrapped = helper(entity);
         const property = wrapped.__meta.properties[prop] ?? { name: prop };
         const serializer = property?.serializer;
         const value = entity[prop];
@@ -126,23 +133,23 @@ class EntityTransformer {
         if (serializer && !raw) {
             return serializer(value);
         }
-        if (Utils_1.Utils.isCollection(value)) {
+        if (Utils.isCollection(value)) {
             return EntityTransformer.processCollection(property, entity, raw, populated);
         }
-        if (Utils_1.Utils.isEntity(value, true)) {
+        if (Utils.isEntity(value, true)) {
             return EntityTransformer.processEntity(property, entity, wrapped.__platform, raw, populated);
         }
-        if (Utils_1.Utils.isScalarReference(value)) {
+        if (Utils.isScalarReference(value)) {
             return value.unwrap();
         }
-        if (property.kind === enums_1.ReferenceKind.EMBEDDED) {
+        if (property.kind === ReferenceKind.EMBEDDED) {
             if (Array.isArray(value)) {
                 return value.map(item => {
-                    const wrapped = item && (0, wrap_1.helper)(item);
+                    const wrapped = item && helper(item);
                     return wrapped ? wrapped.toJSON() : item;
                 });
             }
-            const wrapped = value && (0, wrap_1.helper)(value);
+            const wrapped = value && helper(value);
             return wrapped ? wrapped.toJSON() : value;
         }
         const customType = property?.customType;
@@ -156,7 +163,7 @@ class EntityTransformer {
     }
     static processEntity(prop, entity, platform, raw, populated) {
         const child = entity[prop.name];
-        const wrapped = (0, wrap_1.helper)(child);
+        const wrapped = helper(child);
         const meta = wrapped.__meta;
         const visible = meta.primaryKeys.filter(prop => isVisible(meta, prop));
         if (raw && wrapped.isInitialized() && child !== entity) {
@@ -172,17 +179,17 @@ class EntityTransformer {
             return !wrapped.__managed;
         }
         if (wrapped.isInitialized() && isPopulated() && child !== entity) {
-            return (0, wrap_1.wrap)(child).toJSON();
+            return wrap(child).toJSON();
         }
         let pk = wrapped.getPrimaryKey();
         if (prop.customType) {
             pk = prop.customType.toJSON(pk, wrapped.__platform);
         }
         if (wrapped.__config.get('serialization').forceObject) {
-            return Utils_1.Utils.primaryKeyToObject(meta, pk, visible);
+            return Utils.primaryKeyToObject(meta, pk, visible);
         }
-        if (Utils_1.Utils.isPlainObject(pk)) {
-            const pruned = Utils_1.Utils.primaryKeyToObject(meta, pk, visible);
+        if (Utils.isPlainObject(pk)) {
+            const pruned = Utils.primaryKeyToObject(meta, pk, visible);
             if (visible.length === 1) {
                 return platform.normalizePrimaryKey(pruned[visible[0]]);
             }
@@ -193,22 +200,22 @@ class EntityTransformer {
     static processCollection(prop, entity, raw, populated) {
         const col = entity[prop.name];
         if (raw && col.isInitialized(true)) {
-            return col.map(item => (0, wrap_1.helper)(item).toPOJO());
+            return col.map(item => helper(item).toPOJO());
         }
         if (col.shouldPopulate(populated)) {
             return col.toArray();
         }
         if (col.isInitialized()) {
-            const wrapped = (0, wrap_1.helper)(entity);
+            const wrapped = helper(entity);
             const forceObject = wrapped.__config.get('serialization').forceObject;
             return col.map(item => {
-                const wrapped = (0, wrap_1.helper)(item);
+                const wrapped = helper(item);
                 const pk = wrapped.getPrimaryKey();
                 if (prop.customType) {
                     return prop.customType.toJSON(pk, wrapped.__platform);
                 }
                 if (forceObject) {
-                    return Utils_1.Utils.primaryKeyToObject(wrapped.__meta, pk);
+                    return Utils.primaryKeyToObject(wrapped.__meta, pk);
                 }
                 return pk;
             });
@@ -216,4 +223,3 @@ class EntityTransformer {
         return undefined;
     }
 }
-exports.EntityTransformer = EntityTransformer;

package/serialization/SerializationContext.d.ts

@@ -1,5 +1,5 @@
-import type { AnyEntity, EntityMetadata, PopulateOptions } from '../typings';
-import type { Configuration } from '../utils/Configuration';
+import type { AnyEntity, EntityMetadata, PopulateOptions } from '../typings.js';
+import type { Configuration } from '../utils/Configuration.js';
 /**
  * Helper that allows to keep track of where we are currently at when serializing complex entity graph with cycles.
  * Before we process a property, we call `visit` that checks if it is not a cycle path (but allows to pass cycles that

package/serialization/SerializationContext.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SerializationContext = void 0;
-const Utils_1 = require("../utils/Utils");
-const wrap_1 = require("../entity/wrap");
+import { Utils } from '../utils/Utils.js';
+import { helper } from '../entity/wrap.js';
 /**
  * Helper that allows to keep track of where we are currently at when serializing complex entity graph with cycles.
  * Before we process a property, we call `visit` that checks if it is not a cycle path (but allows to pass cycles that
  * are defined in populate hint). If not, we proceed and call `leave` afterwards.
  */
-class SerializationContext {
+export class SerializationContext {
     config;
     populate;
     fields;
@@ -39,14 +36,14 @@ class SerializationContext {
     }
     leave(entityName, prop) {
         const last = this.path.pop();
-        /* istanbul ignore next */
-        if (!last || last[0] !== entityName || last[1] !== prop) {
+        /* v8 ignore next */
+        if (last?.[0] !== entityName || last[1] !== prop) {
             throw new Error(`Trying to leave wrong property: ${entityName}.${prop} instead of ${last?.join('.')}`);
         }
     }
     close() {
         for (const entity of this.entities) {
-            delete (0, wrap_1.helper)(entity).__serializationContext.root;
+            delete helper(entity).__serializationContext.root;
         }
     }
     /**
@@ -54,19 +51,19 @@ class SerializationContext {
      */
     static propagate(root, entity, isVisible) {
         root.register(entity);
-        const meta = (0, wrap_1.helper)(entity).__meta;
+        const meta = helper(entity).__meta;
         for (const key of Object.keys(entity)) {
             if (!isVisible(meta, key)) {
                 continue;
             }
             const target = entity[key];
-            if (Utils_1.Utils.isEntity(target, true)) {
+            if (Utils.isEntity(target, true)) {
                 if (!target.__helper.__serializationContext.root) {
                     this.propagate(root, target, isVisible);
                 }
                 continue;
             }
-            if (Utils_1.Utils.isCollection(target)) {
+            if (Utils.isCollection(target)) {
                 for (const item of target.getItems(false)) {
                     if (!item.__helper.__serializationContext.root) {
                         this.propagate(root, item, isVisible);
@@ -76,18 +73,21 @@ class SerializationContext {
         }
     }
     isMarkedAsPopulated(entityName, prop) {
-        let populate = this.populate;
+        let populate = this.populate ?? [];
         for (const segment of this.path) {
-            if (!populate) {
-                return false;
-            }
-            const exists = populate.find(p => p.field === segment[1]);
-            if (exists) {
-                // we need to check for cycles here too, as we could fall into endless loops for bidirectional relations
-                if (exists.all) {
-                    return !this.path.find(([cls, item]) => entityName === cls && prop === item);
+            const hints = populate.filter(p => p.field === segment[1]);
+            if (hints.length > 0) {
+                const childHints = [];
+                for (const hint of hints) {
+                    // we need to check for cycles here too, as we could fall into endless loops for bidirectional relations
+                    if (hint.all) {
+                        return !this.path.find(([cls, item]) => entityName === cls && prop === item);
+                    }
+                    if (hint.children) {
+                        childHints.push(...hint.children);
+                    }
                 }
-                populate = exists.children;
+                populate = childHints;
             }
         }
         return !!populate?.some(p => p.field === prop);
@@ -98,7 +98,7 @@ class SerializationContext {
         }
         let fields = [...this.fields];
         for (const segment of this.path) {
-            /* istanbul ignore next */
+            /* v8 ignore next */
             if (fields.length === 0) {
                 return true;
             }
@@ -109,8 +109,7 @@ class SerializationContext {
         return fields.some(p => p === prop || p === '*');
     }
     register(entity) {
-        (0, wrap_1.helper)(entity).__serializationContext.root = this;
+        helper(entity).__serializationContext.root = this;
         this.entities.add(entity);
     }
 }
-exports.SerializationContext = SerializationContext;

package/serialization/index.d.ts

@@ -1,3 +1,3 @@
-export * from './EntityTransformer';
-export * from './EntitySerializer';
-export * from './SerializationContext';
+export * from './EntityTransformer.js';
+export * from './EntitySerializer.js';
+export * from './SerializationContext.js';

package/serialization/index.js

@@ -1,19 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./EntityTransformer"), exports);
-__exportStar(require("./EntitySerializer"), exports);
-__exportStar(require("./SerializationContext"), exports);
+export * from './EntityTransformer.js';
+export * from './EntitySerializer.js';
+export * from './SerializationContext.js';

package/types/ArrayType.d.ts

@@ -1,6 +1,6 @@
-import { Type, type TransformContext } from './Type';
-import type { EntityProperty } from '../typings';
-import type { Platform } from '../platforms';
+import { type TransformContext, Type } from './Type.js';
+import type { EntityProperty } from '../typings.js';
+import type { Platform } from '../platforms/Platform.js';
 export declare class ArrayType<T = string> extends Type<T[] | null, string | null> {
     private readonly toJsValue;
     private readonly toDbValue;