Source object is frozen when mapped

[LennartH]

Is there an existing issue for this?

• I have searched the existing issues

Describe the issue

The source object is frozen after it has been mapped, resulting in errors like TypeError: Cannot assign to read only property 'name' of object '#<Foo>' when trying to change the source afterwards. Probably related to #464.

Models/DTOs/VMs

No response

Mapping configuration

No response

Steps to reproduce

import { AutoMap, classes } from '@automapper/classes';
import { CamelCaseNamingConvention, createMap, createMapper, Mapper } from '@automapper/core';

class Foo {
  @AutoMap()
  id: string;
  @AutoMap()
  name: string;
}

class Bar {
  @AutoMap()
  id: string;
  @AutoMap()
  name: string;
}

export const mapper: Mapper = createMapper({
  strategyInitializer: classes(),
  namingConventions: new CamelCaseNamingConvention(),
});
createMap(mapper, Foo, Bar)

const foo = new Foo();
foo.id = 'id';
foo.name = 'foo';
const bar = mapper.map(foo, Foo, Bar);
console.log(bar);

console.log(Object.isFrozen(foo))
foo.name = 'baz';

Output

Bar { name: 'foo', id: 'id' }
true
TypeError: Cannot assign to read only property 'name' of object '#<Foo>'
    at file:///home/lennart/projects/ace/ace-alternatives/investor-navigator/shared-model/scripts/playground.ts:31:9
    at ModuleJob.run (node:internal/modules/esm/module_job:197:25)
    at async Promise.all (index 0)
    at async ESMLoader.import (node:internal/modules/esm/loader:337:24)
    at async loadESM (node:internal/process/esm_loader:88:5)
    at async handleMainPromise (node:internal/modules/run_main:61:12)

Expected behavior

The source object should be mutable after it was mapped.

Screenshots

No response

Minimum reproduction code

No response

Package

• I don't know.
• @automapper/core
• @automapper/classes
• @automapper/nestjs
• @automapper/pojos
• @automapper/mikro
• @automapper/sequelize
• Other (see below)

Other package and its version

No response

AutoMapper version

8.3.3

Additional context

No response

[LennartH]

I think the issue is caused by the mapper proxy:

// packages/core/src/lib/core.ts - Mapper.map
if (sourceObject == null)
    return sourceObject as TDestination;

const mapping = getMapping(
    receiver,
    sourceIdentifier,
    destinationIdentifier
);

sourceObject = strategy.preMap(
    Object.freeze(sourceObject),
    mapping
);

const destination = mapReturn(
    mapping,
    sourceObject,
    options || {}
);

return strategy.postMap(
    Object.freeze(sourceObject),
    // seal destination so that consumers cannot add properties to it
    // or change the property descriptors. but they can still modify it
    // the ideal behavior is seal but the consumers might need to add/modify the object after map finishes
    destination,
    mapping
);

It looks like the source frozen to prevent side effects by pre-/postMap, but according to the documentation of Object.freeze() it doesn't create a frozen copy but freezes the object in place:

freeze() returns the same object that was passed into the function. It does not create a frozen copy.

I think the source should be copied before freezing or freezing the source should be omitted completely leaving it to the user to make sure that the pre and post methods are side effect free.