@e22m4u/js-trie-router 0.0.1

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

@@ -0,0 +1,130 @@
+import {describe} from 'mocha';
+import {expect} from '../chai.js';
+import {PassThrough} from 'stream';
+import {createResponseMock} from './create-response-mock.js';
+
+describe('createResponseMock', function () {
+  it('returns an instance of PassThrough', function () {
+    const res = createResponseMock();
+    expect(res).to.be.instanceof(PassThrough);
+  });
+
+  describe('setEncoding', function () {
+    it('sets the given encoding and returns 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('returns 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('returns false if the response is not sent', function () {
+      const res = createResponseMock();
+      expect(res._headersSent).to.be.false;
+      expect(res.headersSent).to.be.false;
+    });
+
+    it('returns a value of 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('sets the given header and returns 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('throws an error if headers is 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('sets 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');
+    });
+  });
+
+  describe('getHeader', function () {
+    it('returns 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('uses case-insensitivity lookup', function () {
+      const res = createResponseMock();
+      res._headers['foo'] = 'bar';
+      const ret = res.getHeader('FOO');
+      expect(ret).to.be.eq('bar');
+    });
+  });
+
+  describe('getHeaders', function () {
+    it('returns 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('returns 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);
+      await expect(promise).to.eventually.be.eq(body);
+    });
+  });
+
+  describe('Stream', function () {
+    it('sets "headerSent" to true when the stream ends', function (done) {
+      const res = createResponseMock();
+      expect(res.headersSent).to.be.false;
+      res.on('end', () => {
+        expect(res.headersSent).to.be.true;
+        done();
+      });
+      res.end('test');
+    });
+  });
+});

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

@@ -0,0 +1,17 @@
+import {IncomingMessage} from 'http';
+
+/**
+ * Buffer encoding list.
+ */
+export type BUFFER_ENCODING_LIST = BufferEncoding[];
+
+/**
+ * Fetch request body.
+ *
+ * @param req
+ * @param bodyBytesLimit
+ */
+export declare function fetchRequestBody(
+  req: IncomingMessage,
+  bodyBytesLimit?: number,
+): Promise<string>;

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

