ng new the-real-world && cd the-real-world
ng add @nguniversal/express-engine --clientProject the-real-world
npm run build:ssr
npm run serve:ssr

const app = express();

const {AppServerModuleNgFactory, LAZY_MODULE_MAP} = require('./dist/server/main');

app.engine('html', ngExpressEngine({
  bootstrap: AppServerModuleNgFactory,
  providers: [
    provideModuleMap(LAZY_MODULE_MAP)
  ]
}));

app.set('view engine', 'html');
app.set('views', DIST_FOLDER);

app.get('*.*', express.static(DIST_FOLDER, {
  maxAge: '1y'
}));

app.get('*', (req, res) => {
  res.render('index', { req });
});

app.listen(PORT, () => {
  console.log(`Node Express server listening on http://localhost:${PORT}`);
});

@angular/platform-browser
@angular/platform-browser-dynamic
@angular/platform-server
@angular/platform-webworker // Gone!!
@angular/platform-webworker-dynamic // Gone!!
@angular/platform-terminal // !!!

// @angular/platform-server

@NgModule({
    exports: [BrowserModule],
    imports: [HttpModule, HttpClientModule, NoopAnimationsModule],
    providers: [
        SERVER_RENDER_PROVIDERS,
        SERVER_HTTP_PROVIDERS,
        // ...
    ] 
})
export class ServerModule { }

import { Component, Renderer2 } from '@angular/core'

@Component({
    // ...
})
export class MyComponent {
    constructor (
        private _renderer: Renderer2
    ) { }
}

@Injectable({
    providedIn: 'root'
})
export class WindowRef<T extends Window = Window> {
    private readonly _window: T | null;

    constructor () {
        this._window = this._getWindow();
    }

    public useWindow <U> (handler: (window: T) => U): U | null {
        return this._window ? handler(this._window): null;
    }

    public _getWindow (): T | null {
        return typeof window !== 'undefined' ? window as T : null;
    }
}

export const URL_LOCATION_TOKEN = new InjectionToken('URL_LOCATION');

@Injectable({
    // ...
})
export class UrlLocationService {
    constructor (
        private _window: WindowRef,
        @Optional() @Inject(URL_LOCATION_TOKEN) private _location: Location
    ) {
        this._location = this._location || this._window.useWindow(w => w.location);
    }

    public getHostname (): string {
        return this._location.hostname;
    }
}

declare var global: any
if (typeof window === 'undefined') {
  (global).window = {};
  (global).requestAnimationFrame = () => void 0;
  require('../src/cursor.js');
  delete (global).window;
  delete (global).requestAnimationFrame;
}

import { isPlatformBrowser, isPlatformServer } from '@angular/common';
import { Inject, PLATFORM_ID } from '@angular/core';

@Component({
    // ...
})
export class MyComponent {
    constructor (
        @Inject(PLATFORM_ID) private _platformId: Object
    ) { }

    public myExpensiveDomHeavyOperation (): void {
        if (!isPlatformBrowser(this._platformId) {
            return;
        }

        this._useTheDom();
    }
}

@Component({
    // ...
})
export class MapComponent implements AfterViewInit {
    @ViewChild('map', { static: true }) public map: ElementRef;

    constructor (
        @Optional() private _mapService: MapService
    ) { }

    public ngAfterViewInit (): void {
        if (!this._mapService) {
            return;
        }


        this._init();
    }
}

@NgModule({
    imports: [
        // ...
    ],
    bootstrap: [AppComponent],
    providers: [
        { provide: VideoService, useValue: null }
    ]
})
export class AppServerModule { }

@Component({
    // ...
})
export class AppComponent implements OnInit {
    public castMember: CastMember;

    constructor (
        private _castMemberDataService: CastMemberDataService
    ) { }

    public ngOnInit (): void {
        this._castMemberDataService.getCastMember()
            .subscribe(data => this.castMember = data);
    }
}

import { TransferState, makeStateKey } from '@angular/platform-browser';

const CAST_MEMBER = makeStateKey('castMember');

@Component({
    // ...
})
export class AppComponent implements OnInit {
    public castMember: CastMember

    constructor (
        private _castMemberDataService: CastMemberDataService,
        private _state: TransferState
    ) { }

    public ngOnInit (): void {
        this.castMember = this.state.get(CAST_MEMBER, null);

        if (!this.castMember) {
            this._castMemberDataService.getCastMember()
                .subscribe(data => {
                    this.castMember = data;
                    this.state.set(CAST_MEMBER, data);
                });
        }
    }
}

@NgModule({
    imports: [BrowserTransferStateModule]
})
export class ServerStateModule {
    constructor (
        private _transferState: TransferState,
        private _store: Store<State>
    ) {
        this._transferState.onSerialize(STATE_KEY, () => {
            let stateToTransfer = null;
            this._store.pipe(
                select(state => state),
                take(1)
            ).subscribe(state => stateToTransfer = state);

            return stateToTransfer;
        });
    }
}

@NgModule({
    imports: [BrowserTransferStateModule]
})
export class ClientStateModule {
    constructor (
        private _transferState: TransferState,
        private _store: Store<State>
    ) {
        if (this._transferState.hasKey(STATE_KEY)) {
            const state = this._transferState.get<State>(STATE_KEY, {});
            this._transferState.remove(STATE_KEY);

            this.store.dispatch(new TransferStateAction(state));
        }
    }
}

@Effect()
public getCastMemberDataEffect$ = this._actions.pipe(
    ofType<GetCastMemberDataAction>(GetCastMemberDataAction.TYPE),
    switchMap(action => 
        this._store.pipe(
            select(CastMemberDataSelectors.currentCastMemberData),
            take(1),
            filter(storeItem => this._cacheService.shouldFetch(storeItem, { expiryTime: 120000 })),
            map(() => new GetCastMemberDataFromApi(action.options)
        )
    )

@Effect()
public getCastMemberDataFromApiEffect$ = this._actions.pipe(
    ofType<GetCastMemberDataFromApi>(GetCastMemberDataFromApi.TYPE),
    switchMap(action => 
        this._castMemberDataService.getAsteroidData(action.options).pipe(
            map(() => new GetCastMemberDataFromApiSucccess(action.options, response, new Data().toString())),
            catchError(err => of(new GetCastMembersDataFromApiFail(actions, options, err)))
        )
    )