Bodzio Bodzio - 1 month ago 32
Javascript Question

How to pass parameters rendered from backend to angular2 bootstrap method

Is there a way to pass arguments rendered on the backend to angular2 bootstrap method? I want to set http header for all requests using BaseRequestOptions with value provided from the backend. My

file looks like this:

import { bootstrap } from '@angular/platform-browser-dynamic';
import { AppComponent } from "./app.component.ts";


I found how to pass this arguments to root component (, but i need it when I'm fireing
method... Any ideas?


webpack.config.js content:

module.exports = {
entry: {
app: "./Scripts/app/main.ts"

output: {
filename: "./Scripts/build/[name].js"

resolve: {
extensions: ["", ".ts", ".js"]

module: {
loaders: [
test: /\.ts$/,
loader: 'ts-loader'


update an RC.6 and 2.0.0 final example

    declarations: [AppComponent],
    imports: [BrowserModule,
    providers: [AuthService,
        { provide: APP_INITIALIZER,
          useFactory: (config: ConfigService) => () => config.load(),
          deps: [ConfigService], 
          multi: true }
    bootstrap: [AppComponent]
export class AppModule { }

If there is no need to wait for the initialization to complete, the constructor of `class AppModule {} can also be used:

class AppModule {
  constructor(/*inject required dependencies */) {...} 

hint (cyclic dependency)

For example injecting the router can cause cyclic dependencies. To work around, inject the Injector and get the dependency by

this.myDep = injector.get(MyDependency);

instead of injecting MyDependency directly like:

export class ConfigService {
  private router:Router;
  constructor(/*private router:Router*/ injector:Injector) {
    this.router = injector.get(Router);


This should work the same in RC.5 but instead add the provider to providers: [...] of the root module instead of bootstrap(...)

(not tested myself yet).


An interesting approach to do it entirely inside Angular is explained here

You can use APP_INITIALIZER which will execute a function when the app is initialized and delay what it provides if the function returns a promise. This means the app can be initializing without quite so much latency and you can also use the existing services and framework features.

As an example, suppose you have a multi-tenanted solution where the site info relies on the domain name it's being served from. This can be [name] or a custom domain which is matched on the full hostname. We can hide the fact that this is behind a promise by using APP_INITIALIZER.

In bootstrap:

{provide: APP_INITIALIZER, useFactory: (sites:SitesService) => () => sites.load(), deps:[SitesService, HTTP_PROVIDERS], multi: true}),


export class SitesService {
  public current:Site;

  constructor(private http:Http, private config:Config) { }

  load():Promise<Site> {
    var url:string;
    var pos = location.hostname.lastIndexOf(this.config.rootDomain);
    var url = (pos === -1)
      ? this.config.apiEndpoint + '/sites?host=' + location.hostname
      : this.config.apiEndpoint + '/sites/' + location.hostname.substr(0, pos);
    var promise = this.http.get(url).map(res => res.json()).toPromise();
    promise.then(site => this.current = site);
    return promise;

NOTE: config is just a custom config class. rootDomain would be '' for this example and would allow things like

Any components and other services can now have Site injected into them and use the .current property which will be a concrete populated object with no need to wait on any promise within the app.

This approach seemed to cut the startup latency which was otherwise quite noticeable if you were waiting for the large Angular bundle to load and then another http request before the bootstrap even began.


You can pass it using Angulars dependency injection:

var headers = ... // get the headers from the server

bootstrap(AppComponent, [{provide: 'headers', useValue: headers})]);
class SomeComponentOrService {
   constructor(@Inject('headers') private headers) {}

or provide prepared BaseRequestOptions directly like

class MyRequestOptions extends BaseRequestOptions {
  constructor (private headers) {

var values = ... // get the headers from the server
var headers = new MyRequestOptions(values);

bootstrap(AppComponent, [{provide: BaseRequestOptions, useValue: headers})]);