@e22m4u/js-http-static-router 0.1.2 → 0.2.1

package/src/utils/create-response-mock.js

@@ -0,0 +1,131 @@
+import {PassThrough} from 'stream';
+
+/**
+ * Create response mock.
+ *
+ * @returns {import('http').ServerResponse}
+ */
+export function createResponseMock() {
+  const response = new PassThrough();
+  response.statusCode = 200;
+  patchEncoding(response);
+  patchHeaders(response);
+  patchBody(response);
+  return response;
+}
+
+/**
+ * Patch encoding.
+ *
+ * @param {object} response
+ */
+function patchEncoding(response) {
+  Object.defineProperty(response, '_encoding', {
+    configurable: true,
+    writable: true,
+    value: undefined,
+  });
+  Object.defineProperty(response, 'setEncoding', {
+    configurable: true,
+    value: function (enc) {
+      this._encoding = enc;
+      return this;
+    },
+  });
+  Object.defineProperty(response, 'getEncoding', {
+    configurable: true,
+    value: function () {
+      return this._encoding;
+    },
+  });
+}
+
+/**
+ * Patch headers.
+ *
+ * @param {object} response
+ */
+function patchHeaders(response) {
+  Object.defineProperty(response, '_headersSent', {
+    configurable: true,
+    writable: true,
+    value: false,
+  });
+  Object.defineProperty(response, 'headersSent', {
+    configurable: true,
+    get() {
+      return this._headersSent;
+    },
+  });
+  Object.defineProperty(response, '_headers', {
+    configurable: true,
+    writable: true,
+    value: {},
+  });
+  Object.defineProperty(response, 'setHeader', {
+    configurable: true,
+    value: function (name, value) {
+      if (this.headersSent) {
+        throw new Error(
+          'Error [ERR_HTTP_HEADERS_SENT]: ' +
+            'Cannot set headers after they are sent to the client',
+        );
+      }
+      const key = name.toLowerCase();
+      this._headers[key] = Array.isArray(value)
+        ? [...value.map(String)]
+        : String(value);
+      return this;
+    },
+  });
+  Object.defineProperty(response, 'getHeader', {
+    configurable: true,
+    value: function (name) {
+      return this._headers[name.toLowerCase()];
+    },
+  });
+  Object.defineProperty(response, 'getHeaders', {
+    configurable: true,
+    value: function () {
+      return JSON.parse(JSON.stringify(this._headers));
+    },
+  });
+}
+
+/**
+ * Patch body.
+ *
+ * @param {object} response
+ */
+function patchBody(response) {
+  let resolve, reject;
+  const promise = new Promise((rsv, rej) => {
+    resolve = rsv;
+    reject = rej;
+  });
+  const data = [];
+  response.on('data', c => data.push(c));
+  response.on('error', e => reject(e));
+  response.on('end', () => {
+    resolve(Buffer.concat(data));
+  });
+  // флаг _headersSent должен быть установлен синхронно
+  // после вызова метода response.end, так как асинхронная
+  // установка (к примеру в response.on('end')) не позволит
+  // отследить отправку ответа при синхронном выполнении
+  const originalEnd = response.end.bind(response);
+  response.end = function (...args) {
+    this._headersSent = true;
+    return originalEnd(...args);
+  };
+  Object.defineProperty(response, 'getBody', {
+    configurable: true,
+    value: function () {
+      return promise.then(buffer => {
+        const enc = this.getEncoding();
+        const str = buffer.toString(enc);
+        return data.length ? str : undefined;
+      });
+    },
+  });
+}

package/src/utils/create-response-mock.spec.js

