@tramvai/module-request-limiter 2.70.1 → 2.72.0

package/lib/browser.js

@@ -1,10 +1,6 @@
 import { __decorate } from 'tslib';
 import { Module } from '@tramvai/core';
-import { createToken } from '@tinkoff/dippy';
-
-const REQUESTS_LIMITER_TOKEN = createToken('requestsLimiterToken');
-const REQUESTS_LIMITER_ACTIVATE_TOKEN = createToken('requestsLimiterActivateToken');
-const REQUESTS_LIMITER_OPTIONS_TOKEN = createToken('requestsLimiterOptionsToken');
+export { REQUESTS_LIMITER_ACTIVATE_TOKEN, REQUESTS_LIMITER_OPTIONS_TOKEN, REQUESTS_LIMITER_TOKEN } from './tokens.browser.js';
 
 let RequestLimiterModule = class RequestLimiterModule {
 };
@@ -14,4 +10,4 @@ RequestLimiterModule = __decorate([
     })
 ], RequestLimiterModule);
 
-export { REQUESTS_LIMITER_ACTIVATE_TOKEN, REQUESTS_LIMITER_OPTIONS_TOKEN, REQUESTS_LIMITER_TOKEN, RequestLimiterModule };
+export { RequestLimiterModule };

package/lib/requestLimiter.es.js

@@ -0,0 +1,85 @@
+import fp from 'fastify-plugin';
+import { HttpError } from '@tinkoff/errors';
+import onFinished from 'on-finished';
+import { monitorEventLoopDelay } from 'perf_hooks';
+import { DoubleLinkedList } from './utils/doubleLinkedList.es.js';
+
+const DEFAULT_OPTIONS = {
+    limit: 10,
+    queue: 100,
+    maxEventLoopDelay: 150,
+    error: { httpStatus: 429, message: 'Too Many Requests' },
+};
+const resolution = 10;
+class RequestLimiter {
+    constructor(options) {
+        this.currentActive = 0;
+        this.eventLoopDelay = 0;
+        this.queue = new DoubleLinkedList();
+        const { limit, queue, maxEventLoopDelay, error } = options;
+        this.activeRequestLimit = limit;
+        this.minimalActiveRequestLimit = Math.round(limit / 3);
+        this.queueLimit = queue;
+        this.error = error;
+        this.maxEventLoopDelay = maxEventLoopDelay;
+        this.eventLoopHistogram = monitorEventLoopDelay({ resolution });
+        this.eventLoopHistogram.enable();
+        const timer = setInterval(() => this.nextTick(), 1000);
+        timer.unref();
+    }
+    onResponse() {
+        this.currentActive--;
+        this.loop();
+    }
+    // General idea is change limits every second. Because if DDOS was happened we need some time to get problem with event loop. And better if we slowly adapt
+    nextTick() {
+        this.eventLoopDelay = Math.max(0, this.eventLoopHistogram.mean / 1e6 - resolution);
+        if (Number.isNaN(this.eventLoopDelay))
+            this.eventLoopDelay = Infinity;
+        this.eventLoopHistogram.reset();
+        if (this.currentActive >= this.activeRequestLimit) {
+            if (this.eventLoopDelay <= this.maxEventLoopDelay) {
+                this.activeRequestLimit++;
+                // We need to have minimalActiveRequestLimit
+            }
+            else if (this.activeRequestLimit > this.minimalActiveRequestLimit) {
+                this.activeRequestLimit--;
+            }
+        }
+    }
+    add(request) {
+        if (this.currentActive < this.activeRequestLimit) {
+            this.run(request);
+            return;
+        }
+        if (this.queue.length >= this.queueLimit) {
+            const lastNode = this.queue.shift();
+            lastNode.next(new HttpError(this.error));
+        }
+        this.queue.push(request);
+    }
+    loop() {
+        while (this.queue.length > 0 && this.currentActive < this.activeRequestLimit) {
+            // better if we start with new requests. Because more opportunity to answer before client cancel request
+            this.run(this.queue.pop());
+        }
+    }
+    run({ next, res }) {
+        this.currentActive++;
+        // onFinished doesn't work OK in DEV mode. Just stuck with high load without any reasons
+        // fastify: it only works this way with on-finished, as using hook `onRequest` is not enough to handle all of the requests
+        // and some of the failed requests are getting disappeared
+        // and other hooks useless as well. [related issue](https://github.com/fastify/fastify/issues/1352)
+        onFinished(res.raw, () => {
+            this.onResponse();
+        });
+        next();
+    }
+}
+const fastifyRequestsLimiter = fp(async (fastify, { requestsLimiter }) => {
+    fastify.addHook('onRequest', (req, res, next) => {
+        requestsLimiter.add({ req, res, next });
+    });
+});
+
+export { DEFAULT_OPTIONS, RequestLimiter, fastifyRequestsLimiter };

