@automapper/mikro/index.cjs

AutoMapper TypeScript MikroORM strategy

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var classes = require('@automapper/classes');
var core$1 = require('@automapper/core');
var core = require('@mikro-orm/core');

const excluded = ['__gettersDefined', '__entity', '__meta', '__platform', '__helper', '__factory'];
function serializeEntity(item, itemMetadata, toPojo = false, memorized = new Map(), skipCheckExisting = false) {
  if (!core.Utils.isEntity(item)) return item;
  if (toPojo) return core.wrap(item).toPOJO();
  const result = {};
  const keys = Object.keys(core.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 (core.Utils.isCollection(value)) {
      result[key] = (value.getSnapshot() || []).map(snapshot => {
        return serializeEntity(snapshot, keyMetadata, true, memorized, true);
      });
      continue;
    }
    if (core.Reference.isReference(value)) {
      const isExisting = memorized.has(value);
      if (!skipCheckExisting && isExisting) {
        result[key] = memorized.get(value);
        continue;
      }
      if (!value.isInitialized()) {
        memorized.set(value, core.wrap(value).toPOJO());
        result[key] = serializeEntity(core.wrap(value).toPOJO(), keyMetadata, false, memorized, !isExisting);
        continue;
      }
      memorized.set(value, value.getEntity());
      result[key] = serializeEntity(value.getEntity(), keyMetadata, typeof keyMetadata === 'object' && core$1.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 = {
    ...core$1.defaultStrategyInitializerOptions,
    destinationConstructor: (_, destinationIdentifier) => new destinationIdentifier(),
    ...options
  };
  if (mergedOptions.preMap === core$1.defaultStrategyInitializerOptions.preMap) {
    mergedOptions.preMap = (source, mapping) => {
      const [sourceMetadataObject] = mapping[1 /* MappingClassId.identifierMetadata */];
      return serializeEntity(source, sourceMetadataObject);
    };
  }
  return classes.classes(mergedOptions);
}

exports.mikro = mikro;