@automapper/mikro/index.js

AutoMapper TypeScript MikroORM strategy

import { classes } from '@automapper/classes';
import { isEmpty, defaultStrategyInitializerOptions } from '@automapper/core';
import { Utils, wrap, Reference } from '@mikro-orm/core';

const excluded = ['__gettersDefined', '__entity', '__meta', '__platform', '__helper', '__factory'];
function serializeEntity(item, itemMetadata, toPojo = false, memorized = new Map(), skipCheckExisting = false) {
  if (!Utils.isEntity(item)) return item;
  if (toPojo) return wrap(item).toPOJO();
  const result = {};
  const keys = Object.keys(wrap(item).__meta.properties);
  for (const key of keys) {
    if (typeof key === 'symbol' || excluded.includes(key)) {
      continue;
    }
    const value = item[key];
    const keyMetadata = itemMetadata && itemMetadata[key];
    if (Utils.isCollection(value)) {
      result[key] = (value.getSnapshot() || []).map(snapshot => {
        return serializeEntity(snapshot, keyMetadata, true, memorized, true);
      });
      continue;
    }
    if (Reference.isReference(value)) {
      const isExisting = memorized.has(value);
      if (!skipCheckExisting && isExisting) {
        result[key] = memorized.get(value);
        continue;
      }
      if (!value.isInitialized()) {
        memorized.set(value, wrap(value).toPOJO());
        result[key] = serializeEntity(wrap(value).toPOJO(), keyMetadata, false, memorized, !isExisting);
        continue;
      }
      memorized.set(value, value.getEntity());
      result[key] = serializeEntity(value.getEntity(), keyMetadata, typeof keyMetadata === 'object' && isEmpty(keyMetadata), memorized, !isExisting);
      continue;
    }
    result[key] = serializeEntity(value, keyMetadata, false, memorized, false);
  }
  if (result['id'] == null && item['id'] != null) {
    result['id'] = item['id'];
  }
  return result;
}

function mikro(options = {}) {
  const mergedOptions = {
    ...defaultStrategyInitializerOptions,
    destinationConstructor: (_, destinationIdentifier) => new destinationIdentifier(),
    ...options
  };
  if (mergedOptions.preMap === defaultStrategyInitializerOptions.preMap) {
    mergedOptions.preMap = (source, mapping) => {
      const [sourceMetadataObject] = mapping[1 /* MappingClassId.identifierMetadata */];
      return serializeEntity(source, sourceMetadataObject);
    };
  }
  return classes(mergedOptions);
}

export { mikro };