@@ -0,0 +1,150 @@
+import {expect} from 'chai';
+import {PassThrough} from 'stream';
+import {createResponseMock} from './create-response-mock.js';
+
+describe('createResponseMock', function () {
+  it('should return an instance of PassThrough', function () {
+    const res = createResponseMock();
+    expect(res).to.be.instanceof(PassThrough);
+  });
+
+  describe('statusCode', function () {
+    it('should be initialized with 200 by default', function () {
+      const res = createResponseMock();
+      expect(res.statusCode).to.be.eq(200);
+    });
+  });
+
+  describe('setEncoding', function () {
+    it('should set the given encoding and return the response', function () {
+      const res = createResponseMock();
+      expect(res._encoding).to.be.undefined;
+      const ret = res.setEncoding('utf-8');
+      expect(ret).to.be.eq(res);
+      expect(res._encoding).to.be.eq('utf-8');
+    });
+  });
+
+  describe('getEncoding', function () {
+    it('should return the current encoding', function () {
+      const res = createResponseMock();
+      expect(res._encoding).to.be.undefined;
+      const ret1 = res.getEncoding();
+      expect(ret1).to.be.undefined;
+      res._encoding = 'utf-8';
+      const ret2 = res.getEncoding();
+      expect(ret2).to.be.eq('utf-8');
+    });
+  });
+
+  describe('headersSent', function () {
+    it('should return false when the response is not sent', function () {
+      const res = createResponseMock();
+      expect(res._headersSent).to.be.false;
+      expect(res.headersSent).to.be.false;
+    });
+
+    it('should return a value from the "_headersSent" property', function () {
+      const res = createResponseMock();
+      expect(res._headersSent).to.be.false;
+      expect(res.headersSent).to.be.false;
+      res._headersSent = true;
+      expect(res.headersSent).to.be.true;
+    });
+  });
+
+  describe('setHeader', function () {
+    it('should set the given header and return the response', function () {
+      const res = createResponseMock();
+      expect(res._headers['foo']).to.be.eq(undefined);
+      const ret = res.setHeader('foo', 'bar');
+      expect(ret).to.be.eq(res);
+      expect(res._headers['foo']).to.be.eq('bar');
+    });
+
+    it('should throw an error when headers are sent', function () {
+      const res = createResponseMock();
+      res._headersSent = true;
+      const throwable = () => res.setHeader('foo');
+      expect(throwable).to.throw(
+        'Error [ERR_HTTP_HEADERS_SENT]: ' +
+          'Cannot set headers after they are sent to the client',
+      );
+    });
+
+    it('should set the header value as a String', function () {
+      const res = createResponseMock();
+      expect(res._headers['num']).to.be.eq(undefined);
+      const ret = res.setHeader('num', 10);
+      expect(ret).to.be.eq(res);
+      expect(res._headers['num']).to.be.eq('10');
+    });
+
+    it('should not stringify an array value', function () {
+      const res = createResponseMock();
+      expect(res._headers['key']).to.be.eq(undefined);
+      const ret = res.setHeader('key', ['foo', 'bar']);
+      expect(ret).to.be.eq(res);
+      expect(res._headers['key']).to.be.eql(['foo', 'bar']);
+    });
+
+    it('should stringify an array elements', function () {
+      const res = createResponseMock();
+      expect(res._headers['key']).to.be.eq(undefined);
+      const ret = res.setHeader('key', [1, 2]);
+      expect(ret).to.be.eq(res);
+      expect(res._headers['key']).to.be.eql(['1', '2']);
+    });
+  });
+
+  describe('getHeader', function () {
+    it('should return the header value if exists', function () {
+      const res = createResponseMock();
+      res._headers['foo'] = 'bar';
+      const ret = res.getHeader('foo');
+      expect(ret).to.be.eq('bar');
+    });
+
+    it('should ignore case-sensitivity for header names', function () {
+      const res = createResponseMock();
+      res._headers['foo'] = 'bar';
+      const ret = res.getHeader('FOO');
+      expect(ret).to.be.eq('bar');
+    });
+  });
+
+  describe('getHeaders', function () {
+    it('should return a copy of the headers object', function () {
+      const res = createResponseMock();
+      const ret1 = res.getHeaders();
+      res._headers['foo'] = 'bar';
+      res._headers['baz'] = 'qux';
+      const ret2 = res.getHeaders();
+      expect(ret1).to.be.eql({});
+      expect(ret2).to.be.eql({foo: 'bar', baz: 'qux'});
+      expect(ret1).not.to.be.eq(res._headers);
+      expect(ret2).not.to.be.eq(res._headers);
+    });
+  });
+
+  describe('getBody', function () {
+    it('should return a Promise of the stream content', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const res = createResponseMock();
+      res.end(body);
+      const promise = res.getBody();
+      expect(promise).to.be.instanceof(Promise);
+      const result = await promise;
+      expect(result).to.be.eq(body);
+    });
+  });
+
+  describe('Stream', function () {
+    it('should set the property "headersSent" to true when the stream ends', function () {
+      const res = createResponseMock();
+      expect(res.headersSent).to.be.false;
+      res.end('test');
+      expect(res.headersSent).to.be.true;
+    });
+  });
+});

package/src/utils/fetch-request-body.d.ts

