For now we have to create mapper instance:

    final mapper = SomeMapperImpl();
    final entities = models.map(mapper.fromModel);

It would be greate to use mappers as static

    final entities = models.map(SomeMapper.fromModel);

Something like this:

@Mapper()
abstract class EntityMapper {
  static Entity fromModel(Model model) => _$EntityMapperFromModel(model);
}

This is early version of the PR, i'd really enjoy feedback from you!

Api Changes:

• added optional defaultValue property in @Mapping annotation. (No breaking changes)

Current state: Added support for mapping from optional to required property, if source value is null, defaultValue will be used, otherwise mapping will fail.

Previous State: If tired to map from optional to required it generates uncompilable code

Example:

@Mapper
abstract class NullablePropertiesMapper {
  @Mapping(source: 'number', target: 'number', defaultValue: '0')
  NullablePropertiesTarget fromSource(NullablePropertiesSource source);
}

will produce:

class NullablePropertiesMapperImpl extends NullablePropertiesMapper {
  NullablePropertiesMapperImpl() : super();

  @override
  NullablePropertiesTarget fromSource(NullablePropertiesSource source) {
    assert(source.text != null, 'text cannot be blank');
    final nullablepropertiestarget =
        NullablePropertiesTarget(source.text!, source.number ?? 0);
    return nullablepropertiestarget;
  }
}

    @smotastic  Hi, thanks for info. 

I've tested new commits and unfortunately there is still broken Static mapping.

With this new change, it is not possible add helper methods for map Enums, List, Maps, Set or anything that is not a class as it generates invalid code

static EnumFoo _mapEnumFoo(Source model) => model.foo ... 
static List<String> _mapNames(Source model) => model.friends.map((f) => f.name).toList()

both will generate something like

EnumFoo _$_mapEnumFoo(Source model) {
   final enumFoo = EnumFoo._();
   return enumFoo;
}

for List it wil generate similar code.

So for now within my fork I've completely reverted static mapping as it is not usable in my application.

Originally posted by @petrnymsa in https://github.com/smotastic/smartstruct/issues/58#issuecomment-1214401368

I've added nullChecked for nullable list. (Test is failing due to an issue described below).

Generated source is generating:

final nullablelisttarget =
        NullableListTarget(source.list!.map((e) => e).toList());

It should be

final nullablelisttarget =
        NullableListTarget(source.list!.map(fromSubSource).toList());

I'm not sure why matchingMappingListMethods.isNotEmpty is returning false.

If you can help me out, I can make changes and push the commit on this PR. Also, let me know if there are any other changes related to this.

Mapper got case insensitive fields and contains fields: data and data. If you use a case-sensitive mapper, make sure the fields are unique in a case insensitive way.

I'm using the latest version. This was still working v1.2.3+1

Generate static proxy for mapper class for the user can use the mapper without the mapper object.

Which is discussed at https://github.com/smotastic/smartstruct/pull/57#discussion_r901207690.

Given below the my mapper class:

@Mapper(useInjection: true)
abstract class UserSigninMapper {
  UserSigninContract? fromEntity(UserSigninEntity? entity);
}

and the generated file contains:

@LazySingleton(as: UserSigninMapper)
class UserSigninMapperImpl extends UserSigninMapper {
  @override
  UserSigninContract? fromEntity(UserSigninEntity? entity) {
    if (entity == null) {
      return null;
    }
    ;
    final usersignincontract =
        UserSigninContract(email: entity.email, password: entity.password);
    return usersignincontract;
  }
}

Running flutter pub run build_runner build shows the following output:

[INFO] Running build...

// Removed for brevity

[AuthManagerImpl] depends on unregistered type [UserSigninMapper] from my_app/domain/mappers/authentication/user_signin_mapper.dart

Did you forget to annotate the above class(s) or their implementation with @injectable?
------------------------------------------------------------------------ 

// Removed for brevity

[INFO] Succeeded after 19.2s with 14 outputs (90 actions)

It seems that UserSigninMapper is not being registered. I think build_runner is ignoring generated files.

Lists should be mappable too.

When the sourcefield contains an iterable, we iterate through it, and map it respectively to the target field. Primitive types will just map to itself, so we can also just create a new list with the old values in it. Lists of nested Beans will call the mapping method, provided in the mapper class.

class NestedTarget {
  NestedTarget(this.subNested);

  final List<SubNestedTarget> subNested;
}
class NestedSource {
  NestedSource(this.subNested);

  final List<SubNestedSource> subNested;
}

@Mapper()
abstract class NestedMapper {
  @Mapping(source: 'subNestedSource', target: 'subNestedTarget')
  NestedTarget fromModel(NestedSource model);

  SubNestedTarget fromSubClassModel(SubNestedSource model);
}

Should generate something like this.

class NestedMapperImpl extends NestedMapper {
  @override
  NestedTarget fromModel(NestedSource model) {
    final nestedtarget = NestedTarget(model.subNested.map((e) => fromSubClassModel(e)).toList(););
    return nestedtarget;
  }

  @override
  SubNestedTarget fromSubClassModel(SubNestedSource model) {
    final subnestedtarget = SubNestedTarget(model.myProperty);
    return subnestedtarget;
  }
}

1. Retain the more information about source filed by "RefChain.dart"; When I use "object-box" and "smartstruct" at one time, I have some trouble.

class Source {
    final one = ToOne<SubSource>() ;
}

class Target {
    late SubTarget one;
}

class SubSource {
}

