martes, 29 de mayo de 2018

How to convert your Angular 5 app to Universal with ngUniversal

Hi there again! Today I come with a new situation that I solve using Universal in my Angular app with ngUniversal.

The situation:

I developed an application (here is the repository). When I begin using google search engine and other engines to index my web, I've found the problem that my web is not indexed correctly.

When I change the language of the web, the title, the description and the keywords don't change. So google and other engines only index my main index.html file.

With Universal, you can change it, and I'm going to explain how.

The code you have to change:

In my package.json file, I have these dependencies and I show the run you have to define:

"scripts": {
"universal": "ng build --prod client && ng build --prod --app server --output-hashing=false && webpack --config webpack.server.config.js --progress --colors && node dist/server.js",
"ng": "ng",
"start": "ng serve",
"build": "ng build",
"test": "ng test",
"lint": "ng lint",
"e2e": "ng e2e"
"dependencies": {
"@angular/animations": "^5.0.0",
"@angular/common": "^5.0.0",
"@angular/compiler": "^5.0.0",
"@angular/core": "^5.0.0",
"@angular/forms": "^5.0.0",
"@angular/http": "^5.0.0",
"@angular/language-service": "^5.0.0",
"@angular/platform-browser": "^5.0.0",
"@angular/platform-browser-dynamic": "^5.0.0",
"@angular/platform-server": "^5.0.0",
"@angular/router": "^5.0.0",
"@nguniversal/common": "^5.0.0-beta.5",
"@nguniversal/express-engine": "^5.0.0-beta.5",
"@nguniversal/module-map-ngfactory-loader": "^5.0.0-beta.5",
"@ngx-translate/core": "8.0.0",
"@ngx-translate/http-loader": "2.0.0"

The trick of Universal in Angular is to separate what the browser shows and what the server needs to compile for shows the browser.

You need to create an AppServerModule.ts that use the AppModule.ts of your application:

import { NgModule } from '@angular/core';
import { ServerModule, ServerTransferStateModule } from '@angular/platform-server';
import { ModuleMapLoaderModule } from '@nguniversal/module-map-ngfactory-loader';

import { AppModule } from './app.module';
import { TemplateComponent } from '../template/template.component';
import { TranslateModule, TranslateLoader } from '@ngx-translate/core';
import { TransferState } from '@angular/platform-browser';
import { HttpClient } from '@angular/common/http';
import { translateFactory } from './translate-universal-loader.service';

imports: [
// The AppServerModule should import your AppModule followed
// by the ServerModule from @angular/platform-server.
loader: {
provide: TranslateLoader,
useFactory: translateFactory
// Since the bootstrapped component is not inherited from your
// imported AppModule, it needs to be repeated here.
bootstrap: [TemplateComponent],
export class AppServerModule {
constructor() {

So Universal is separating the Server and the Browser, you have to indicate to your application which parts will be and those parts.

Here you can see my TemplateComponent (that is like an AppComponent):

constructor(@Inject(PLATFORM_ID) private platformId: Object,
public authService: AuthService,
private translate: TranslateService,
private route: ActivatedRoute,
private languageService: LanguageService,
private titleService: Title,
private metaService: Meta) {

ngOnInit() {
if (isPlatformBrowser(this.platformId)) {
// Client only code.
if (isPlatformServer(this.platformId)) {
// Server only code.

You have to know that some HTML access components are not permitted in Server Part. It's logic, so you don't have access to the dom of the browser. These not permitted uses are for example the access to DOM objects of the HTML or to the navigator.

So this code has to be on the browser part:

if(!userLang || userLang == "") {
userLang = navigator.language;
if(userLang.startsWith("zh")) {
userLang = "zh";

Also, you need to create a main.server.ts file in the same directory of main.ts with this line:

export { AppServerModule } from './app/core/app.server.module';

Also, you need a tsconfig.server.json file with this content and in the same directory of

"extends": "../tsconfig.json",
"compilerOptions": {
"outDir": "../out-tsc/app",
"baseUrl": "./",
"module": "commonjs",
"types": []
"exclude": [
"angularCompilerOptions": {
"entryModule": "app/core/app.server.module#AppServerModule"

Also, you need a webpack.server.config.js file like this (just copy-paste):

const path = require('path');
const webpack = require('webpack');

module.exports = {
entry: { server: './server.ts' },
resolve: { extensions: ['.js', '.ts'] },
target: 'node',
// this makes sure we include node_modules and other 3rd party libraries
externals: [/(node_modules|main\..*\.js)/],
output: {
path: path.join(__dirname, 'dist'),
filename: '[name].js'
module: {
rules: [
{ test: /\.ts$/, loader: 'ts-loader' }
plugins: [
// Temporary Fix for issue:
// for "WARNING Critical dependency: the request of a dependency is an expression"
new webpack.ContextReplacementPlugin(
path.join(__dirname, 'src'), // location of your src
{} // a map of your routes
new webpack.ContextReplacementPlugin(
path.join(__dirname, 'src'),

And you have to modify your .angular-cli.json file adding a new app. So you are going to have two apps (the client app and the server app). This separation is used on the run script defined on the package.json.

This will be the .angular-cli.json file:

"$schema": "./node_modules/@angular/cli/lib/config/schema.json",
"project": {
"name": ""
"apps": [
"name": "client",
"root": "src",
"outDir": "dist/browser",
"assets": [
"index": "index.html",
"main": "main.ts",
"polyfills": "polyfills.ts",
"test": "test.ts",
"tsconfig": "",
"testTsconfig": "tsconfig.spec.json",
"prefix": "app",
"styles": [
"scripts": [
"environmentSource": "environments/environment.ts",
"environments": {
"dev": "environments/environment.ts",
"prod": "environments/"
"name": "server",
"platform": "server",
"root": "src",
"outDir": "dist/server",
"assets": [
"index": "index.html",
"main": "main.server.ts",
"test": "test.ts",
"tsconfig": "tsconfig.server.json",
"testTsconfig": "tsconfig.spec.json",
"prefix": "app",
"styles": [
"scripts": [
"environmentSource": "environments/environment.ts",
"environments": {
"dev": "environments/environment.ts",
"prod": "environments/"
"e2e": {
"protractor": {
"config": "./protractor.conf.js"
"lint": [
"project": "src/",
"exclude": "**/node_modules/**"
"project": "src/tsconfig.spec.json",
"exclude": "**/node_modules/**"
"project": "e2e/tsconfig.e2e.json",
"exclude": "**/node_modules/**"
"test": {
"karma": {
"config": "./karma.conf.js"
"defaults": {
"styleExt": "css",
"component": {}

And finally, you need a server.ts file in the same directory of the package.json file. My server.ts looks like this:

// These are important and needed before anything else
import 'zone.js/dist/zone-node';
import 'reflect-metadata';

import { renderModuleFactory } from '@angular/platform-server';
import { enableProdMode } from '@angular/core';

import * as express from 'express';
import { join } from 'path';
import { readFileSync } from 'fs';

(global as any).WebSocket = require('ws');
(global as any).XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest;

// Faster server renders w/ Prod mode (dev mode never needed)

// Express server
const app = express();

//app.urlencoded({extended: false});

const PORT = process.env.PORT || 4000;
const HTTPS_PORT = process.env.HTTPS_PORT || 4443;


const DIST_FOLDER = join(process.cwd(), 'dist');

// Our index.html we'll use as our template
const template = readFileSync(join(DIST_FOLDER, 'browser', 'index.html')).toString();

// * NOTE :: leave this as require() since this file is built Dynamically from webpack
const { AppServerModuleNgFactory, LAZY_MODULE_MAP } = require('./dist/server/main.bundle');

// Express Engine
import { ngExpressEngine } from '@nguniversal/express-engine';

// Import module map for lazy loading
import { provideModuleMap } from '@nguniversal/module-map-ngfactory-loader';
app.engine('html', (_, options, callback) => {
const opts = { document: template, url: options.req.url };

renderModuleFactory(AppServerModuleNgFactory, opts)
.then(html => callback(null, html));
app.engine('html', ngExpressEngine({
bootstrap: AppServerModuleNgFactory,
providers: [

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

// Our page routes
export const routes: string[] = [

// All regular routes use the Universal engine
app.get('/', (req, res) => {
console.time(`GET: ${req.originalUrl}`);
res.render(join(DIST_FOLDER, 'browser', 'index.html'), { req, res } );
console.timeEnd(`GET: ${req.originalUrl}`);

routes.forEach(route => {
app.get(`/${route}`, (req, res) => {
//res.json({'lang': req.query.lang});
console.time(`GET: ${req.originalUrl}`);
res.render(join(DIST_FOLDER, 'browser', 'index.html'), { req, res } );
console.timeEnd(`GET: ${req.originalUrl}`);
app.get(`/${route}/*`, (req, res) => {
//res.json({'lang': req.query.lang});
console.time(`GET: ${req.originalUrl}`);
res.render(join(DIST_FOLDER, 'browser', 'index.html'), { req, res } );
console.timeEnd(`GET: ${req.originalUrl}`);

// Server static files from /browser
app.get('/web', express.static(join(DIST_FOLDER, 'browser'), { 'index': false }));

app.get('/**', express.static(join(DIST_FOLDER, 'browser')));

// All other routes must be resolved if exist
app.get('*', function(req, res) {
res.render(join(req.url), { req });

var http = require('http');

var httpServer = http.createServer(app);

// Start up the Node server at PORT
httpServer.listen(PORT, () => {
console.log(`Node server listening on http://localhost:${PORT}`);


var fs = require('fs');
var https = require('https');

var privateKey = fs.readFileSync(KEY_CERTIFICATE, 'utf8');
var certificate = fs.readFileSync(CRT_CERTIFICATE, 'utf8');

var credentials = {
key: privateKey,
cert: certificate,
var httpsServer = https.createServer(credentials, app);

// Start up the Node server at HTTP_PORT
httpsServer.listen(HTTPS_PORT, () => {
console.log(`Node server listening on http://localhost:${HTTPS_PORT}`);

I've defined some URLs of my application that use the ServerModule and the rest of the URLs in the domain access statically. Also, I've defined an HTTP and an HTTPS server for secure connections defined on my node server.

And that's all! Is not easy, but works very good.

I hope you enjoy my tutorial and ask me any question you have with this trick.

You can see my project on production in this URL:

Have a nice day!