@@ -0,0 +1,26 @@
+import {IncomingMessage} from 'http';
+
+/**
+ * Character encoding list.
+ */
+export const CHARACTER_ENCODING_LIST: (
+  | 'ascii'
+  | 'utf8'
+  | 'utf-8'
+  | 'utf16le'
+  | 'utf-16le'
+  | 'ucs2'
+  | 'ucs-2'
+  | 'latin1'
+)[];
+
+/**
+ * Fetch request body.
+ *
+ * @param request
+ * @param bodyBytesLimit
+ */
+export declare function fetchRequestBody(
+  request: IncomingMessage,
+  bodyBytesLimit?: number,
+): Promise<string | undefined>;

package/src/utils/fetch-request-body.js

@@ -0,0 +1,148 @@
+import HttpErrors from 'http-errors';
+import {IncomingMessage} from 'http';
+import {createError} from './create-error.js';
+import {InvalidArgumentError} from '@e22m4u/js-format';
+import {parseContentType} from './parse-content-type.js';
+
+/**
+ * Character encoding list.
+ */
+export const CHARACTER_ENCODING_LIST = [
+  'ascii',
+  'utf8',
+  'utf-8',
+  'utf16le',
+  'utf-16le',
+  'ucs2',
+  'ucs-2',
+  'latin1',
+];
+
+/**
+ * Fetch request body.
+ *
+ * @param {IncomingMessage} request
+ * @param {number} bodyBytesLimit
+ * @returns {Promise<string|undefined>}
+ */
+export function fetchRequestBody(request, bodyBytesLimit = 0) {
+  if (!(request instanceof IncomingMessage)) {
+    throw new InvalidArgumentError(
+      'Parameter "request" must be an instance of IncomingMessage, ' +
+        'but %v was given.',
+      request,
+    );
+  }
+  if (typeof bodyBytesLimit !== 'number') {
+    throw new InvalidArgumentError(
+      'Parameter "bodyBytesLimit" must be a Number, but %v was given.',
+      bodyBytesLimit,
+    );
+  }
+  return new Promise((resolve, reject) => {
+    // сравнение внутреннего ограничения
+    // размера тела запроса с заголовком
+    // "content-length"
+    const contentLength = parseInt(
+      request.headers['content-length'] || '0',
+      10,
+    );
+    if (bodyBytesLimit && contentLength && contentLength > bodyBytesLimit) {
+      throw createError(
+        HttpErrors.PayloadTooLarge,
+        'Request body limit is %s bytes, but %s bytes given.',
+        bodyBytesLimit,
+        contentLength,
+      );
+    }
+    // определение кодировки
+    // по заголовку "content-type"
+    let encoding = 'utf-8';
+    const contentType = request.headers['content-type'] || '';
+    if (contentType) {
+      const parsedContentType = parseContentType(contentType);
+      if (parsedContentType && parsedContentType.charset) {
+        encoding = parsedContentType.charset.toLowerCase();
+        if (!CHARACTER_ENCODING_LIST.includes(encoding)) {
+          throw createError(
+            HttpErrors.UnsupportedMediaType,
+            'Request encoding %v is not supported.',
+            encoding,
+          );
+        }
+      }
+    }
+    // подготовка массива загружаемых байтов
+    // и счетчика для отслеживания их объема
+    const data = [];
+    let receivedLength = 0;
+    // обработчик проверяет объем загружаемых
+    // данных и складывает их в массив
+    const onData = chunk => {
+      receivedLength += chunk.length;
+      if (bodyBytesLimit && receivedLength > bodyBytesLimit) {
+        cleanupListeners();
+        const error = createError(
+          HttpErrors.PayloadTooLarge,
+          'Request body limit is %v bytes, but %v bytes given.',
+          bodyBytesLimit,
+          receivedLength,
+        );
+        // после удаления слушателей поток продолжает быть
+        // в состоянии resume (flowing mode), данные будут
+        // считываться в никуда, и чтобы сэкономить трафик
+        // и ресурсы сервера при превышении лимита,
+        // выполняется уничтожение потока запроса
+        request.unpipe();
+        request.destroy();
+        reject(error);
+        return;
+      }
+      data.push(chunk);
+    };
+    // кода данные полностью загружены, нужно удалить
+    // обработчики событий, и сравнить полученный объем
+    // данных с заявленным в заголовке "content-length"
+    const onEnd = () => {
+      cleanupListeners();
+      if (contentLength && contentLength !== receivedLength) {
+        const error = createError(
+          HttpErrors.BadRequest,
+          'Received bytes do not match the "content-length" header.',
+        );
+        reject(error);
+        return;
+      }
+      // объединение массива байтов в буфер, кодирование
+      // результата в строку, и передача полученных данных
+      // в ожидающий Promise
+      const buffer = Buffer.concat(data);
+      const body = buffer.toString(encoding);
+      resolve(body || undefined);
+    };
+    // при ошибке загрузки тела запроса,
+    // удаляются обработчики событий,
+    // и отклоняется ожидающий Promise
+    // ошибкой с кодом 400
+    const onError = error => {
+      cleanupListeners();
+      reject(HttpErrors(400, error));
+    };
+    // запрос может иметь слушателей, установленных самим Node.js
+    // сервером или другими инструментами, которые подписались
+    // на close, aborted или error, потому нельзя использовать
+    // метод removeAllListeners
+    const cleanupListeners = () => {
+      request.removeListener('data', onData);
+      request.removeListener('end', onEnd);
+      request.removeListener('error', onError);
+    };
+    // добавление обработчиков прослушивающих
+    // события входящего запроса и возобновление
+    // потока данных
+    request.on('data', onData);
+    request.on('end', onEnd);
+    request.on('error', onError);
+    request.resume();
+  });
+}