class SubTarget {

}

@Mapper()
abstract class SourceMapper {

    @Mapping(target: "one", source: "prop.one.target")
    Target fromSource(Source source);

    SubTarget fromSubSource(SubSource subSource);
}

The type of source "prop.code.target" is "SubSource" and the target "one" is "SubTarget", so it need the nested mapping "fromSubSource". But the code doesn't know the type of "prop.one.target", because it is a generic type in "ToOne" class. In the "SourceAssignment", the only type info of "prop.one.target" is "EntityT" which is a type variable in the "ToOne" class. It's impossible that finding the correct nested mapping for the "prop.one.target". The "RefChain" class can record the real type of "prop"，“prop.one" and "prop.one.target". The "RefChain" also record the nullability of each of the property.

2. Apply nested mapping after function mapping. Sometimes the result of function mapping need to mapped again by the nested mapping.

class Source {
  late SubSourceRef source;
}

class Target {
  late SubTarget target;
}

class SubSource {
}

class SubTarget {
}

class SubSourceRef {
     late SubSource source;
}

@Mapper()
abstract class ModelMapper {

  @Mapping(source: refToSource, target: 'source')
  Target fromSource(Source source);
  SubTarget fromSubSource(SubSource subSource);    
  

}

// The return value need to be mapped again by the nested mapping('fromSubSource').
SubSource refToSource(SubSourceRef ref) => ref.source;

And the generate code is

class ModelMapperImpl extends ModelMapper {
  ModelMapperImpl() : super();

  @override
  Target fromSource(Source source) {
    final target = Target();
    return target;
  }

  @override
  SubTarget fromSubSource(SubSource subSource) {
    final subtarget = SubTarget();
    return subtarget;
  }
}

3. Ingore the nullability of type in nested mapping function matching. So the nested mapping function can be matched more easily.

4. Pass on the mapper pointer to the function mapping method by the named parameters.

@Mapper
abstract ModelMapper {

    @Mapping(source=funMapping, target="data")
    Target fromSource(Source source);
    // ...
}
funMapping(Source source, {
    mapper: ModelMapper
}) {

}

5. Extend the availability of the shouldAssignList. More list like object can be mapped automatically.

class Source {
    late Set<String> nameList;
}

class Target {
    late List<String> nameList;
}

The "Source.nameList" can be mapped to "Target.nameList" automatically.

6. Add null check code in the generate code. When the input of "nestedMappingMethod" is not nullable and the input property is nullable, the 'null check code' will be generated. Just like:

target = source == null ? null : nestedMappingMethod(source)

Thanks for the library. I'm a fan of Mapstruct and it's good to see a similar effort in the dart world.

One question or feature request. Is it possible to exclude a field from the automatic mapper, something similar to this?

The less we explicitly name the fields, the easier it becomes to maintain the mappings. This is particularly relevant when using libraries like Equatable that add helper fields we do not want to include in our mappings.

This would allow scenarios where we could say "map all fields except this one" as opposed to having to explicitly map all the ones we want.

Hi, this is a great package thanks for sharing. I did look at the documentation and did not see anything like...

For example, I have the class

class UserResponse { final String profile; ... }

And I have

enum UserProfile { investor, consumer }

class User {
final UserProfile profile;
...
}

How can I make the mapper to map with a custom logic for example:

profile: enumFromString<UserProfile>(
    UserProfile.values,
    response.profile,
    UserProfile.consumer,
  )

for the profile field. This is just one example there is several more like

class UserResponse {
   final String zipCode;
   final String number;
   final String street;
...
}

Map to

class User {
   final Address address;
}

This PR adds new parameter to Mapper() annotation to optionally turn off "Static mapping".

In our project, we usually have "statci helper methods" to map the inner fields of complex objects, but such methods are only for mapping. Without this feature, for each static method a new static $_method is generated which often is not needed and moreover, sometimes it leads to compile errors.

Breaking change: NO - as this parameter is by default set to true

When I use this plugin , I can't fill the data straightly into the target object . I add the isStraight into @Mapping annotation and change the _targetToSource method . I just change the implement way , not to change the content. So it has created the all previous example successfully after my test.

It makes we can straightly fill the data into the target as the field , we don't need to package the parameter as the function or bean when we are in the easy situation. The example is the the dog_example folder.

Hi and thank you for work I have to use other mapper inside my mapper for mapping nested element of my model to entity But currently I have to copy same method from other mapper

Question: How to realize this kind of mapping?

class Target {
  final String text1;
  final Sourse2 source2;

  Target(this.text1, this.source2);
}

class Source {
  final String text1;
  final int source2Id;  
  Source(this.text1);
}

class Source2 {
  final int id;
  final String text2;
  Source2(this.text2);
}

"Multiple sources" example is close to that, but not exactly.

Description

Given the following classes:

class Dog {
  final String breed;
  final int age;
  final String name;
  Dog(this.breed, this.age, this.name);
}

class DogModel {
  final String breed;
  final int age;
  final String name;
  DogModel(this.breed, this.age, this.name);
}

And given the following mapper interface:

// dogmapper.dart

part 'dogmapper.mapper.g.dart';

@Mapper()
abstract class DogMapper {
  Dog asEntity(DogModel model);
}

Instead of generating a mapper class, it would be great to generate mapper extension methods as follows:

// dogmapper.mapper.g.dart

extension ConvertibleDogModel on DogModel {
  Dog get asEntity => Dog(breed, age, name);
}