@@ -0,0 +1,133 @@
+import HttpErrors from 'http-errors';
+import {createError} from './create-error.js';
+import {parseContentType} from './parse-content-type.js';
+import {Errorf} from '@e22m4u/js-format';
+import {IncomingMessage} from 'http';
+
+/**
+ * Buffer encoding.
+ *
+ * @type {import('buffer').BufferEncoding[]}
+ */
+export const BUFFER_ENCODING_LIST = [
+  'ascii',
+  'utf8',
+  'utf-8',
+  'utf16le',
+  'utf-16le',
+  'ucs2',
+  'ucs-2',
+  'base64',
+  'base64url',
+  'latin1',
+  'binary',
+  'hex',
+];
+
+/**
+ * Fetch request body.
+ *
+ * @param {IncomingMessage} req
+ * @param {number} bodyBytesLimit
+ * @returns {Promise<string|undefined>}
+ */
+export function fetchRequestBody(req, bodyBytesLimit = 0) {
+  if (!(req instanceof IncomingMessage))
+    throw new Errorf(
+      'The first parameter of "fetchRequestBody" should be ' +
+        'an IncomingMessage instance, but %v given.',
+      req,
+    );
+  if (typeof bodyBytesLimit !== 'number')
+    throw new Errorf(
+      'The parameter "bodyBytesLimit" of "fetchRequestBody" ' +
+        'should be a number, but %v given.',
+      bodyBytesLimit,
+    );
+  return new Promise((resolve, reject) => {
+    // сравнение внутреннего ограничения
+    // размера тела запроса с заголовком
+    // "content-length"
+    const contentLength = parseInt(req.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 = req.headers['content-type'] || '';
+    if (contentType) {
+      const parsedContentType = parseContentType(contentType);
+      if (parsedContentType && parsedContentType.charset) {
+        encoding = parsedContentType.charset.toLowerCase();
+        if (!BUFFER_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) {
+        req.removeAllListeners();
+        const error = createError(
+          HttpErrors.PayloadTooLarge,
+          'Request body limit is %v bytes, but %v bytes given.',
+          bodyBytesLimit,
+          receivedLength,
+        );
+        reject(error);
+        return;
+      }
+      data.push(chunk);
+    };
+    // кода данные полностью загружены, нужно удалить
+    // обработчики событий, и сравнить полученный объем
+    // данных с заявленным в заголовке "content-length"
+    const onEnd = () => {
+      req.removeAllListeners();
+      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.from(buffer, encoding).toString();
+      resolve(body || undefined);
+    };
+    // при ошибке загрузки тела запроса,
+    // удаляются обработчики событий,
+    // и отклоняется ожидающий Promise
+    // ошибкой с кодом 400
+    const onError = error => {
+      req.removeAllListeners();
+      reject(HttpErrors(400, error));
+    };
+    // добавление обработчиков прослушивающих
+    // события входящего запроса и возобновление
+    // потока данных
+    req.on('data', onData);
+    req.on('end', onEnd);
+    req.on('error', onError);
+    req.resume();
+  });
+}

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

@@ -0,0 +1,211 @@
+import {expect} from '../chai.js';
+import {format} from '@e22m4u/js-format';
+import {fetchRequestBody} from './fetch-request-body.js';
+import {createRequestMock} from './create-request-mock.js';
+
+describe('fetchRequestBody', function () {
+  it('requires the first parameter to be an IncomingMessage instance', function () {
+    const throwable = v => () => fetchRequestBody(v);
+    const error = v =>
+      format(
+        'The first parameter of "fetchRequestBody" should be ' +
+          'an IncomingMessage instance, but %s 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('requires the parameter "bodyBytesLimit" to be an IncomingMessage instance', function () {
+    const req = createRequestMock();
+    const throwable = v => () => fetchRequestBody(req, v);
+    const error = v =>
+      format(
+        'The parameter "bodyBytesLimit" of "fetchRequestBody" ' +
+          'should be a number, but %s 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('returns 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('returns 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 of the header "content-type"', function () {
+    it('throws 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('does not throw an error if the header "content-type" does not have a specified charset', 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('decodes non-standard encoding', async function () {
+      const body = 'Lorem Ipsum is simply dummy text.';
+      const encoding = 'base64';
+      const encodedBody = Buffer.from(body).toString(encoding);
+      const req = createRequestMock({
+        body: Buffer.from(encodedBody, encoding),
+        headers: {'content-type': `text/plain; charset=${encoding}`},
+      });
+      const result = await fetchRequestBody(req);
+      expect(result).to.be.eq(body);
+    });
+  });
+
+  describe('the header "content-length"', function () {
+    it('throws 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('throws 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('does not throw an error if the body length does match with 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"', function () {
+    it('throws 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('does 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('does 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('throws 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('does 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('does 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-request-path.d.ts

@@ -0,0 +1,8 @@
+import {IncomingMessage} from 'http';
+
+/**
+ * Get request path.
+ *
+ * @param req
+ */
+export declare function getRequestPath(req: IncomingMessage): string;

package/src/utils/get-request-path.js

@@ -0,0 +1,23 @@
+import {Errorf} from '@e22m4u/js-format';
+
+/**
+ * Get request path.
+ *
+ * @param {import('http').IncomingMessage} req
+ * @returns {string}
+ */
+export function getRequestPath(req) {
+  if (
+    !req ||
+    typeof req !== 'object' ||
+    Array.isArray(req) ||
+    typeof req.url !== 'string'
+  ) {
+    throw new Errorf(
+      'The first argument of "getRequestPath" should be ' +
+        'an instance of IncomingMessage, but %v given.',
+      req,
+    );
+  }
+  return (req.url || '/').replace(/\?.*$/, '');
+}

package/src/utils/get-request-path.spec.js

@@ -0,0 +1,31 @@
+import {expect} from '../chai.js';
+import {format} from '@e22m4u/js-format';
+import {getRequestPath} from './get-request-path.js';
+
+describe('getRequestPath', function () {
+  it('requires the argument to be an Object with "url" property', function () {
+    const throwable = v => () => getRequestPath(v);
+    const error = v =>
+      format(
+        'The first argument of "getRequestPath" should be ' +
+          'an instance of IncomingMessage, but %s 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({url: ''})();
+  });
+
+  it('returns the request path without query parameters', function () {
+    const res = getRequestPath({url: '/test?foo=bar'});
+    expect(res).to.be.eq('/test');
+  });
+});

package/src/utils/index.d.ts

@@ -0,0 +1,11 @@
+export * from './is-promise.js';
+export * from './parse-cookie.js';
+export * from './create-error.js';
+export * from './to-camel-case.js';
+export * from './create-debugger.js';
+export * from './is-response-sent.js';
+export * from './get-request-path.js';
+export * from './is-readable-stream.js';
+export * from './is-writable-stream.js';
+export * from './fetch-request-body.js';
+export * from './create-cookie-string.js';

package/src/utils/index.js

@@ -0,0 +1,11 @@
+export * from './is-promise.js';
+export * from './parse-cookie.js';
+export * from './create-error.js';
+export * from './to-camel-case.js';
+export * from './create-debugger.js';
+export * from './is-response-sent.js';
+export * from './get-request-path.js';
+export * from './is-readable-stream.js';
+export * from './is-writable-stream.js';
+export * from './fetch-request-body.js';
+export * from './create-cookie-string.js';

package/src/utils/is-promise.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Check whether a value is a Promise-like
+ * instance. Recognizes both native promises
+ * and third-party promise libraries.
+ *
+ * @param value
+ */
+export declare function isPromise<T = unknown>(
+  value: unknown,
+): value is Promise<T>;

package/src/utils/is-promise.js

@@ -0,0 +1,13 @@
+/**
+ * Check whether a value is a Promise-like
+ * instance. Recognizes both native promises
+ * and third-party promise libraries.
+ *
+ * @param {*} value
+ * @returns {boolean}
+ */
+export function isPromise(value) {
+  if (!value) return false;
+  if (typeof value !== 'object') return false;
+  return typeof value.then === 'function';
+}

package/src/utils/is-promise.spec.js

@@ -0,0 +1,20 @@
+import {expect} from '../chai.js';
+import {isPromise} from './is-promise.js';
+
+describe('isPromise', function () {
+  it('returns true if the value is a promise', function () {
+    const value = Promise.resolve();
+    expect(isPromise(value)).to.be.true;
+  });
+
+  it('returns false if the value is not a promise', function () {
+    expect(isPromise('string')).to.be.false;
+    expect(isPromise(5)).to.be.false;
+    expect(isPromise([])).to.be.false;
+    expect(isPromise({})).to.be.false;
+    expect(isPromise(undefined)).to.be.false;
+    expect(isPromise(null)).to.be.false;
+    expect(isPromise(NaN)).to.be.false;
+    expect(isPromise(() => 10)).to.be.false;
+  });
+});

package/src/utils/is-readable-stream.d.ts

@@ -0,0 +1,9 @@
+import {Readable} from 'stream';
+
+/**
+ * Check whether a value has a pipe
+ * method.
+ *
+ * @param value
+ */
+export declare function isReadableStream(value: unknown): value is Readable;

package/src/utils/is-readable-stream.js

@@ -0,0 +1,11 @@
+/**
+ * Check whether a value has a pipe
+ * method.
+ *
+ * @param {*} value
+ * @returns {boolean}
+ */
+export function isReadableStream(value) {
+  if (!value || typeof value !== 'object') return false;
+  return typeof value.pipe === 'function';
+}

package/src/utils/is-readable-stream.spec.js

@@ -0,0 +1,23 @@
+import {expect} from '../chai.js';
+import {Readable} from 'stream';
+import {isReadableStream} from './is-readable-stream.js';
+
+describe('isReadableStream', function () {
+  it('returns true if the value is a readable stream', function () {
+    const value1 = new Readable();
+    expect(isReadableStream(value1)).to.be.true;
+    const value2 = {pipe: () => undefined};
+    expect(isReadableStream(value2)).to.be.true;
+  });
+
+  it('returns false if the value is not a stream', function () {
+    expect(isReadableStream('string')).to.be.false;
+    expect(isReadableStream(5)).to.be.false;
+    expect(isReadableStream([])).to.be.false;
+    expect(isReadableStream({})).to.be.false;
+    expect(isReadableStream(undefined)).to.be.false;
+    expect(isReadableStream(null)).to.be.false;
+    expect(isReadableStream(NaN)).to.be.false;
+    expect(isReadableStream(() => 10)).to.be.false;
+  });
+});