package/lib/requestLimiter.js

@@ -0,0 +1,96 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fp = require('fastify-plugin');
+var errors = require('@tinkoff/errors');
+var onFinished = require('on-finished');
+var perf_hooks = require('perf_hooks');
+var doubleLinkedList = require('./utils/doubleLinkedList.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fp__default = /*#__PURE__*/_interopDefaultLegacy(fp);
+var onFinished__default = /*#__PURE__*/_interopDefaultLegacy(onFinished);
+
+const DEFAULT_OPTIONS = {
+    limit: 10,
+    queue: 100,
+    maxEventLoopDelay: 150,
+    error: { httpStatus: 429, message: 'Too Many Requests' },
+};
+const resolution = 10;
+class RequestLimiter {
+    constructor(options) {
+        this.currentActive = 0;
+        this.eventLoopDelay = 0;
+        this.queue = new doubleLinkedList.DoubleLinkedList();
+        const { limit, queue, maxEventLoopDelay, error } = options;
+        this.activeRequestLimit = limit;
+        this.minimalActiveRequestLimit = Math.round(limit / 3);
+        this.queueLimit = queue;
+        this.error = error;
+        this.maxEventLoopDelay = maxEventLoopDelay;
+        this.eventLoopHistogram = perf_hooks.monitorEventLoopDelay({ resolution });
+        this.eventLoopHistogram.enable();
+        const timer = setInterval(() => this.nextTick(), 1000);
+        timer.unref();
+    }
+    onResponse() {
+        this.currentActive--;
+        this.loop();
+    }
+    // General idea is change limits every second. Because if DDOS was happened we need some time to get problem with event loop. And better if we slowly adapt
+    nextTick() {
+        this.eventLoopDelay = Math.max(0, this.eventLoopHistogram.mean / 1e6 - resolution);
+        if (Number.isNaN(this.eventLoopDelay))
+            this.eventLoopDelay = Infinity;
+        this.eventLoopHistogram.reset();
+        if (this.currentActive >= this.activeRequestLimit) {
+            if (this.eventLoopDelay <= this.maxEventLoopDelay) {
+                this.activeRequestLimit++;
+                // We need to have minimalActiveRequestLimit
+            }
+            else if (this.activeRequestLimit > this.minimalActiveRequestLimit) {
+                this.activeRequestLimit--;
+            }
+        }
+    }
+    add(request) {
+        if (this.currentActive < this.activeRequestLimit) {
+            this.run(request);
+            return;
+        }
+        if (this.queue.length >= this.queueLimit) {
+            const lastNode = this.queue.shift();
+            lastNode.next(new errors.HttpError(this.error));
+        }
+        this.queue.push(request);
+    }
+    loop() {
+        while (this.queue.length > 0 && this.currentActive < this.activeRequestLimit) {
+            // better if we start with new requests. Because more opportunity to answer before client cancel request
+            this.run(this.queue.pop());
+        }
+    }
+    run({ next, res }) {
+        this.currentActive++;
+        // onFinished doesn't work OK in DEV mode. Just stuck with high load without any reasons
+        // fastify: it only works this way with on-finished, as using hook `onRequest` is not enough to handle all of the requests
+        // and some of the failed requests are getting disappeared
+        // and other hooks useless as well. [related issue](https://github.com/fastify/fastify/issues/1352)
+        onFinished__default["default"](res.raw, () => {
+            this.onResponse();
+        });
+        next();
+    }
+}
+const fastifyRequestsLimiter = fp__default["default"](async (fastify, { requestsLimiter }) => {
+    fastify.addHook('onRequest', (req, res, next) => {
+        requestsLimiter.add({ req, res, next });
+    });
+});
+
+exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+exports.RequestLimiter = RequestLimiter;
+exports.fastifyRequestsLimiter = fastifyRequestsLimiter;

package/lib/server.es.js

@@ -2,153 +2,10 @@ import { __decorate } from 'tslib';
 import { Module, provide, Scope } from '@tramvai/core';
 import { ENV_USED_TOKEN, ENV_MANAGER_TOKEN } from '@tramvai/tokens-common';
 import { WEB_FASTIFY_APP_LIMITER_TOKEN } from '@tramvai/tokens-server-private';
-import fp from 'fastify-plugin';
-import { HttpError } from '@tinkoff/errors';
-import onFinished from 'on-finished';
-import { monitorEventLoopDelay } from 'perf_hooks';
-import { createToken } from '@tinkoff/dippy';
-
-class DoubleLinkedList {
-    constructor() {
-        this.length = 0;
-        this.start = null;
-        this.end = null;
-    }
-    push(value) {
-        const newNode = {
-            value,
-            next: null,
-            prev: null,
-        };
-        this.length++;
-        if (this.start === null) {
-            this.start = newNode;
-            this.end = newNode;
-            return;
-        }
-        const currentEnd = this.end;
-        this.end = newNode;
-        this.end.prev = currentEnd;
-        currentEnd.next = this.end;
-    }
-    pop() {
-        if (this.end === null) {
-            return null;
-        }
-        this.length--;
-        // if equal we have only 1 node, so we just remove start
-        if (this.end === this.start) {
-            this.start = null;
-        }
-        const { value } = this.end;
-        this.end = this.end.prev;
-        if (this.end) {
-            this.end.next = null;
-        }
-        return value;
-    }
-    shift() {
-        if (this.start === null) {
-            return null;
-        }
-        this.length--;
-        // if equal we have only 1 node, so we just remove end
-        if (this.end === this.start) {
-            this.end = null;
-        }
-        const { value } = this.start;
-        this.start = this.start.next;
-        if (this.start) {
-            this.start.prev = null;
-        }
-        return value;
-    }
-    size() {
-        return this.length;
-    }
-}
-
-const DEFAULT_OPTIONS = {
-    limit: 10,
-    queue: 100,
-    maxEventLoopDelay: 150,
-    error: { httpStatus: 429, message: 'Too Many Requests' },
-};
-const resolution = 10;
-class RequestLimiter {
-    constructor(options) {
-        this.currentActive = 0;
-        this.eventLoopDelay = 0;
-        this.queue = new DoubleLinkedList();
-        const { limit, queue, maxEventLoopDelay, error } = options;
-        this.activeRequestLimit = limit;
-        this.minimalActiveRequestLimit = Math.round(limit / 3);
-        this.queueLimit = queue;
-        this.error = error;
-        this.maxEventLoopDelay = maxEventLoopDelay;
-        this.eventLoopHistogram = monitorEventLoopDelay({ resolution });
-        this.eventLoopHistogram.enable();
-        const timer = setInterval(() => this.nextTick(), 1000);
-        timer.unref();
-    }
-    onResponse() {
-        this.currentActive--;
-        this.loop();
-    }
-    // General idea is change limits every second. Because if DDOS was happened we need some time to get problem with event loop. And better if we slowly adapt
-    nextTick() {
-        this.eventLoopDelay = Math.max(0, this.eventLoopHistogram.mean / 1e6 - resolution);
-        if (Number.isNaN(this.eventLoopDelay))
-            this.eventLoopDelay = Infinity;
-        this.eventLoopHistogram.reset();
-        if (this.currentActive >= this.activeRequestLimit) {
-            if (this.eventLoopDelay <= this.maxEventLoopDelay) {
-                this.activeRequestLimit++;
-                // We need to have minimalActiveRequestLimit
-            }
-            else if (this.activeRequestLimit > this.minimalActiveRequestLimit) {
-                this.activeRequestLimit--;
-            }
-        }
-    }
-    add(request) {
-        if (this.currentActive < this.activeRequestLimit) {
-            this.run(request);
-            return;
-        }
-        if (this.queue.length >= this.queueLimit) {
-            const lastNode = this.queue.shift();
-            lastNode.next(new HttpError(this.error));
-        }
-        this.queue.push(request);
-    }
-    loop() {
-        while (this.queue.length > 0 && this.currentActive < this.activeRequestLimit) {
-            // better if we start with new requests. Because more opportunity to answer before client cancel request
-            this.run(this.queue.pop());
-        }
-    }
-    run({ next, res }) {
-        this.currentActive++;
-        // onFinished doesn't work OK in DEV mode. Just stuck with high load without any reasons
-        // fastify: it only works this way with on-finished, as using hook `onRequest` is not enough to handle all of the requests
-        // and some of the failed requests are getting disappeared
-        // and other hooks useless as well. [related issue](https://github.com/fastify/fastify/issues/1352)
-        onFinished(res.raw, () => {
-            this.onResponse();
-        });
-        next();
-    }
-}
-const fastifyRequestsLimiter = fp(async (fastify, { requestsLimiter }) => {
-    fastify.addHook('onRequest', (req, res, next) => {
-        requestsLimiter.add({ req, res, next });
-    });
-});
-
-const REQUESTS_LIMITER_TOKEN = createToken('requestsLimiterToken');
-const REQUESTS_LIMITER_ACTIVATE_TOKEN = createToken('requestsLimiterActivateToken');
-const REQUESTS_LIMITER_OPTIONS_TOKEN = createToken('requestsLimiterOptionsToken');
+import { DEFAULT_OPTIONS, RequestLimiter, fastifyRequestsLimiter } from './requestLimiter.es.js';
+export { DEFAULT_OPTIONS, RequestLimiter, fastifyRequestsLimiter } from './requestLimiter.es.js';
+import { REQUESTS_LIMITER_OPTIONS_TOKEN, REQUESTS_LIMITER_TOKEN, REQUESTS_LIMITER_ACTIVATE_TOKEN } from './tokens.es.js';
+export { REQUESTS_LIMITER_ACTIVATE_TOKEN, REQUESTS_LIMITER_OPTIONS_TOKEN, REQUESTS_LIMITER_TOKEN } from './tokens.es.js';
 
 let RequestLimiterModule = class RequestLimiterModule {
 };
@@ -234,4 +91,4 @@ RequestLimiterModule = __decorate([
     })
 ], RequestLimiterModule);
 