package/src/utils/fetch-request-body.spec.js

@@ -0,0 +1,209 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {fetchRequestBody} from './fetch-request-body.js';
+import {createRequestMock} from './create-request-mock.js';
+
+describe('fetchRequestBody', function () {
+  it('should require the parameter "request" to be an instance of IncomingMessage', function () {
+    const throwable = v => () => fetchRequestBody(v);
+    const error = v =>
+      format(
+        'Parameter "request" must be an instance of IncomingMessage, ' +
+          'but %s was given.',
+        v,
+      );
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error('0'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable(null)).to.throw(error('null'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
+    throwable(createRequestMock())();
+  });
+
+  it('should require the parameter "bodyBytesLimit" to be a Number', function () {
+    const req = createRequestMock();
+    const throwable = v => () => fetchRequestBody(req, v);
+    const error = v =>
+      format(
+        'Parameter "bodyBytesLimit" must be a Number, but %s was given.',
+        v,
+      );
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable(null)).to.throw(error('null'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    throwable(10)();
+    throwable(0)();
+    throwable(undefined)();
+  });
+
+  it('should return a string from the string body', async function () {
+    const body = 'Lorem Ipsum is simply dummy text.';
+    const req = createRequestMock({body});
+    const result = await fetchRequestBody(req);
+    expect(result).to.be.eq(body);
+  });
+
+  it('should return a string from the buffer body', async function () {
+    const body = 'Lorem Ipsum is simply dummy text.';
+    const req = createRequestMock({body: Buffer.from(body)});
+    const result = await fetchRequestBody(req);
+    expect(result).to.be.eq(body);
+  });
+
+  describe('encoding usage from the "content-type" header', function () {
+    it('should throw an error for an unsupported encoding', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const req = createRequestMock({
+        body,
+        headers: {'content-type': 'text/plain; charset=unknown'},
+      });
+      const promise = fetchRequestBody(req);
+      await expect(promise).to.be.rejectedWith(
+        'Request encoding "unknown" is not supported.',
+      );
+    });
+
+    it('should ignore the "content-type" header when no charset specified', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const req = createRequestMock({
+        body,
+        headers: {'content-type': 'text/plain'},
+      });
+      const result = await fetchRequestBody(req);
+      expect(result).to.be.eq(body);
+    });
+
+    it('should decode non-UTF-8 encoding to a plain text', async function () {
+      const originalBody = 'Hello, world!';
+      const req = createRequestMock({
+        body: originalBody,
+        encoding: 'latin1',
+        headers: {'content-type': `text/plain; charset=latin1`},
+      });
+      const result = await fetchRequestBody(req);
+      expect(result).to.be.eq(originalBody);
+    });
+  });
+
+  describe('the "content-length" header usage', function () {
+    it('should throw an error if the body length is greater than the header', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const bodyLength = Buffer.from(body).byteLength;
+      const contentLength = String(bodyLength + 10);
+      const req = createRequestMock({
+        body,
+        headers: {'content-length': contentLength},
+      });
+      const promise = fetchRequestBody(req);
+      await expect(promise).to.be.rejectedWith(
+        'Received bytes do not match the "content-length" header.',
+      );
+    });
+
+    it('should throw an error if the body length is lower than the header', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const bodyLength = Buffer.from(body).byteLength;
+      const contentLength = String(bodyLength - 10);
+      const req = createRequestMock({
+        body,
+        headers: {'content-length': contentLength},
+      });
+      const promise = fetchRequestBody(req);
+      await expect(promise).to.be.rejectedWith(
+        'Received bytes do not match the "content-length" header.',
+      );
+    });
+
+    it('should not throw an error if the body length matches the header', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const contentLength = String(Buffer.from(body).byteLength);
+      const req = createRequestMock({
+        body,
+        headers: {'content-length': contentLength},
+      });
+      const result = await fetchRequestBody(req);
+      expect(result).to.be.eq(body);
+    });
+  });
+
+  describe('the parameter "bodyBytesLimit" usage', function () {
+    it('should throw an error if the "content-length" header is greater than the limit', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const bodyLength = Buffer.from(body).byteLength;
+      const bodyLimit = bodyLength - 10;
+      const req = createRequestMock({
+        body,
+        headers: {'content-length': String(bodyLength)},
+      });
+      const error = format(
+        'Request body limit is %s bytes, but %s bytes given.',
+        bodyLimit,
+        bodyLength,
+      );
+      const promise = fetchRequestBody(req, bodyLimit);
+      await expect(promise).to.be.rejectedWith(error);
+    });
+
+    it('should not throw an error if the "content-length" header does match with the limit', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const bodyLength = Buffer.from(body).byteLength;
+      const req = createRequestMock({
+        body,
+        headers: {'content-length': String(bodyLength)},
+      });
+      const result = await fetchRequestBody(req, bodyLength);
+      expect(result).to.be.eq(body);
+    });
+
+    it('should not throw an error if the "content-length" header is lower than the limit', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const bodyLength = Buffer.from(body).byteLength;
+      const req = createRequestMock({
+        body,
+        headers: {'content-length': String(bodyLength)},
+      });
+      const result = await fetchRequestBody(req, bodyLength + 10);
+      expect(result).to.be.eq(body);
+    });
+
+    it('should throw an error if the body length is greater than the limit', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const bodyLength = Buffer.from(body).byteLength;
+      const bodyLimit = bodyLength - 10;
+      const req = createRequestMock({body});
+      const error = format(
+        'Request body limit is %s bytes, but %s bytes given.',
+        bodyLimit,
+        bodyLength,
+      );
+      const promise = fetchRequestBody(req, bodyLimit);
+      await expect(promise).to.be.rejectedWith(error);
+    });
+
+    it('should not throw an error if the body length does match with the limit', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const bodyLength = Buffer.from(body).byteLength;
+      const req = createRequestMock({body});
+      const result = await fetchRequestBody(req, bodyLength);
+      expect(result).to.be.eq(body);
+    });
+
+    it('should not throw an error if the body length is lower than the limit', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const bodyLength = Buffer.from(body).byteLength;
+      const bodyLimit = bodyLength + 10;
+      const req = createRequestMock({body});
+      const result = await fetchRequestBody(req, bodyLimit);
+      expect(result).to.be.eq(body);
+    });
+  });
+});

package/src/utils/get-pathname-from-url.d.ts

@@ -2,6 +2,6 @@
 /**
  * Get pathname from url.
  *
- * @param request
+ * @param url
  */
 export declare function getPathnameFromUrl(url: string): string;

package/src/utils/{get-request-pathname.spec.js → get-pathname-from-url.spec.js}

@@ -3,7 +3,7 @@ import {format} from '@e22m4u/js-format';
 import {getPathnameFromUrl} from './get-pathname-from-url.js';
 
 describe('getPathnameFromUrl', function () {
-  it('should require the parameter "request" to be a String', function () {
+  it('should require the parameter "url" to be a String', function () {
     const throwable = v => () => getPathnameFromUrl(v);
     const error = v =>
       format('Parameter "url" must be a String, but %s was given.', v);

package/src/utils/index.d.ts

@@ -1,2 +1,10 @@
+export * from './create-error.js';
 export * from './escape-regexp.js';
+export * from './fetch-request-body.js';
+export * from './is-readable-stream.js';
+export * from './parse-content-type.js';
+export * from './create-request-mock.js';
+export * from './parse-cookie-string.js';
+export * from './create-response-mock.js';
+export * from './create-cookie-string.js';
 export * from './get-pathname-from-url.js';