@medusajs/utils 3.0.0-snapshot-20250410112222 → 3.0.0-snapshot-20251104004624

package/dist/dal/mikro-orm/mikro-orm-serializer.js

@@ -1,243 +1,452 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mikroOrmSerializer = exports.EntitySerializer = void 0;
-const core_1 = require("@mikro-orm/core");
-function isVisible(meta, propName, options = {}) {
-    if (options.populate === true) {
+const core_1 = require("@medusajs/deps/mikro-orm/core");
+const STATIC_OPTIONS_SHAPE = {
+    populate: true,
+    exclude: undefined,
+    preventCircularRef: true,
+    skipNull: undefined,
+    ignoreSerializers: undefined,
+    forceObject: true,
+};
+const EMPTY_ARRAY = Object.freeze([]);
+const WILDCARD = "*";
+const DOT = ".";
+const UNDERSCORE = "_";
+function isVisible(propName, populate, exclude, meta) {
+    if (populate === true)
         return true;
-    }
-    if (Array.isArray(options.populate) &&
-        options.exclude?.find((item) => item === propName)) {
+    if (exclude && exclude.includes(propName))
         return false;
+    if (Array.isArray(populate)) {
+        const populateLength = populate.length;
+        const propNameLength = propName.length;
+        for (let i = 0; i < populateLength; i++) {
+            const item = populate[i];
+            if (item === WILDCARD)
+                return true;
+            if (item === propName)
+                return true;
+            if (item.length > propNameLength && item[propNameLength] === DOT) {
+                if (item.slice(0, propNameLength) === propName)
+                    return true;
+            }
+        }
     }
-    if (Array.isArray(options.populate) &&
-        (options.populate?.find((item) => item === propName || item.startsWith(propName + ".")) ||
-            options.populate.includes("*"))) {
-        return true;
-    }
-    const prop = meta.properties[propName];
-    const visible = (prop && !prop.hidden) || prop === undefined; // allow unknown properties
-    const prefixed = prop && !prop.primary && propName.startsWith("_"); // ignore prefixed properties, if it's not a PK
+    const prop = meta[propName];
+    const visible = (prop && !prop.hidden) || prop === undefined;
+    const prefixed = prop && !prop.primary && propName.charAt(0) === UNDERSCORE;
     return visible && !prefixed;
 }
-function isPopulated(entity, propName, options) {
-    if (Array.isArray(options.populate) &&
-        (options.populate?.find((item) => item === propName || item.startsWith(propName + ".")) ||
-            options.populate.includes("*"))) {
+function isPopulated(propName, populate) {
+    if (populate === true)
         return true;
-    }
-    if (typeof options.populate === "boolean") {
-        return options.populate;
+    if (populate === false || !Array.isArray(populate))
+        return false;
+    const propNameLength = propName.length;
+    const populateLength = populate.length;
+    for (let i = 0; i < populateLength; i++) {
+        const item = populate[i];
+        if (item === WILDCARD || item === propName)
+            return true;
+        if (item.length > propNameLength && item[propNameLength] === DOT) {
+            if (item.slice(0, propNameLength) === propName)
+                return true;
+        }
     }
     return false;
 }
-/**
- * Custom property filtering for the serialization which takes into account circular references to not return them.
- * @param propName
- * @param meta
- * @param options
- * @param parents
- */
-function filterEntityPropToSerialize({ propName, meta, options, parents, }) {
-    parents ??= [];
-    const isVisibleRes = isVisible(meta, propName, options);
-    const prop = meta.properties[propName];
-    // Only prevent circular references if prop is a relation
-    if (prop &&
-        options.preventCircularRef &&
-        isVisibleRes &&
-        prop.kind !== core_1.ReferenceKind.SCALAR) {
-        // mapToPk would represent a foreign key and we want to keep them
-        if (!!prop.mapToPk) {
-            return true;
+class RequestScopedSerializationContext {
+    constructor() {
+        this.propertyNameCache = new Map();
+        this.visitedEntities = new WeakSet();
+        //  The buffer essentially replaces what would otherwise be a Set → Array conversion with a more
+        //  efficient pre-allocated array approach, while maintaining the
+        //  deduplication logic via the separate seenKeys Set.
+        this.keyCollectionBuffer = new Array(100); // Pre-allocated buffer for key collection
+        this.keyBufferIndex = 0;
+        this.propertyNameCache.set("id", "id");
+        this.propertyNameCache.set("created_at", "created_at");
+        this.propertyNameCache.set("updated_at", "updated_at");
+        this.propertyNameCache.set("deleted_at", "deleted_at");
+    }
+    resetKeyBuffer() {
+        this.keyBufferIndex = 0;
+    }
+    addKey(key) {
+        if (this.keyBufferIndex < this.keyCollectionBuffer.length) {
+            this.keyCollectionBuffer[this.keyBufferIndex++] = key;
+        }
+        else {
+            this.keyCollectionBuffer.push(key);
+            this.keyBufferIndex++;
         }
-        return !parents.some((parent) => parent === prop.type);
     }
-    return isVisibleRes;
+    getKeys() {
+        // Avoid slice allocation if buffer is exactly full
+        if (this.keyBufferIndex === this.keyCollectionBuffer.length) {
+            return this.keyCollectionBuffer;
+        }
+        return this.keyCollectionBuffer.slice(0, this.keyBufferIndex);
+    }
 }
 class EntitySerializer {
-    static serialize(entity, options = {}, parents = []) {
-        const parents_ = Array.from(new Set(parents));
+    static serialize(entity, options = STATIC_OPTIONS_SHAPE, parents = EMPTY_ARRAY, requestCtx) {
+        const ctx = requestCtx ?? new RequestScopedSerializationContext();
         const wrapped = (0, core_1.helper)(entity);
         const meta = wrapped.__meta;
         let contextCreated = false;
-        if (!wrapped.__serializationContext.root) {
+        const populate = options.populate ?? STATIC_OPTIONS_SHAPE.populate;
+        const exclude = options.exclude;
+        const skipNull = options.skipNull ?? STATIC_OPTIONS_SHAPE.skipNull;
+        const preventCircularRef = options.preventCircularRef ?? STATIC_OPTIONS_SHAPE.preventCircularRef;
+        const ignoreSerializers = options.ignoreSerializers ?? STATIC_OPTIONS_SHAPE.ignoreSerializers;
+        const forceObject = options.forceObject ?? STATIC_OPTIONS_SHAPE.forceObject;
+        const serializationContext = wrapped.__serializationContext;
+        if (!serializationContext.root) {
             const root = new core_1.SerializationContext({});
             core_1.SerializationContext.propagate(root, entity, (meta, prop) => meta.properties[prop]?.kind !== core_1.ReferenceKind.SCALAR);
             contextCreated = true;
         }
-        const root = wrapped.__serializationContext
-            .root;
+        const root = serializationContext.root;
         const ret = {};
-        const keys = new Set(meta.primaryKeys);
-        Object.keys(entity).forEach((prop) => keys.add(prop));
+        ctx.resetKeyBuffer();
+        const seenKeys = new Set();
+        const primaryKeys = meta.primaryKeys;
+        const primaryKeysLength = primaryKeys.length;
+        const entityKeys = Object.keys(entity);
+        const entityKeysLength = entityKeys.length;
+        const metaPropertyKeys = Object.keys(meta.properties);
+        const metaPropertyKeysLength = metaPropertyKeys.length;
+        for (let i = 0; i < primaryKeysLength; i++) {
+            const key = primaryKeys[i];
+            if (!seenKeys.has(key)) {
+                seenKeys.add(key);
+                ctx.addKey(key);
+            }
+        }
+        for (let i = 0; i < entityKeysLength; i++) {
+            const key = entityKeys[i];
+            if (!seenKeys.has(key)) {
+                seenKeys.add(key);
+                ctx.addKey(key);
+            }
+        }
+        for (let i = 0; i < metaPropertyKeysLength; i++) {
+            const key = metaPropertyKeys[i];
+            if (!seenKeys.has(key)) {
+                seenKeys.add(key);
+                ctx.addKey(key);
+            }
+        }
+        const allKeys = ctx.getKeys();
+        const allKeysLength = allKeys.length;
+        let hasComplexProperties = false;
+        const metaProperties = meta.properties;
+        for (let i = 0; i < allKeysLength; i++) {
+            const prop = allKeys[i];
+            const propMeta = metaProperties[prop];
+            if (propMeta && propMeta.kind !== core_1.ReferenceKind.SCALAR) {
+                hasComplexProperties = true;
+                break;
+            }
+        }
+        if (!hasComplexProperties && populate === true) {
+            for (let i = 0; i < allKeysLength; i++) {
+                const prop = allKeys[i];
+                const propValue = entity[prop];
+                if (propValue !== undefined && !(propValue === null && skipNull)) {
+                    ret[prop] = propValue;
+                }
+            }
+            if (contextCreated)
+                root.close();
+            return ret;
+        }
         const visited = root.visited.has(entity);
-        if (!visited) {
+        if (!visited)
             root.visited.add(entity);
+        const className = meta.className;
+        const platform = wrapped.__platform;
+        for (let i = 0; i < allKeysLength; i++) {
+            const prop = allKeys[i];
+            const isPropertyVisible = isVisible(prop, populate, exclude, metaProperties);
+            if (!isPropertyVisible)
+                continue;
+            const propMeta = metaProperties[prop];
+            let shouldSerialize = true;
+            if (propMeta &&
+                preventCircularRef &&
+                propMeta.kind !== core_1.ReferenceKind.SCALAR) {
+                if (!propMeta.mapToPk) {
+                    const propType = propMeta.type;
+                    const parentsLength = parents.length;
+                    for (let j = 0; j < parentsLength; j++) {
+                        if (parents[j] === propType) {
+                            shouldSerialize = false;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (!shouldSerialize)
+                continue;
+            const cycle = root.visit(className, prop);
+            if (cycle && visited)
+                continue;
+            const val = this.processProperty(prop, entity, populate, exclude, skipNull, preventCircularRef, ignoreSerializers, forceObject, parents, ctx);
+            if (!cycle)
+                root.leave(className, prop);
+            if (val !== undefined && !(val === null && skipNull)) {
+                let propName;
+                if (propMeta?.serializedName) {
+                    propName = propMeta.serializedName;
+                }
+                else if (propMeta?.primary && platform) {
+                    propName = platform.getSerializedPrimaryKeyField(prop);
+                }
+                else {
+                    propName = prop;
+                }
+                ret[propName] = val;
+            }
         }
-        ;
-        [...keys]
-            /** Medusa Custom properties filtering **/
-            .filter((prop) => filterEntityPropToSerialize({
-            propName: prop,
-            meta,
-            options,
-            parents: parents_,
-        }))
-            .map((prop) => {
-            const cycle = root.visit(meta.className, prop);
-            if (cycle && visited) {
-                return [prop, undefined];
-            }
-            const val = this.processProperty(prop, entity, options, parents_);
-            if (!cycle) {
-                root.leave(meta.className, prop);
-            }
-            if (options.skipNull && core_1.Utils.isPlainObject(val)) {
-                core_1.Utils.dropUndefinedProperties(val, null);
-            }
-            return [prop, val];
-        })
-            .filter(([, value]) => typeof value !== "undefined" && !(value === null && options.skipNull))
-            .forEach(([prop, value]) => (ret[this.propertyName(meta, prop, wrapped.__platform)] = value));
-        if (contextCreated) {
+        if (contextCreated)
             root.close();
-        }
-        if (!wrapped.isInitialized()) {
+        if (!wrapped.isInitialized())
             return ret;
+        const metaProps = meta.props;
+        const metaPropsLength = metaProps.length;
+        for (let i = 0; i < metaPropsLength; i++) {
+            const prop = metaProps[i];
+            const propName = prop.name;
+            if (!isVisible(propName, populate, exclude, meta.properties))
+                continue;
+            let propertyKey;
+            let shouldProcess = false;
+            if (prop.getter && !prop.getterName && entity[propName] !== undefined) {
+                propertyKey = propName;
+                shouldProcess = true;
+            }
+            else if (prop.getterName &&
+                typeof entity[prop.getterName] === "function") {
+                propertyKey = prop.getterName;
+                shouldProcess = true;
+            }
+            if (shouldProcess) {
+                ret[this.propertyName(meta, propName, platform, ctx)] =
+                    this.processProperty(propertyKey, entity, populate, exclude, skipNull, preventCircularRef, ignoreSerializers, forceObject, parents, ctx);
+            }
         }
-        // decorated getters
-        meta.props
-            .filter((prop) => prop.getter &&
-            prop.getterName === undefined &&
-            typeof entity[prop.name] !== "undefined" &&
-            isVisible(meta, prop.name, options))
-            .forEach((prop) => (ret[this.propertyName(meta, prop.name, wrapped.__platform)] =
-            this.processProperty(prop.name, entity, options, parents_)));
-        // decorated get methods
-        meta.props
-            .filter((prop) => prop.getterName &&
-            entity[prop.getterName] instanceof Function &&
-            isVisible(meta, prop.name, options))
-            .forEach((prop) => (ret[this.propertyName(meta, prop.name, wrapped.__platform)] =
-            this.processProperty(prop.getterName, entity, options, parents_)));
         return ret;
     }
-    static propertyName(meta, prop, platform) {
-        /* istanbul ignore next */
-        if (meta.properties[prop]?.serializedName) {
-            return meta.properties[prop].serializedName;
+    static propertyName(meta, prop, platform, ctx) {
+        const cacheKey = `${meta.className}:${prop}:${platform?.constructor.name || "none"}`;
+        const cached = ctx.propertyNameCache.get(cacheKey);
+        if (cached !== undefined)
+            return cached;
+        const property = meta.properties[prop];
+        let result;
+        if (property?.serializedName) {
+            result = property.serializedName;
+        }
+        else if (property?.primary && platform) {
+            result = platform.getSerializedPrimaryKeyField(prop);
         }
-        if (meta.properties[prop]?.primary && platform) {
-            return platform.getSerializedPrimaryKeyField(prop);
+        else {
+            result = prop;
         }
-        return prop;
+        ctx.propertyNameCache.set(cacheKey, result);
+        return result;
     }
-    static processProperty(prop, entity, options, parents = []) {
-        const parents_ = [...parents, entity.constructor.name];
-        const parts = prop.split(".");
-        prop = parts[0];
+    static processProperty(prop, entity, populate, exclude, skipNull, preventCircularRef, ignoreSerializers, forceObject, parents, ctx) {
+        const entityConstructorName = entity.constructor.name;
+        const newParents = parents.length > 0
+            ? [...parents, entityConstructorName]
+            : [entityConstructorName];
+        const dotIndex = prop.indexOf(DOT);
+        if (dotIndex > 0) {
+            prop = prop.substring(0, dotIndex);
+        }
         const wrapped = (0, core_1.helper)(entity);
         const property = wrapped.__meta.properties[prop];
-        const serializer = property?.serializer;
-        // getter method
-        if (entity[prop] instanceof Function) {
-            const returnValue = entity[prop]();
-            if (!options.ignoreSerializers && serializer) {
-                return serializer(returnValue);
+        const propValue = entity[prop];
+        if (typeof propValue === "function") {
+            const returnValue = propValue();
+            if (!ignoreSerializers && property?.serializer) {
+                return property.serializer(returnValue);
             }
             return returnValue;
         }
-        /* istanbul ignore next */
-        if (!options.ignoreSerializers && serializer) {
-            return serializer(entity[prop]);
+        if (!ignoreSerializers && property?.serializer) {
+            return property.serializer(propValue);
         }
-        if (core_1.Utils.isCollection(entity[prop])) {
-            return this.processCollection(prop, entity, options, parents_);
+        if (core_1.Utils.isCollection(propValue)) {
+            return this.processCollection(prop, entity, populate, exclude, skipNull, preventCircularRef, ignoreSerializers, forceObject, newParents, ctx);
         }
-        if (core_1.Utils.isEntity(entity[prop], true)) {
-            return this.processEntity(prop, entity, wrapped.__platform, options, parents_);
+        if (core_1.Utils.isEntity(propValue, true)) {
+            return this.processEntity(prop, entity, wrapped.__platform, populate, exclude, skipNull, preventCircularRef, ignoreSerializers, forceObject, newParents, ctx);
         }
-        /* istanbul ignore next */
-        if (property?.reference === core_1.ReferenceKind.EMBEDDED) {
-            if (Array.isArray(entity[prop])) {
-                return entity[prop].map((item) => (0, core_1.helper)(item).toJSON());
+        if (property?.kind === core_1.ReferenceKind.EMBEDDED) {
+            if (Array.isArray(propValue)) {
+                const result = new Array(propValue.length);
+                for (let i = 0; i < propValue.length; i++) {
+                    result[i] = (0, core_1.helper)(propValue[i]).toJSON();
+                }
+                return result;
             }
-            if (core_1.Utils.isObject(entity[prop])) {
-                return (0, core_1.helper)(entity[prop]).toJSON();
+            if (core_1.Utils.isObject(propValue)) {
+                return (0, core_1.helper)(propValue).toJSON();
             }
         }
-        const customType = property?.customType;
-        if (customType) {
-            return customType.toJSON(entity[prop], wrapped.__platform);
+        if (property?.customType) {
+            return property.customType.toJSON(propValue, wrapped.__platform);
         }
-        return wrapped.__platform.normalizePrimaryKey(entity[prop]);
+        return wrapped.__platform.normalizePrimaryKey(propValue);
     }
-    static extractChildOptions(options, prop) {
-        const extractChildElements = (items) => {
-            return items
-                .filter((field) => field.startsWith(`${prop}.`))
-                .map((field) => field.substring(prop.length + 1));
-        };
+    static extractChildPopulate(populate, prop) {
+        if (!Array.isArray(populate) || populate.includes(WILDCARD)) {
+            return populate;
+        }
+        const propPrefix = prop + DOT;
+        const propPrefixLength = propPrefix.length;
+        const childPopulate = [];
+        const populateLength = populate.length;
+        for (let i = 0; i < populateLength; i++) {
+            const field = populate[i];
+            if (field.length > propPrefixLength &&
+                field.slice(0, propPrefixLength) === propPrefix) {
+                childPopulate.push(field.substring(propPrefixLength));
+            }
+        }
+        return childPopulate.length > 0 ? childPopulate : false;
+    }
+    static createChildOptions(populate, exclude, skipNull, preventCircularRef, ignoreSerializers, forceObject, prop) {
+        const childPopulate = this.extractChildPopulate(populate, prop);
         return {
-            ...options,
-            populate: Array.isArray(options.populate) && !options.populate.includes("*")
-                ? extractChildElements(options.populate)
-                : options.populate,
-            exclude: Array.isArray(options.exclude) && !options.exclude.includes("*")
-                ? extractChildElements(options.exclude)
-                : options.exclude,
+            populate: childPopulate,
+            exclude,
+            preventCircularRef,
+            skipNull,
+            ignoreSerializers,
+            forceObject,
         };
     }
-    static processEntity(prop, entity, platform, options, parents = []) {
-        const parents_ = [...parents, entity.constructor.name];
+    static processEntity(prop, entity, platform, populate, exclude, skipNull, preventCircularRef, ignoreSerializers, forceObject, parents, ctx) {
         const child = core_1.Reference.unwrapReference(entity[prop]);
         const wrapped = (0, core_1.helper)(child);
-        const populated = isPopulated(child, prop, options) && wrapped.isInitialized();
-        const expand = populated || options.forceObject || !wrapped.__managed;
+        const populated = isPopulated(prop, populate) && wrapped.isInitialized();
+        const expand = populated || forceObject || !wrapped.__managed;
         if (expand) {
-            return this.serialize(child, this.extractChildOptions(options, prop), parents_);
+            const childOptions = this.createChildOptions(populate, exclude, skipNull, preventCircularRef, ignoreSerializers, forceObject, prop);
+            return this.serialize(child, childOptions, parents, ctx);
         }
         return platform.normalizePrimaryKey(wrapped.getPrimaryKey());
     }
-    static processCollection(prop, entity, options, parents = []) {
-        const parents_ = [...parents, entity.constructor.name];
+    static processCollection(prop, entity, populate, exclude, skipNull, preventCircularRef, ignoreSerializers, forceObject, parents, ctx) {
         const col = entity[prop];
-        if (!col.isInitialized()) {
+        if (!col.isInitialized())
             return undefined;
+        const items = col.getItems(false);
+        const itemsLength = items.length;
+        if (itemsLength === 0)
+            return [];
+        const result = new Array(itemsLength);
+        let shouldPopulateCollection = false;
+        if (populate === true) {
+            shouldPopulateCollection = true;
         }
-        return col.getItems(false).map((item) => {
-            if (isPopulated(item, prop, options)) {
-                return this.serialize(item, this.extractChildOptions(options, prop), parents_);
+        else if (Array.isArray(populate)) {
+            const propLength = prop.length;
+            const populateLength = populate.length;
+            for (let j = 0; j < populateLength; j++) {
+                const item = populate[j];
+                if (item === WILDCARD || item === prop) {
+                    shouldPopulateCollection = true;
+                    break;
+                }
+                if (item.length > propLength && item[propLength] === DOT) {
+                    if (item.slice(0, propLength) === prop) {
+                        shouldPopulateCollection = true;
+                        break;
+                    }
+                }
             }
-            return (0, core_1.helper)(item).getPrimaryKey();
-        });
+        }
+        if (!shouldPopulateCollection) {
+            for (let i = 0; i < itemsLength; i++) {
+                const item = items[i];
+                const wrapped = (0, core_1.helper)(item);
+                result[i] = wrapped.getPrimaryKey();
+            }
+            return result;
+        }
+        let childPopulate = populate;
+        if (Array.isArray(populate) && !populate.includes(WILDCARD)) {
+            const propPrefix = prop + DOT;
+            const propPrefixLength = propPrefix.length;
+            const childPopulateArray = [];
+            for (let j = 0; j < populate.length; j++) {
+                const field = populate[j];
+                if (field.length > propPrefixLength &&
+                    field.slice(0, propPrefixLength) === propPrefix) {
+                    childPopulateArray.push(field.substring(propPrefixLength));
+                }
+            }
+            childPopulate = childPopulateArray.length > 0 ? childPopulateArray : false;
+        }
+        const childOptions = {
+            populate: childPopulate,
+            exclude,
+            preventCircularRef,
+            skipNull,
+            ignoreSerializers,
+            forceObject,
+        };
+        for (let i = 0; i < itemsLength; i++) {
+            result[i] = this.serialize(items[i], childOptions, parents, ctx);
+        }
+        return result;
     }
 }
 exports.EntitySerializer = EntitySerializer;
 const mikroOrmSerializer = (data, options) => {
-    return new Promise((resolve) => {
-        options ??= {};
-        const data_ = (Array.isArray(data) ? data : [data]).filter(Boolean);
-        const forSerialization = [];
-        const notForSerialization = [];
-        data_.forEach((object) => {
-            if (object.__meta) {
-                return forSerialization.push(object);
-            }
-            return notForSerialization.push(object);
-        });
-        let result = forSerialization.map((entity) => EntitySerializer.serialize(entity, {
-            forceObject: true,
-            populate: ["*"],
-            preventCircularRef: true,
-            ...options,
-        }));
-        if (notForSerialization.length) {
-            result = result.concat(notForSerialization);
-        }
-        resolve(Array.isArray(data) ? result : result[0]);
-    });
+    const ctx = new RequestScopedSerializationContext();
+    const finalOptions = options
+        ? {
+            populate: Array.isArray(options.populate) &&
+                options.populate?.includes(WILDCARD)
+                ? true
+                : options.populate ?? STATIC_OPTIONS_SHAPE.populate,
+            exclude: options.exclude,
+            preventCircularRef: options.preventCircularRef ?? STATIC_OPTIONS_SHAPE.preventCircularRef,
+            skipNull: options.skipNull ?? STATIC_OPTIONS_SHAPE.skipNull,
+            ignoreSerializers: options.ignoreSerializers ?? STATIC_OPTIONS_SHAPE.ignoreSerializers,
+            forceObject: options.forceObject ?? STATIC_OPTIONS_SHAPE.forceObject,
+        }
+        : STATIC_OPTIONS_SHAPE;
+    if (!Array.isArray(data)) {
+        if (data?.__meta) {
+            return EntitySerializer.serialize(data, finalOptions, EMPTY_ARRAY, ctx);
+        }
+        return data;
+    }
+    const dataLength = data.length;
+    if (dataLength === 0) {
+        return [];
+    }
+    const result = new Array(dataLength);
+    for (let i = 0; i < dataLength; i++) {
+        const item = data[i];
+        if (item?.__meta) {
+            result[i] = EntitySerializer.serialize(item, finalOptions, EMPTY_ARRAY, ctx);
+        }
+        else {
+            result[i] = item;
+        }
+    }
+    return result;
 };
 exports.mikroOrmSerializer = mikroOrmSerializer;
 //# sourceMappingURL=mikro-orm-serializer.js.map