Node.js middleware: Never again!

Node.js Middleware
Never again!
Timur Shemsedinov
Chief Technology Architect at Metarhia
Lecturer at Kiev Polytechnic Institute

const fs = require('fs'); const compose = (...funcs) => x => funcs.
reduce((x, fn) => fn(x), x); const DENSITY_COL = 3; const renderTab
table => { const cellWidth = [18, 10, 8, 8, 18, 6]; return table.ma
=> (row.map((cell, i) => { const width = cellWidth[i]; return i ? c
What is middleware?
● Connect contract
(req: Request, res: Response, next: NextFunction)
(req: Request, res: Response)
● Koa contract
async (ctx: Context, next: NextFunction): Promise
async (ctx: Context): Promise

Middlewares and Controller
Middleware
Middleware
Middleware(req, res, next)
Controller
(req, res)
(req, res, next)
(req, res, next)

What is middleware?
● Mixin provocation
● Reference pollution and shared state provocation
● Race condition provocation
● Abstraction leak provocation
● Fat controller and layers mix provocation
● High coupling provocation
● Error ignoring provocation

Middleware: Reference pollution
Middleware
Middleware
Controller
(req, res, next)
(req, res, next)
(req, res)

Middleware
Middleware
Controller
(req, res, next)
(req, res, next)
(req, res)
req, res

Middleware: Pass ref outer
const sockets = new Map();
app.use((req, res, next) => {
...
sockets.set(userId, req.socket);
...
next();
});
for (const socket of sockets) {
doSomethingWithSocket(socket);
}

Middleware
Middleware
Controller
(req, res, next)
(req, res, next)
(req, res)
instance.method(req, res, ...);
instance.method(req.socket, ...);
instance.ﬁeld = req.headers;
instance.emit('request', req);
const f1 = method.bind(req);
const f2 = method(req)(res);

Middleware
Middleware
Controller
(req, res, next)
(req, res, next)
(req, res)
const client = new Client(req, res);
abstraction.method(client);
instance.ﬁeld = client;
client.doSomething(instance);
emitter.emit('connected', client);
func(client).then(...).then(...)...;

Middleware
Middleware
Controller
(req, res, next)
(req, res, next)
(req, res)
calls

Middleware
Middleware
Controller
(req, res, next)
(req, res, next)
(req, res)
events
calls

Middleware
Middleware
Controller
(req, res, next)
(req, res, next)
(req, res)
events
calls
global

Middleware
Middleware
Controller
(req, res, next)
(req, res, next)
(req, res)
events
calls
global
ﬁelds

Middleware: Pass ref everywhere
const ee = new EventEmitter();
ee.emit('timeout', res);
next();
});
ee.on('timeout', res) => {
setTimeout(() => {
if (!res.writableEnded) res.end('timeout');
}, 5000);
});

Middleware: Race, data corruption
let userId;
userId = ...;
next();
});
app.get('/resource', (req, res) => {
if (checkAccess('/resource', userId) === GRANTED) {
res.end('You have an access');
}
});

Middleware: Mixin pollutions
Middleware
Middleware
Controller
(req, res, next)
(req, res, next) (req, res)

Middleware: mixin to req, res, ctx
res.groupName = 'idiots';
next();
});
app.get('/user', (req, res) => {
if (res.groupName === 'idiots') {
res.end('Welcome, my dear friend!');
}
});

Middleware: mixin to req, res, ctx
res.locals.groupName = 'idiots';
next();
});
app.get('/user', (req, res) => {
if (res.locals.groupName === 'idiots') {
res.end('Welcome, my dear friend!');
}
});

Middleware: Fat controller
Middleware
Middleware
Middleware Controller
● Access db
● Logging
● Parse headers
● Cache
● Business-logic
● Validation
● Serialization
(req, res, next)
(req, res)

Don’t mix in a single function
● Data access (database connection)
● Business-logic and domain model
● Routing, logging, conﬁguration
● Health and server state reporting
● Working with sockets, headers, cookies, etc.
● Serialization and deserialization
● Templating, caching, cryptography, sessions

Middleware: Fat controller
router.get('/user/:id', (req, res) => {
if (blacklist.has(res.socket.remoteAddress)) {...}
const id = parseInt(req.params.id);
if (!isValidateUserId(id)) return res.status(500);
const query = 'SELECT * FROM users WHERE id = $1';
pool.query(query, [id], (err, data) => {
if (err) {...}
logger.write(`access user: ${id}`);
res.status(200).json(data.rows);
});
});

Middleware provocates antipatterns
● Pass-through parameters,
Too many parameters, Data clump
● Accumulate and ﬁre
● Temporary ﬁeld, State mixins, Shared state,
Global state, State in outer contexts
● Inappropriate intimacy
● High coupling (also see high cohesion pattern)

Layered (onion) architecture
Data Access Layer
Middleware
Middleware
Controller
(req, res, next)
(req, res, next)
(req, res, next)
(req, res)
Service

domain
model
app
servicesuse cases
controllers
infrastructure

We need patterns and principles
● DIP (dependency inversion principle)
IoC (Inversion of control)
DI (dependency injection)
● Chain of responsibility (GoF)
● Law of demeter
● SRP (Single responsibility, SOLID)
● Low coupling (GRASP)

Keep attention on
● Domain in the middle
● Context isolation
● Layered (onion) architecture
● Don’t depend on frameworks
● Don’t move logic between model and controller
● Always work on abstraction leaking
● Protect data with parallel primitives

github.com/tshemsedinov
youtube.com/TimurShemsedinov
github.com/HowProgrammingWorks/Index
Весь курс по ноде и JS (186 лекций)
https://habr.com/ru/post/485294/
t.me/HowProgrammingWorks
t.me/NodeUA
timur.shemsedinov@gmail.com

Node.js middleware: Never again!

More Related Content

Similar to Node.js middleware: Never again! (20)

More from Timur Shemsedinov (15)

Recently uploaded (20)

Node.js middleware: Never again!