Dependency annotations

[L8D]

After we get a system in place to handle them properly, there is a plan to create annotations and annotation handlers for the following:

• A token for representing the instance of the dependency that the current dependency is providing. Example:

@provide(DbConn)
@dependencies(Super)
class TransactionalDbConn {
  constructor(originalDbConn) {
    return originalDbConn.byTransaction();
  }
}

• An annotation for injecting a dependency lazily (i.e. a prototype of the constructor is passed in, before the constructor is applied to the prototype). This would allow for systems for more efficiently initialize because resources can be referenced and inserted while they are still loading. Although error handling and other problems arise. Example:

@dependencies(Lazy(CurrentUser))
class CurrentOrder {
  constructor(user) {
    return new Order({user, /* ... */});
  }
}

• An annotation for injecting the promise of a dependency. This would be a more robust but less fancy form of lazy loading, where the promise of a resource that is resolving is passed in, instead of waiting for the promise to resolve and then passing in the result. This would be mostly used for handling parallelization in a form better than lazy loading or for handling errors that would be thrown during instantiation (although there should be an annotation specifically for that). Example:

@dependencies(Async(CurrentUser))
class CurrentOrder {
  constructor(userPromise) {
    return Promise.props({
      order: something.getCurrentOrder(),
      user: userPromise
    }).then({order, user} => {user, ...order});
}

• An annotation (or maybe an alternative @provide-like decorator) for allowing thrown errors to be caught and handled. Although this could probably be replaced by making the Super token wrap the mocked resource.