Wsrtjtyk

For example:

@NgModule ({

  providers: [ 

    { provide: MyService, 

      useFactory: (optionalDep) => new MyService(optionalDep)

      deps: [SOME_DEP]

    }

})

class MyModule {}

Can useFactory have optional dependencies?

According to official doc, you can do the following:

const Location = new InjectionToken('location');

const Hash = new InjectionToken('hash');



const injector = Injector.create([{

  provide: Hash,

  useFactory: (location: string) => `Hash for: ${location}`,

  // use a nested array to define metadata for dependencies.

  deps: [[new Optional(), Location]]

}]);



expect(injector.get(Hash)).toEqual('Hash for: null');

See https://angular.io/api/core/FactoryProvider#example for more

I have found such a workaround:

class OptionalDepHolder {

  constructor(@Optional() @Inject(SOME_DEP) public optionalDep) {}

}



@NgModule ({

  providers: [ 

    { provide: MyService, 

      useFactory: (holder) => new MyService(holder.optionalDep)

      deps: [OptionalDepHolder]

    }

})

class MyModule {}

Factory accepts a function.

Decorators in typescript can apply on: class declaration, method, accessor, property, or parameter.

In other words, currently you can only decorate a class and class members.

parameter refers to the parameter of a method, not a function.

So, since you can't decorate function and more so parameters in a function you can't set the @Optional tag.

This a language/spec limitation that might change in the future.

Another thing to note is that the metadata feature supported by typescript and consumed by angular using reflect-metadata is designed to work on classes. This is of course nonsense, classes are functions... but this is the general mental model.

According to the documentation, the deps array accepts provider tokens which means you can't hint about a dependency being optional.

It is a good idea to have support for optional dependencies in factories. You should open a GH issue with a feature request!

It is indeed possible to declare an optional dependency for a factory provider.

export const MY_OPTIONAL_SERVICE_PARAMETER = new OpaqueToken('my_optional_service_parameter');

export const myOptionalServiceParameterDefault = 42;

Then, in your providers list, provide the default using a value provider

@NgModule({

   providers: [

      {

          provide: MY_OPTIONAL_SERVICE_PARAMETER, 

          useValue: myOptionalServiceParameterDefault

      },

      {

          provide: MyService, 

          useFactory: (optionalParam) => new MyService(optionalParam)

          deps: [MY_OPTIONAL_SERVICE_PARAMETER]

      }

})

export class Module {}

The service will use the provided default value of the parameter (which could be undefined), unless the consumer overrides the value later in the list of providers.

The HttpModule from @angular/http uses this pattern to provide the optional dependency RequestOptions to its services.

so I've been trying to solve it. Check this:

@NgModule ({

  providers: [ 

    { provide: MyService, 

      useFactory: (optionalDep) => new MyService(optionalDep)

      deps: [[new Optional(), new Inject(SOME_DEP)]]

    }

})

class MyModule {}