-export { DEFAULT_OPTIONS, REQUESTS_LIMITER_ACTIVATE_TOKEN, REQUESTS_LIMITER_OPTIONS_TOKEN, REQUESTS_LIMITER_TOKEN, RequestLimiter, RequestLimiterModule, fastifyRequestsLimiter };
+export { RequestLimiterModule };

package/lib/server.js

@@ -6,158 +6,8 @@ var tslib = require('tslib');
 var core = require('@tramvai/core');
 var tokensCommon = require('@tramvai/tokens-common');
 var tokensServerPrivate = require('@tramvai/tokens-server-private');
-var fp = require('fastify-plugin');
-var errors = require('@tinkoff/errors');
-var onFinished = require('on-finished');
-var perf_hooks = require('perf_hooks');
-var dippy = require('@tinkoff/dippy');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var fp__default = /*#__PURE__*/_interopDefaultLegacy(fp);
-var onFinished__default = /*#__PURE__*/_interopDefaultLegacy(onFinished);
-
-class DoubleLinkedList {
-    constructor() {
-        this.length = 0;
-        this.start = null;
-        this.end = null;
-    }
-    push(value) {
-        const newNode = {
-            value,
-            next: null,
-            prev: null,
-        };
-        this.length++;
-        if (this.start === null) {
-            this.start = newNode;
-            this.end = newNode;
-            return;
-        }
-        const currentEnd = this.end;
-        this.end = newNode;
-        this.end.prev = currentEnd;
-        currentEnd.next = this.end;
-    }
-    pop() {
-        if (this.end === null) {
-            return null;
-        }
-        this.length--;
-        // if equal we have only 1 node, so we just remove start
-        if (this.end === this.start) {
-            this.start = null;
-        }
-        const { value } = this.end;
-        this.end = this.end.prev;
-        if (this.end) {
-            this.end.next = null;
-        }
-        return value;
-    }
-    shift() {
-        if (this.start === null) {
-            return null;
-        }
-        this.length--;
-        // if equal we have only 1 node, so we just remove end
-        if (this.end === this.start) {
-            this.end = null;
-        }
-        const { value } = this.start;
-        this.start = this.start.next;
-        if (this.start) {
-            this.start.prev = null;
-        }
-        return value;
-    }
-    size() {
-        return this.length;
-    }
-}
-
-const DEFAULT_OPTIONS = {
-    limit: 10,
-    queue: 100,
-    maxEventLoopDelay: 150,
-    error: { httpStatus: 429, message: 'Too Many Requests' },
-};
-const resolution = 10;
-class RequestLimiter {
-    constructor(options) {
-        this.currentActive = 0;
-        this.eventLoopDelay = 0;
-        this.queue = new DoubleLinkedList();
-        const { limit, queue, maxEventLoopDelay, error } = options;
-        this.activeRequestLimit = limit;
-        this.minimalActiveRequestLimit = Math.round(limit / 3);
-        this.queueLimit = queue;
-        this.error = error;
-        this.maxEventLoopDelay = maxEventLoopDelay;
-        this.eventLoopHistogram = perf_hooks.monitorEventLoopDelay({ resolution });
-        this.eventLoopHistogram.enable();
-        const timer = setInterval(() => this.nextTick(), 1000);
-        timer.unref();
-    }
-    onResponse() {
-        this.currentActive--;
-        this.loop();
-    }
-    // General idea is change limits every second. Because if DDOS was happened we need some time to get problem with event loop. And better if we slowly adapt
-    nextTick() {
-        this.eventLoopDelay = Math.max(0, this.eventLoopHistogram.mean / 1e6 - resolution);
-        if (Number.isNaN(this.eventLoopDelay))
-            this.eventLoopDelay = Infinity;
-        this.eventLoopHistogram.reset();
-        if (this.currentActive >= this.activeRequestLimit) {
-            if (this.eventLoopDelay <= this.maxEventLoopDelay) {
-                this.activeRequestLimit++;
-                // We need to have minimalActiveRequestLimit
-            }
-            else if (this.activeRequestLimit > this.minimalActiveRequestLimit) {
-                this.activeRequestLimit--;
-            }
-        }
-    }
-    add(request) {
-        if (this.currentActive < this.activeRequestLimit) {
-            this.run(request);
-            return;
-        }
-        if (this.queue.length >= this.queueLimit) {
-            const lastNode = this.queue.shift();
-            lastNode.next(new errors.HttpError(this.error));
-        }
-        this.queue.push(request);
-    }
-    loop() {
-        while (this.queue.length > 0 && this.currentActive < this.activeRequestLimit) {
-            // better if we start with new requests. Because more opportunity to answer before client cancel request
-            this.run(this.queue.pop());
-        }
-    }
-    run({ next, res }) {
-        this.currentActive++;
-        // onFinished doesn't work OK in DEV mode. Just stuck with high load without any reasons
-        // fastify: it only works this way with on-finished, as using hook `onRequest` is not enough to handle all of the requests
-        // and some of the failed requests are getting disappeared
-        // and other hooks useless as well. [related issue](https://github.com/fastify/fastify/issues/1352)
-        onFinished__default["default"](res.raw, () => {
-            this.onResponse();
-        });
-        next();
-    }
-}
-const fastifyRequestsLimiter = fp__default["default"](async (fastify, { requestsLimiter }) => {
-    fastify.addHook('onRequest', (req, res, next) => {
-        requestsLimiter.add({ req, res, next });
-    });
-});
-
-const REQUESTS_LIMITER_TOKEN = dippy.createToken('requestsLimiterToken');
-const REQUESTS_LIMITER_ACTIVATE_TOKEN = dippy.createToken('requestsLimiterActivateToken');
-const REQUESTS_LIMITER_OPTIONS_TOKEN = dippy.createToken('requestsLimiterOptionsToken');
+var requestLimiter = require('./requestLimiter.js');
+var tokens = require('./tokens.js');
 
 exports.RequestLimiterModule = class RequestLimiterModule {
 };
