Is it possible to map a POJO to an annotated Class?

[lacoonte]

I have a POJO with its metadata already created (IAppointment) and an annotated class (Appointment). There's no info about that in the documentation, the following does not work:
mapper.createMap<IAppointment, Appointment>("IAppointment", Appointment);
Maybe its not possible because POJO plugin and class plugin are using different metadata store?
Thanks in advance

[nartc]

Hi @alvarorece , it is not possible the way you describe it. You are right, the two plugins have two separate metadata storages. What I'd recommend is to make IAppointment a class like AppointmentDto or something like that (which fits its purpose). A class without any constructor and methods are almost the same as an interface in this case.

[darrenmothersele]

I was hoping to be able to do this. Would it be possible to create a plugin that composes multiple plugins and aggregates their metadata stores?

[nartc]

@darrenmothersele maybe but the plugin interface needs to be adjusted to expose a method that would just save the metadata. Right now, the metadata is only extracted (from Reflection) and saved on the storage only when createMap() is called. If we were to try to aggregate the metadata storage, we would need to have a way to store the metadata without having to call createMap().

[darrenmothersele]

I had a go at starting this. I tried creating a new plugin that combined the features from classes and pojos plugins. But, I hit a few stumbling blocks with the utilities I needed to access being encapsulated. The implementations of the plugin interface in classes.ts and pojos.ts have a lot in common, but obviously have different "Strategies" for things like "exploreMetadata". I got a bit stuck, which made me think my approach wasn't quite right. For now I'm going to use class-transformer as that does what I need for now. I might revisit this in the future.

[nartc]

@darrenmothersele that's fair. Yeah, the AutoMapper isn't meant to be used with different type of models, at least in TypeScript. class-transformer is a great solution to go from Interface to Class but I guess you can't go the other way around right? I'll try to think of something when I have time.

[MAMISHO]

I think that if you use a strategyInitializer: pojos() and expose metadata from your class, will works!

user.interface.ts

export interface IUser {
  uuid?: string;
  username: string;
  name: string;
  lastname: string;
  email: string;
  password: string;
  passwordConfirm?: string;
  resetPasswordToken: string;
  role: UserRoleType;
  status: boolean;
}

user.dto.ts

export class UserDTO {
public name: string;
public lastname: string;
public username: string;
constructor(props?: IUser) {
    Object.assign(this, props);
  }
  public fullName(): string {
    return `${this.name} ${this.lastname}`;
  }
}

user.metadata.ts

export function createUserMetadata() {
  PojosMetadataMap.create<IUser>('IUser', {
    uuid: String,
    username: String,
    name: String,
    lastname: String,
    email: String,
    password: String,
    passwordConfirm: String,
    resetPasswordToken: String,
    role: String,
    status: Boolean,
  });

  PojosMetadataMap.create<UserDTO>('UserDTO', {
    username: String,
    name: String,
    lastname: String
  });
}

entity-mapper.interface.ts

export interface EntityMapper<Entity, DTO> {
  initMapper(): void;
  toDTO(entity: Entity): DTO;
  toEntity(dto: DTO): Entity;
  toDTOList(entity: Entity[]): DTO[];
  toEntityList(dto: DTO[]): Entity[];
}

user-mapper.service.ts

@injectable()
export class UserMapperService implements EntityMapper<IUser, UserDTO> {
  private mapper: Mapper;

  constructor() {
    this.initMapper();
  }

  public initMapper(): void {
    createUserMetadata();
    this.mapper = createMapper({ strategyInitializer: pojos() });
    createMap<IUser, UserDTO>(this.mapper, 'IUser', 'UserDTO');
  }

  public toDTO(entity: IUser): UserDTO {
    const obj = this.mapper.map<IUser, UserDTO>(entity, 'IUser', 'UserDTO');
    return new UserDTO(obj); // The class will have fullName method.
  }

  public toEntity(dto: UserDTO): IUser {
    return this.mapper.map<UserDTO, IUser>(dto, UserDTO, 'IUser');
  }

  public toDTOList(entityList: IUser[]): UserDTO[] {
    if (!entityList || entityList.length < 1) {
      return new Array<UserDTO>();
    }
    return entityList.map((entity) => this.toDTO(entity));
  }

  public toEntityList(dtoList: UserDTO[]): IUser[] {
    if (!dtoList || dtoList.length < 1) {
      return new Array<IUser>();
    }
    return dtoList.map((dto) => this.toEntity(dto));
  }
}

user-repository.service.ts

@injectable()
export class UserRepositoryServiceImpl implements IUserRepositoryService {
  constructor(
    @inject('IUserRepository') private userRepository: IUserRepository,
    private userMapperService: UserMapperService
  ) {}

  public async findOnebyUsername(username: string): Promise<UserDTO> {
    const filter: UserCriteriaDTO = { username };
    const result = await this.findAll(filter);

    if (result.length > 1) {
      throw new Error('username should be  unique');
    }

    if (result.length === 1) {
      return Promise.resolve(result.pop());
    }

    return Promise.reject();
  }

  public async findOne(userId: number): Promise<UserDTO> {
    let userDTO: UserDTO;
    const user: IUser = await this.userRepository.get(userId);
    if (user) {
      userDTO = this.userMapperService.toDTO(user);
      return Promise.resolve(userDTO);
    }
    return Promise.reject(new Error('User not found'));
  }

  public async findOneByUUID(uuid: string): Promise<UserDTO> {
    let userDTO: UserDTO;
    const user: IUser = await this.userRepository.getByUUID(uuid);
    if (user) {
      userDTO = user as UserDTO;
      return Promise.resolve(userDTO);
    }
    return Promise.reject(new Error('User not found'));
  }

  public async findOneComplete(userId: number): Promise<UserDTO> {
    throw new Error('Method not implemented.');
  }

  public async findOneByUUIDComplete(userId: string): Promise<UserDTO> {
    throw new Error('Method not implemented.');
  }

  public async findAll(filter: UserCriteriaDTO): Promise<UserDTO[]> {
    let userDTOs: UserDTO[] = new Array<UserDTO>();
    const users: IUser[] = await this.userRepository.findAll(filter);
    if (users && users.length > 0) {
      userDTOs = this.userMapperService.toDTOList(users);
    }
    return Promise.resolve(userDTOs);
  }

  public async findAllComplete(filter: UserCriteriaDTO): Promise<UserDTO[]> {
    throw new Error('Method not implemented.');
  }

  public async save(userDTO: UserDTO): Promise<UserDTO> {
    const user: IUser = this.userMapperService.toEntity(userDTO);
    const newUser: IUser = await this.userRepository.add(user);
    if (newUser) {
      const userDTO: UserDTO = this.userMapperService.toDTO(newUser);
      return Promise.resolve(userDTO);
    }
    return Promise.reject(new Error('Fail to to save user'));
  }
}

[Dark0rion]

Thanks, it helps me a lot, I'm using this in angular 17