function myMiddleware(request, response, next) {
    if (typeof next !== 'function') {
        next = () => {};
    }
    console.log('Incoming request');
    next();
}

const http = require('http');
const middlewares = [];
/**
* Основной обработчик HTTP-запросов
*
* Пока что тут только заглушка
*
* @param {IncomingMessage} request
* @param {ServerResponse} response
* @return {Promise<void>}
*/
async function requestListener(request, response) {
    throw new Error('Not implemented');
}
/*
* Функция-регистратор middleware-кода
*/
function registerMiddleware(callback) {
    if (typeof callback !== 'function') {
        return;
    }
    middlewares.push(callback);
}
// Создаётся сервер и регистрируется осноной обработчик
const server = http.createServer(requestListener);
// К серверу добавляется регистратор middleware-функций
server.use = registerMiddleware;

/*
* Это просто служебная функция — вставлена здесь для примера
* и сама по себе обычно находится в другом модуле
*/
function isError(error) {
    switch (Object.prototype.toString.call(error)) {
        case '[object Error]':
            return true;
        case '[object Object]':
            return (
                error.message
                && typeof error.message === 'string'
                && error.stack
                && typeof error.stack === 'string'
            );
    }
    return false;
}
/**
* Основной обработчик HTTP-запросов
*
* @param {IncomingMessage} request
* @param {ServerResponse} response
* @return {Promise<void>}
*/
async function requestListener(request, response) {
    response.isFinished = false;
    response.on('finish', () => response.isFinished = true);
    response.on('close', () => response.isFinished = true);
    let result;
    try {
        result = await middlewares.reduce(
            // Редусер. Первый параметр — предыдущее значение,
            // второй — текущее. Чтобы обеспечить асинхронность,
            // всё оборачивается в Promise.
            (/**Promise*/promise, middleware) => promise.then(result => {
                // Если в предыдущем middleware был вызов
                // next(new Error('Some message')), текущий middleware
                // игнорируется и сразу возвращается ошибка
                // из предыдущего кода
                if (isError(result)) {
                    return Promise.reject(result);
                }
                // Возвращается новый Promise, который, кроме прочего,
                // реагирует на какую-то ошибку в рамках не только
                // вызова next, но и в рамках всего кода.
                // То есть, если middleware вызывает внутри JSON.parse
                // без try-catch, то, в случае ошибки парсинга, реакция
                // будет такая же, как и при вызове next с передачей
                // ошибки в качестве параметра
                return new Promise((next, reject) => {
                    Promise.resolve(middleware(request, response, next)).catch(reject);
                });
            }),
            Promise.resolve()
        );
        if (isError(result)) {
            throw result;
        }
    } catch (error) {
        response.statusCode = 500;
        result = 'Error';
    }
    if (response.isFinished) {
        return;
    }
    response.end(result);
}

const cookieParser = require('cookie-parser');
server.use(cookieParser());
// Мой основной код
server.use((request, response, next) => {
    if (request.cookies['SSID']) {
        response.end('Your session id is ' + request.cookies['SSID']);
    } else {
        response.end('No session detected');
    }
    next();
});