@@ -171,22 +21,22 @@ exports.RequestLimiterModule = tslib.__decorate([
                     {
                         key: 'REQUEST_LIMITER_MELD',
                         optional: true,
-                        value: String(DEFAULT_OPTIONS.maxEventLoopDelay),
+                        value: String(requestLimiter.DEFAULT_OPTIONS.maxEventLoopDelay),
                     },
                     {
                         key: 'REQUEST_LIMITER_QUEUE',
                         optional: true,
-                        value: String(DEFAULT_OPTIONS.queue),
+                        value: String(requestLimiter.DEFAULT_OPTIONS.queue),
                     },
                     {
                         key: 'REQUEST_LIMITER_LIMIT',
                         optional: true,
-                        value: String(DEFAULT_OPTIONS.limit),
+                        value: String(requestLimiter.DEFAULT_OPTIONS.limit),
                     },
                 ],
             }),
             core.provide({
-                provide: REQUESTS_LIMITER_OPTIONS_TOKEN,
+                provide: tokens.REQUESTS_LIMITER_OPTIONS_TOKEN,
                 useFactory: ({ envManager }) => ({
                     maxEventLoopDelay: Number(envManager.get('REQUEST_LIMITER_MELD')),
                     queue: Number(envManager.get('REQUEST_LIMITER_QUEUE')),
@@ -197,7 +47,7 @@ exports.RequestLimiterModule = tslib.__decorate([
                 },
             }),
             core.provide({
-                provide: REQUESTS_LIMITER_TOKEN,
+                provide: tokens.REQUESTS_LIMITER_TOKEN,
                 scope: core.Scope.SINGLETON,
                 useFactory: ({ options, featureEnable, envManager }) => {
                     var _a, _b, _c, _d;
@@ -208,18 +58,18 @@ exports.RequestLimiterModule = tslib.__decorate([
                     const queue = envManager.get('REQUEST_LIMITER_QUEUE');
                     const limit = envManager.get('REQUEST_LIMITER_LIMIT');
                     const resultOptions = {
-                        limit: limit ? Number(limit) : (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : DEFAULT_OPTIONS.limit,
-                        queue: queue ? Number(queue) : (_b = options === null || options === void 0 ? void 0 : options.queue) !== null && _b !== void 0 ? _b : DEFAULT_OPTIONS.queue,
+                        limit: limit ? Number(limit) : (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : requestLimiter.DEFAULT_OPTIONS.limit,
+                        queue: queue ? Number(queue) : (_b = options === null || options === void 0 ? void 0 : options.queue) !== null && _b !== void 0 ? _b : requestLimiter.DEFAULT_OPTIONS.queue,
                         maxEventLoopDelay: meld
                             ? Number(meld)
-                            : (_c = options === null || options === void 0 ? void 0 : options.maxEventLoopDelay) !== null && _c !== void 0 ? _c : DEFAULT_OPTIONS.maxEventLoopDelay,
-                        error: (_d = options === null || options === void 0 ? void 0 : options.error) !== null && _d !== void 0 ? _d : DEFAULT_OPTIONS.error,
+                            : (_c = options === null || options === void 0 ? void 0 : options.maxEventLoopDelay) !== null && _c !== void 0 ? _c : requestLimiter.DEFAULT_OPTIONS.maxEventLoopDelay,
+                        error: (_d = options === null || options === void 0 ? void 0 : options.error) !== null && _d !== void 0 ? _d : requestLimiter.DEFAULT_OPTIONS.error,
                     };
-                    return new RequestLimiter(resultOptions);
+                    return new requestLimiter.RequestLimiter(resultOptions);
                 },
                 deps: {
-                    options: { token: REQUESTS_LIMITER_OPTIONS_TOKEN, optional: true },
-                    featureEnable: { token: REQUESTS_LIMITER_ACTIVATE_TOKEN, optional: true },
+                    options: { token: tokens.REQUESTS_LIMITER_OPTIONS_TOKEN, optional: true },
+                    featureEnable: { token: tokens.REQUESTS_LIMITER_ACTIVATE_TOKEN, optional: true },
                     envManager: tokensCommon.ENV_MANAGER_TOKEN,
                 },
             }),
@@ -231,21 +81,21 @@ exports.RequestLimiterModule = tslib.__decorate([
                         if (featureEnable === false) {
                             return;
                         }
-                        await fastifyRequestsLimiter(app, { requestsLimiter });
+                        await requestLimiter.fastifyRequestsLimiter(app, { requestsLimiter });
                     };
                 },
                 deps: {
-                    requestsLimiter: REQUESTS_LIMITER_TOKEN,
-                    featureEnable: { token: REQUESTS_LIMITER_ACTIVATE_TOKEN, optional: true },
+                    requestsLimiter: tokens.REQUESTS_LIMITER_TOKEN,
+                    featureEnable: { token: tokens.REQUESTS_LIMITER_ACTIVATE_TOKEN, optional: true },
                 },
             }),
         ],
     })
 ], exports.RequestLimiterModule);
 
-exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
-exports.REQUESTS_LIMITER_ACTIVATE_TOKEN = REQUESTS_LIMITER_ACTIVATE_TOKEN;
-exports.REQUESTS_LIMITER_OPTIONS_TOKEN = REQUESTS_LIMITER_OPTIONS_TOKEN;
-exports.REQUESTS_LIMITER_TOKEN = REQUESTS_LIMITER_TOKEN;
-exports.RequestLimiter = RequestLimiter;
-exports.fastifyRequestsLimiter = fastifyRequestsLimiter;
+exports.DEFAULT_OPTIONS = requestLimiter.DEFAULT_OPTIONS;
+exports.RequestLimiter = requestLimiter.RequestLimiter;
+exports.fastifyRequestsLimiter = requestLimiter.fastifyRequestsLimiter;
+exports.REQUESTS_LIMITER_ACTIVATE_TOKEN = tokens.REQUESTS_LIMITER_ACTIVATE_TOKEN;
+exports.REQUESTS_LIMITER_OPTIONS_TOKEN = tokens.REQUESTS_LIMITER_OPTIONS_TOKEN;
+exports.REQUESTS_LIMITER_TOKEN = tokens.REQUESTS_LIMITER_TOKEN;

package/lib/tokens.browser.js

@@ -0,0 +1,7 @@
+import { createToken } from '@tinkoff/dippy';
+
+const REQUESTS_LIMITER_TOKEN = createToken('requestsLimiterToken');
+const REQUESTS_LIMITER_ACTIVATE_TOKEN = createToken('requestsLimiterActivateToken');
+const REQUESTS_LIMITER_OPTIONS_TOKEN = createToken('requestsLimiterOptionsToken');
+
+export { REQUESTS_LIMITER_ACTIVATE_TOKEN, REQUESTS_LIMITER_OPTIONS_TOKEN, REQUESTS_LIMITER_TOKEN };

