Implement `Resolve<T>` style interface for simpler DI

[marshall007]

Implement `Resolve` style interface for simpler DI

from core.

[christopherthielen]

@marshall007 my thoughts... I'm not super fond of having to export everything, nor adding extra ceremony around resolve. I do like the idea of typing the resolve data for a specific class, although I am not sure about where the typing data would be used.

This is especially true now given that the AoT compiler complains on non-exported anonymous resolveFn.

Here's an alternative approach I've been toying with:

@State()
export class PersonState {
  name =  'person',
  url = '/people/:personId',
  component = Person,

  @Resolve({ deps: [PeopleService, Transition] })
  person(peopleSvc, transition) {
    return peopleSvc.getPerson(transition.params().personId);
  }
};

The current problem is that the state is no longer statically analyzable (because component = Person is effectively handled in the constructor). I've had a couple of conversations with @robwormald about what we would need to support this, and my current hope is that we'll be able to do this eventually.

[marshall007]

@christopherthielen I'd be happy to work on this if I could get your thoughts on the initial proposal. I'm also curious to know whether or not there might be pitfalls associated with this approach.

[marshall007]

I'm definitely a fan of the @Resolve() decorator and declaring resolve data directly on the state like that. However, I still find having to explicitly declare deps rather annoying. The key thing I was trying to accomplish in my proposal was a method that takes advantage of the metadata emitted by the Angular compiler to resolve dependencies.

My understanding is that there is currently no way to accomplish this other than implementing a class. I would love to be wrong about that, but unless we can get the @Resolve() decorator to emit metadata annotations for its injected dependencies, I think a Resolve<T> interface is still the cleaner solution.

@christopherthielen thoughts?

[aitboudad]

@marshall007 basically resolve function is a small piece of code (use a function is fairly enough), I prefer explicitly declare deps rather than defining another service which I need to define explicitly in state declaration and @NgModel

[marshall007]

In v5 it appears there will be an emphasis on declaring states as classes (as @christopherthielen proposed above). Instead of a new Resolve<T> interface I was suggesting, what do you guys think about injecting dependencies in the state definition's constructor itself? In doing so, would we still be able provide a mechanism for injecting resolved dependencies from a parent state too (presumably using @Inject(<token>))?

@State("person")
export class PersonState {
  url = '/people/:personId',
  component = Person,

  constructor(private peopleSvc: PeopleService, private transition: Transition) { }

  @Resolve()
  person() {
    return this.peopleSvc.getPerson(this.transition.params().personId);
  }
};

It would be really great if the Angular team exposed a decorator or some other mechanism for telling the compiler to preserve parameter metadata on an arbitrary function. That way we could just do:

@Resolve()
person(peopleSvc: PeopleService, transition: Transition) {
  return peopleSvc.getPerson(transition.params().personId);
}

---

The current problem is that the state is no longer statically analyzable (because component = Person is effectively handled in the constructor).

Have you guys had any further communication with the Angular team on this point? Is the discussion around getting them to emit type metadata for generics so we can do something like class PersonState implements StateDeclaration<Person> or what is the plan there?

[stale]

This issue has been automatically marked as stale because it has not had
recent activity. It will be closed if no further activity occurs.

This does not mean that the issue is invalid. Valid issues
may be reopened.

Thank you for your contributions.