Support constructor parameter annotations to improve the code readability

[renatoargh]

Hello! I am not sure if this is even possible, but I think it is worth mentioning it for the future.

I have written my data classes by taking advantage of TS syntax like this:

export default class Address {
  constructor(
    public readonly id: string,
    public readonly zipCode: string,
    public readonly line1: string,
    public readonly line2: Nullable<string>,
    public readonly number: string,
    public readonly district: string,
    public readonly municipalityCode: string,
    public readonly state: States,
    public readonly isResidential: boolean = false,
    public readonly isBusiness: boolean = false,
    public readonly isMailing: boolean = false,
    public readonly isDelivery: boolean = false,
  ) {}
}

Now I have to add the @AutoMap annotation to the class and they don't work if I put them on top of the constructor parameters, like this:

export default class Address {
  constructor(
    @AutoMap() public readonly id: string,
    @AutoMap() public readonly zipCode: string,
    @AutoMap() public readonly line1: string,
    @AutoMap() public readonly line2: Nullable<string>,
    @AutoMap() public readonly number: string,
    @AutoMap() public readonly district: string,
    @AutoMap() public readonly municipalityCode: string,
    @AutoMap() public readonly state: States,
    @AutoMap() public readonly isResidential: boolean = false,
    @AutoMap() public readonly isBusiness: boolean = false,
    @AutoMap() public readonly isMailing: boolean = false,
    @AutoMap() public readonly isDelivery: boolean = false,
  ) {}
}

Because this is not supported (maybe JS/TS itself won't support this syntax) I have to break down this code into constructor+property, which triplicates the length of my code, ending up in something like this:

export default class Address {
  @AutoMap()
  public readonly id: string

  @AutoMap()
  public readonly zipCode: string

  @AutoMap()
  public readonly line1: string

  @AutoMap()
  public readonly line2: Nullable<string>

  @AutoMap()
  public readonly number: string

  @AutoMap()
  public readonly district: string

  @AutoMap()
  public readonly municipalityCode: string

  @AutoMap()
  public readonly state: States

  @AutoMap()
  public readonly isResidential: boolean = false

  @AutoMap()
  public readonly isBusiness: boolean = false

  @AutoMap()
  public readonly isMailing: boolean = false

  @AutoMap()
  public readonly isDelivery: boolean = false

  constructor(
    _id: string,
    _zipCode: string,
    _line1: string,
    _line2: Nullable<string>,
    _number: string,
    _district: string,
    _municipalityCode: string,
    _state: States,
    _isResidential = false,
    _isBusiness = false,
    _isMailing = false,
    _isDelivery = false,
  ) {
    this.id = _id
    this.zipCode = _zipCode
    this.line1 = _line1
    this.line2 = _line2
    this.number = _number
    this.district = _district
    this.municipalityCode = _municipalityCode
    this.state = _state
    this.isResidential = _isResidential
    this.isBusiness = _isBusiness
    this.isMailing = _isMailing
    this.isDelivery = _isDelivery
  }
}

Is there any better, less verbose way, to do what I am doing here?! Do yo plan to support such syntax (if even possible, of course)?

Congrats on the great work on AutoMapper! 🥇

[nartc]

It's really not about whether it is possible or not. There's a bit of a story 😅

To get into explaining this, I'd like to start with the @AutoMap decorator

quick note here, AutoMap is currently a PropertyDecorator, that's why it doesn't work in the constructor as the short-hand properties in constructor are parameters, hence a ParameterDecorator is needed

AutoMap decorator purpose is to keep track of the metadata of each field in a certain class (model). Take a look at the following snippet:

class Foo {
   foo: string;
   bar: string;
}

console.log(new Foo()); // Foo {}

As you can see here, a new instance of Foo is an empty object. It doesn't have any information about its properties. Hence, the auto part in AutoMapper wouldn't work. A workaround this is to use what you're proposing, short-hand property declaration syntax:

class Foo {
   constructor(
      public foo?: string,
      public bar?: string
   ) {}
}

console.log(new Foo()); // Foo { foo: undefined, bar: undefined }

Great! Now a new instance of Foo will have some information about foo and bar. This would work great for Primitives. For nested objects, it becomes a little bit tricky and too opinionated to force the consumers of AutoMapper to use. That's why AutoMap was born. And coupled with AutoMap, an instantiate() method to get the instance of a class was also born, instead of new Class().

Also, your proposal would limit this as well #319 (though this has not been implemented yet 🥲).

That said, I think a new ParameterDecorator would be good for you. I'll think of something.

[renatoargh]

Hey, @nartc thank you for your quick and clarifying response!
The parameter decorator would definitely improve the code, but no worries since this is not a blocker, but of course, nice to have!

Thanks again!