package/lib/tokens.es.js

@@ -0,0 +1,7 @@
+import { createToken } from '@tinkoff/dippy';
+
+const REQUESTS_LIMITER_TOKEN = createToken('requestsLimiterToken');
+const REQUESTS_LIMITER_ACTIVATE_TOKEN = createToken('requestsLimiterActivateToken');
+const REQUESTS_LIMITER_OPTIONS_TOKEN = createToken('requestsLimiterOptionsToken');
+
+export { REQUESTS_LIMITER_ACTIVATE_TOKEN, REQUESTS_LIMITER_OPTIONS_TOKEN, REQUESTS_LIMITER_TOKEN };

package/lib/tokens.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dippy = require('@tinkoff/dippy');
+
+const REQUESTS_LIMITER_TOKEN = dippy.createToken('requestsLimiterToken');
+const REQUESTS_LIMITER_ACTIVATE_TOKEN = dippy.createToken('requestsLimiterActivateToken');
+const REQUESTS_LIMITER_OPTIONS_TOKEN = dippy.createToken('requestsLimiterOptionsToken');
+
+exports.REQUESTS_LIMITER_ACTIVATE_TOKEN = REQUESTS_LIMITER_ACTIVATE_TOKEN;
+exports.REQUESTS_LIMITER_OPTIONS_TOKEN = REQUESTS_LIMITER_OPTIONS_TOKEN;
+exports.REQUESTS_LIMITER_TOKEN = REQUESTS_LIMITER_TOKEN;

package/lib/utils/doubleLinkedList.es.js

@@ -0,0 +1,61 @@
+class DoubleLinkedList {
+    constructor() {
+        this.length = 0;
+        this.start = null;
+        this.end = null;
+    }
+    push(value) {
+        const newNode = {
+            value,
+            next: null,
+            prev: null,
+        };
+        this.length++;
+        if (this.start === null) {
+            this.start = newNode;
+            this.end = newNode;
+            return;
+        }
+        const currentEnd = this.end;
+        this.end = newNode;
+        this.end.prev = currentEnd;
+        currentEnd.next = this.end;
+    }
+    pop() {
+        if (this.end === null) {
+            return null;
+        }
+        this.length--;
+        // if equal we have only 1 node, so we just remove start
+        if (this.end === this.start) {
+            this.start = null;
+        }
+        const { value } = this.end;
+        this.end = this.end.prev;
+        if (this.end) {
+            this.end.next = null;
+        }
+        return value;
+    }
+    shift() {
+        if (this.start === null) {
+            return null;
+        }
+        this.length--;
+        // if equal we have only 1 node, so we just remove end
+        if (this.end === this.start) {
+            this.end = null;
+        }
+        const { value } = this.start;
+        this.start = this.start.next;
+        if (this.start) {
+            this.start.prev = null;
+        }
+        return value;
+    }
+    size() {
+        return this.length;
+    }
+}
+
+export { DoubleLinkedList };

package/lib/utils/doubleLinkedList.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class DoubleLinkedList {
+    constructor() {
+        this.length = 0;
+        this.start = null;
+        this.end = null;
+    }
+    push(value) {
+        const newNode = {
+            value,
+            next: null,
+            prev: null,
+        };
+        this.length++;
+        if (this.start === null) {
+            this.start = newNode;
+            this.end = newNode;
+            return;
+        }
+        const currentEnd = this.end;
+        this.end = newNode;
+        this.end.prev = currentEnd;
+        currentEnd.next = this.end;
+    }
+    pop() {
+        if (this.end === null) {
+            return null;
+        }
+        this.length--;
+        // if equal we have only 1 node, so we just remove start
+        if (this.end === this.start) {
+            this.start = null;
+        }
+        const { value } = this.end;
+        this.end = this.end.prev;
+        if (this.end) {
+            this.end.next = null;
+        }
+        return value;
+    }
+    shift() {
+        if (this.start === null) {
+            return null;
+        }
+        this.length--;
+        // if equal we have only 1 node, so we just remove end
+        if (this.end === this.start) {
+            this.end = null;
+        }
+        const { value } = this.start;
+        this.start = this.start.next;
+        if (this.start) {
+            this.start.prev = null;
+        }
+        return value;
+    }
+    size() {
+        return this.length;
+    }
+}
+
+exports.DoubleLinkedList = DoubleLinkedList;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-request-limiter",
-  "version": "2.70.1",
+  "version": "2.72.0",
   "description": "Enable different rendering modes for pages",
   "main": "lib/server.js",
   "module": "lib/server.es.js",
@@ -16,24 +16,23 @@
   },
   "license": "Apache-2.0",
   "scripts": {
-    "build": "tramvai-build --for-publish",
-    "watch": "tsc -w",
-    "build-for-publish": "true"
+    "build": "tramvai-build --forPublish --preserveModules",
+    "watch": "tsc -w"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@tinkoff/errors": "0.3.5",
+    "@tinkoff/errors": "0.3.6",
     "fastify-plugin": "^4.2.1",
     "on-finished": "^2.3.0"
   },
   "devDependencies": {},
   "peerDependencies": {
-    "@tinkoff/dippy": "0.8.12",
-    "@tramvai/core": "2.70.1",
-    "@tramvai/tokens-common": "2.70.1",
-    "@tramvai/tokens-server-private": "2.70.1",
+    "@tinkoff/dippy": "0.8.13",
+    "@tramvai/core": "2.72.0",
+    "@tramvai/tokens-common": "2.72.0",
+    "@tramvai/tokens-server-private": "2.72.0",
     "fastify": "^4.6.0",
     "tslib": "^2.4.0"
   }