@tramvai/module-common 4.36.0 → 4.37.0

package/README.md

@@ -65,12 +65,89 @@ Module that implements caches.
 
 It provides next functionality:
 
-- create new cache instance (currently it will be instance of lru-cache)
+- create new cache instance (instance of lru-cache by default)
 - clear all of the previously create caches
 - subscribe on cache clearance event to execute own cache clearance actions
 - adds papi-route `/clear-cache` that will trigger caches clear event
 
-This modules logs wit id `cache:papi-clear-cache`
+This modules logs with id `cache:papi-clear-cache`
+
+##### Cache types
+
+You can create different cache types with `CREATE_CACHE_TOKEN` factory:
+
+- LRU - [@tinkoff/lru-cache-nano](https://github.com/tramvaijs/lru-cache-nano)
+
+  This type of cache is created by default. To create it explicitly you must pass `'memory'` as the first argument, and options as the second.
+
+  ```typescript
+  provide({
+    provide: CACHE_TOKEN,
+    scope: Scope.SINGLETON,
+    useFactory: ({ createCache }) =>
+      createCache('memory', {
+        max: 100,
+        ttl: 24 * 60 * 60 * 1000, // 1 day
+        ttlResolution: 60 * 1000, // 1 minute
+        allowStale: true,
+        updateAgeOnGet: true,
+      }),
+    deps: {
+      createCache: CREATE_CACHE_TOKEN,
+    },
+  });
+  ```
+
+- LFU - [@akashbabu/lfu-cache](https://github.com/AkashBabu/lfu-cache)
+
+  To create it you must pass `'memory-lfu'` as the first argument, cache options - as second.
+
+  ```typescript
+  provide({
+    provide: CACHE_TOKEN,
+    scope: Scope.SINGLETON,
+    useFactory: ({ createCache }) =>
+      createCache('memory-lfu', {
+        max: 20,
+        evictCount: 5,
+        maxAge: 24 * 60 * 60 * 1000, // 1 day
+      }),
+    deps: {
+      createCache: CREATE_CACHE_TOKEN,
+    },
+  });
+  ```
+
+##### Cache metrics
+
+To turn cache hit/miss rate monitoring, cache size, you need to provide cache name in options:
+
+```typescript
+provide({
+  provide: CACHE_TOKEN,
+  scope: Scope.SINGLETON,
+  useFactory: ({ createCache }) =>
+    createCache('memory', {
+      name: 'cache-name',
+    }),
+  deps: {
+    createCache: CREATE_CACHE_TOKEN,
+  },
+});
+```
+
+Cache name have to be unique, factory will throw exception in case of cache name duplication.
+
+[Metric module](references/modules/metrics.md) should be provided in your application.
+
+Server cache metrics:
+
+- cache_hit{name, method} counter
+- cache_miss{name, method} counter
+- cache_max{name} gauge
+- cache_size{name} gauge
+
+By default hit/miss rate is computed as a sum of all data access attempts (methods `has`, `peek`, `get`).
 
 #### RequestManagerModule
 

package/lib/cache/CacheModule.browser.js

@@ -1,11 +1,11 @@
 import { __decorate } from 'tslib';
-import { createToken } from '@tinkoff/dippy';
+import { provide } from '@tinkoff/dippy';
 import { Module, Scope } from '@tramvai/core';
-import { CREATE_CACHE_TOKEN, CLEAR_CACHE_TOKEN, REGISTER_CLEAR_CACHE_TOKEN } from '@tramvai/tokens-common';
-import { cacheFactory } from './cacheFactory.browser.browser.js';
+import { CREATE_CACHE_TOKEN, CACHE_METRICS_SERVER_TOKEN, CLEAR_CACHE_TOKEN, REGISTER_CLEAR_CACHE_TOKEN } from '@tramvai/tokens-common';
 import { providers } from './clientProviders.browser.js';
+import { cacheRegistry } from './cacheRegistry.browser.js';
+import { CACHES_LIST_TOKEN, CACHE_NAMES_LIST_TOKEN } from './tokens.browser.js';
 
-const cachesToken = createToken('_cachesList');
 let CacheModule = class CacheModule {
 };
 CacheModule = __decorate([
@@ -13,43 +13,45 @@ CacheModule = __decorate([
         providers: [
             ...providers,
             {
-                provide: cachesToken,
+                provide: CACHES_LIST_TOKEN,
                 scope: Scope.SINGLETON,
                 useValue: [],
             },
-            {
+            provide({
                 provide: CREATE_CACHE_TOKEN,
                 scope: Scope.SINGLETON,
-                useFactory: ({ caches }) => {
-                    return (type, ...args) => {
-                        const cache = cacheFactory(type, ...args);
-                        caches.push(cache);
-                        return cache;
-                    };
-                },
+                useFactory: cacheRegistry,
                 deps: {
-                    caches: cachesToken,
+                    caches: CACHES_LIST_TOKEN,
+                    cacheNames: {
+                        token: CACHE_NAMES_LIST_TOKEN,
+                        optional: true,
+                    },
+                    metrics: {
+                        token: CACHE_METRICS_SERVER_TOKEN,
+                        optional: true,
+                    },
                 },
-            },
-            {
+            }),
+            provide({
                 provide: CLEAR_CACHE_TOKEN,
                 scope: Scope.SINGLETON,
-                useFactory: ({ caches, cachesClear }) => {
+                useFactory: ({ caches, onCacheClear }) => {
                     return (type) => {
                         caches.forEach((cache) => cache.clear());
-                        if (cachesClear) {
-                            return Promise.all(cachesClear.map((clear) => clear(type)));
+                        if (onCacheClear) {
+                            return Promise.all(onCacheClear.map((clear) => clear(type)));
                         }
                         return Promise.resolve();
                     };
                 },
                 deps: {
-                    caches: cachesToken,
-                    cachesClear: { token: REGISTER_CLEAR_CACHE_TOKEN, optional: true },
+                    caches: CACHES_LIST_TOKEN,
+                    onCacheClear: { token: REGISTER_CLEAR_CACHE_TOKEN, optional: true },
                 },
-            },
+            }),
         ],
     })
 ], CacheModule);
 
-export { CacheModule, cachesToken };
+export { CacheModule };

package/lib/cache/CacheModule.d.ts

@@ -1,7 +1,3 @@
-import type { Cache } from '@tramvai/tokens-common';
-export declare const cachesToken: Cache<any>[] & {
-    __type?: "base token" | undefined;
-};
 export declare class CacheModule {
 }
 //# sourceMappingURL=CacheModule.d.ts.map

package/lib/cache/CacheModule.es.js

@@ -1,11 +1,11 @@
 import { __decorate } from 'tslib';
-import { createToken } from '@tinkoff/dippy';
+import { provide } from '@tinkoff/dippy';
 import { Module, Scope } from '@tramvai/core';
-import { CREATE_CACHE_TOKEN, CLEAR_CACHE_TOKEN, REGISTER_CLEAR_CACHE_TOKEN } from '@tramvai/tokens-common';
-import { cacheFactory } from './cacheFactory.es.js';
+import { CREATE_CACHE_TOKEN, CACHE_METRICS_SERVER_TOKEN, CLEAR_CACHE_TOKEN, REGISTER_CLEAR_CACHE_TOKEN } from '@tramvai/tokens-common';
 import { providers } from './serverProviders.es.js';
+import { cacheRegistry } from './cacheRegistry.es.js';
+import { CACHES_LIST_TOKEN, CACHE_NAMES_LIST_TOKEN } from './tokens.es.js';
 
-const cachesToken = createToken('_cachesList');
 let CacheModule = class CacheModule {
 };
 CacheModule = __decorate([
@@ -13,43 +13,45 @@ CacheModule = __decorate([
         providers: [
             ...providers,
             {
-                provide: cachesToken,
+                provide: CACHES_LIST_TOKEN,
                 scope: Scope.SINGLETON,
                 useValue: [],
             },
-            {
+            provide({
                 provide: CREATE_CACHE_TOKEN,
                 scope: Scope.SINGLETON,
-                useFactory: ({ caches }) => {
-                    return (type, ...args) => {
-                        const cache = cacheFactory(type, ...args);
-                        caches.push(cache);
-                        return cache;
-                    };
-                },
+                useFactory: cacheRegistry,
                 deps: {
-                    caches: cachesToken,
+                    caches: CACHES_LIST_TOKEN,
+                    cacheNames: {
+                        token: CACHE_NAMES_LIST_TOKEN,
+                        optional: true,
+                    },
+                    metrics: {
+                        token: CACHE_METRICS_SERVER_TOKEN,
+                        optional: true,
+                    },
                 },
-            },
-            {
+            }),
+            provide({
                 provide: CLEAR_CACHE_TOKEN,
                 scope: Scope.SINGLETON,
-                useFactory: ({ caches, cachesClear }) => {
+                useFactory: ({ caches, onCacheClear }) => {
                     return (type) => {
                         caches.forEach((cache) => cache.clear());
-                        if (cachesClear) {
-                            return Promise.all(cachesClear.map((clear) => clear(type)));
+                        if (onCacheClear) {
+                            return Promise.all(onCacheClear.map((clear) => clear(type)));
                         }
                         return Promise.resolve();
                     };
                 },
                 deps: {
-                    caches: cachesToken,
-                    cachesClear: { token: REGISTER_CLEAR_CACHE_TOKEN, optional: true },
+                    caches: CACHES_LIST_TOKEN,
+                    onCacheClear: { token: REGISTER_CLEAR_CACHE_TOKEN, optional: true },
                 },
-            },
+            }),
         ],
     })
 ], CacheModule);
 
-export { CacheModule, cachesToken };
+export { CacheModule };

package/lib/cache/CacheModule.js

@@ -6,10 +6,10 @@ var tslib = require('tslib');
 var dippy = require('@tinkoff/dippy');
 var core = require('@tramvai/core');
 var tokensCommon = require('@tramvai/tokens-common');
-var cacheFactory = require('./cacheFactory.js');
 var serverProviders = require('./serverProviders.js');
+var cacheRegistry = require('./cacheRegistry.js');
+var tokens = require('./tokens.js');
 
-const cachesToken = dippy.createToken('_cachesList');
 exports.CacheModule = class CacheModule {
 };
 exports.CacheModule = tslib.__decorate([
@@ -17,43 +17,43 @@ exports.CacheModule = tslib.__decorate([
         providers: [
             ...serverProviders.providers,
             {
-                provide: cachesToken,
+                provide: tokens.CACHES_LIST_TOKEN,
                 scope: core.Scope.SINGLETON,
                 useValue: [],
             },
-            {
+            dippy.provide({
                 provide: tokensCommon.CREATE_CACHE_TOKEN,
                 scope: core.Scope.SINGLETON,
-                useFactory: ({ caches }) => {
-                    return (type, ...args) => {
-                        const cache = cacheFactory.cacheFactory(type, ...args);
-                        caches.push(cache);
-                        return cache;
-                    };
-                },
+                useFactory: cacheRegistry.cacheRegistry,
                 deps: {
-                    caches: cachesToken,
+                    caches: tokens.CACHES_LIST_TOKEN,
+                    cacheNames: {
+                        token: tokens.CACHE_NAMES_LIST_TOKEN,
+                        optional: true,
+                    },
+                    metrics: {
+                        token: tokensCommon.CACHE_METRICS_SERVER_TOKEN,
+                        optional: true,
+                    },
                 },
-            },
-            {
+            }),
+            dippy.provide({
                 provide: tokensCommon.CLEAR_CACHE_TOKEN,
                 scope: core.Scope.SINGLETON,
-                useFactory: ({ caches, cachesClear }) => {
+                useFactory: ({ caches, onCacheClear }) => {
                     return (type) => {
                         caches.forEach((cache) => cache.clear());
-                        if (cachesClear) {
-                            return Promise.all(cachesClear.map((clear) => clear(type)));
+                        if (onCacheClear) {
+                            return Promise.all(onCacheClear.map((clear) => clear(type)));
                         }
                         return Promise.resolve();
                     };
                 },
                 deps: {
-                    caches: cachesToken,
-                    cachesClear: { token: tokensCommon.REGISTER_CLEAR_CACHE_TOKEN, optional: true },
+                    caches: tokens.CACHES_LIST_TOKEN,
+                    onCacheClear: { token: tokensCommon.REGISTER_CLEAR_CACHE_TOKEN, optional: true },
                 },
-            },
+            }),
         ],
     })
 ], exports.CacheModule);
-
-exports.cachesToken = cachesToken;

package/lib/cache/cacheFactory.browser.browser.js

@@ -1,7 +1,9 @@
 import LRU from '@tinkoff/lru-cache-nano';
 
-const cacheFactory = (type, options = { max: 100 }) => {
-    return new LRU(options);
-};
+function getCacheFactory() {
+    return function cacheFactory(cacheType = 'memory', options) {
+        return new LRU(options);
+    };
+}
 
-export { cacheFactory };
+export { getCacheFactory };

package/lib/cache/cacheFactory.browser.d.ts

@@ -1,3 +1,4 @@
-import type { CacheFactory } from '@tramvai/tokens-common';
-export declare const cacheFactory: CacheFactory;
+import LRU from '@tinkoff/lru-cache-nano';
+import type { CacheOptions, CacheType } from '@tramvai/tokens-common';
+export declare function getCacheFactory(): <T>(cacheType: CacheType | undefined, options: CacheOptions<CacheType>) => LRU<string, T>;
 //# sourceMappingURL=cacheFactory.browser.d.ts.map

package/lib/cache/cacheFactory.d.ts

@@ -1,3 +1,6 @@
-import type { CacheFactory } from '@tramvai/tokens-common';
-export declare const cacheFactory: CacheFactory;
+import type { CacheOptions, Cache, CacheServerMetricsHandlers, CacheType } from '@tramvai/tokens-common';
+export declare function getCacheFactory({ cacheNames, metrics, }: {
+    cacheNames: Set<string> | null;
+    metrics: CacheServerMetricsHandlers | null;
+}): <T>(cacheType: CacheType, options: CacheOptions<CacheType>) => Cache<T>;
 //# sourceMappingURL=cacheFactory.d.ts.map

package/lib/cache/cacheFactory.es.js

@@ -1,34 +1,60 @@
 import LRU from '@tinkoff/lru-cache-nano';
 import LFU from '@akashbabu/lfu-cache';
+import { MEMORY_LRU } from '@tramvai/tokens-common';
+import { isMemoryLFU, isMemoryLRU } from './cacheType.es.js';
+import { CacheWithMetricsProxy } from './cacheWithMetricsProxy.es.js';
 
 class LFUToCacheAdapter extends LFU {
-    set(key, value, options) {
-        return this.set(key, value);
-    }
     has(key) {
-        return typeof this.get(key) !== 'undefined';
+        return typeof super.get(key) !== 'undefined';
     }
     dump() {
         const arr = [];
-        this.forEach(([key, value]) => arr.push([key, { value }]));
+        super.forEach(([key, value]) => arr.push([key, { value }]));
         return arr;
     }
     load(arr) {
         arr.forEach(([key, { value }]) => {
-            this.set(key, value);
+            super.set(key, value);
         });
     }
 }
-const cacheFactory = (type, options = { max: 100 }) => {
-    if (type === 'memory-lfu') {
-        if (typeof options === 'object' && 'ttl' in options) {
-            // ttl option is not supported by @akashbabu/lfu-cache
-            // eslint-disable-next-line no-param-reassign
-            options.maxAge = options.ttl;
-        }
-        return new LFUToCacheAdapter(options);
-    }
+function cacheFactoryMemoryLRU({ type, ...options }) {
     return new LRU(options);
-};
+}
+function cacheFactoryMemoryLFU({ type, ...options }) {
+    if (options && 'ttl' in options && typeof options.ttl === 'number') {
+        // ttl option is not supported by @akashbabu/lfu-cache
+        // eslint-disable-next-line no-param-reassign
+        options.maxAge = options.ttl;
+    }
+    return new LFUToCacheAdapter(options);
+}
+function cacheFactory(cacheType = MEMORY_LRU, options) {
+    let cache;
+    if (isMemoryLFU(options)) {
+        cache = cacheFactoryMemoryLFU(options);
+    }
+    if (isMemoryLRU(options)) {
+        cache = cacheFactoryMemoryLRU(options);
+    }
+    if (!cache) {
+        throw new Error(`Cache type ${cacheType} doesn't implemented yet`);
+    }
+    return cache;
+}
+function getCacheFactory({ cacheNames, metrics, }) {
+    return function (cacheType, options) {
+        const cache = cacheFactory(cacheType, options);
+        if (!(options === null || options === void 0 ? void 0 : options.name) || cacheNames === null) {
+            return cache;
+        }
+        if (cacheNames.has(options.name)) {
+            throw new Error(`Cache with name ${options.name} is already created`);
+        }
+        cacheNames.add(options.name);
+        return new CacheWithMetricsProxy(cache, options, metrics);
+    };
+}
 
-export { cacheFactory };
+export { getCacheFactory };

package/lib/cache/cacheFactory.js

@@ -4,6 +4,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var LRU = require('@tinkoff/lru-cache-nano');
 var LFU = require('@akashbabu/lfu-cache');
+var tokensCommon = require('@tramvai/tokens-common');
+var cacheType = require('./cacheType.js');
+var cacheWithMetricsProxy = require('./cacheWithMetricsProxy.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -11,33 +14,56 @@ var LRU__default = /*#__PURE__*/_interopDefaultLegacy(LRU);
 var LFU__default = /*#__PURE__*/_interopDefaultLegacy(LFU);
 
 class LFUToCacheAdapter extends LFU__default["default"] {
-    set(key, value, options) {
-        return this.set(key, value);
-    }
     has(key) {
-        return typeof this.get(key) !== 'undefined';
+        return typeof super.get(key) !== 'undefined';
     }
     dump() {
         const arr = [];
-        this.forEach(([key, value]) => arr.push([key, { value }]));
+        super.forEach(([key, value]) => arr.push([key, { value }]));
         return arr;
     }
     load(arr) {
         arr.forEach(([key, { value }]) => {
-            this.set(key, value);
+            super.set(key, value);
         });
     }
 }
-const cacheFactory = (type, options = { max: 100 }) => {
-    if (type === 'memory-lfu') {
-        if (typeof options === 'object' && 'ttl' in options) {
-            // ttl option is not supported by @akashbabu/lfu-cache
-            // eslint-disable-next-line no-param-reassign
-            options.maxAge = options.ttl;
-        }
-        return new LFUToCacheAdapter(options);
-    }
+function cacheFactoryMemoryLRU({ type, ...options }) {
     return new LRU__default["default"](options);
-};
+}
+function cacheFactoryMemoryLFU({ type, ...options }) {
+    if (options && 'ttl' in options && typeof options.ttl === 'number') {
+        // ttl option is not supported by @akashbabu/lfu-cache
+        // eslint-disable-next-line no-param-reassign
+        options.maxAge = options.ttl;
+    }
+    return new LFUToCacheAdapter(options);
+}
+function cacheFactory(cacheType$1 = tokensCommon.MEMORY_LRU, options) {
+    let cache;
+    if (cacheType.isMemoryLFU(options)) {
+        cache = cacheFactoryMemoryLFU(options);
+    }
+    if (cacheType.isMemoryLRU(options)) {
+        cache = cacheFactoryMemoryLRU(options);
+    }
+    if (!cache) {
+        throw new Error(`Cache type ${cacheType$1} doesn't implemented yet`);
+    }
+    return cache;
+}
+function getCacheFactory({ cacheNames, metrics, }) {
+    return function (cacheType, options) {
+        const cache = cacheFactory(cacheType, options);
+        if (!(options === null || options === void 0 ? void 0 : options.name) || cacheNames === null) {
+            return cache;
+        }
+        if (cacheNames.has(options.name)) {
+            throw new Error(`Cache with name ${options.name} is already created`);
+        }
+        cacheNames.add(options.name);
+        return new cacheWithMetricsProxy.CacheWithMetricsProxy(cache, options, metrics);
+    };
+}
 
-exports.cacheFactory = cacheFactory;
+exports.getCacheFactory = getCacheFactory;

package/lib/cache/cacheMetrics.d.ts

@@ -0,0 +1,12 @@
+import { type CacheServerMetricsHandlers } from '@tramvai/tokens-common';
+export declare const cacheMetricsServerProviders: import("@tinkoff/dippy").Provider<{
+    metrics: {
+        token: import("@tramvai/tokens-metrics").Metrics & {
+            __type?: "base token" | undefined;
+        };
+        optional: boolean;
+    };
+}, CacheServerMetricsHandlers & {
+    __type?: "base token" | undefined;
+}>[];
+//# sourceMappingURL=cacheMetrics.d.ts.map

package/lib/cache/cacheMetrics.es.js

@@ -0,0 +1,56 @@
+import { provide, Scope } from '@tinkoff/dippy';
+import { CACHE_METRICS_SERVER_TOKEN } from '@tramvai/tokens-common';
+import { METRICS_MODULE_TOKEN } from '@tramvai/tokens-metrics';
+
+const cacheMetricsServerFactory = ({ metrics, }) => {
+    const cacheMetrics = metrics
+        ? {
+            hitCounter: metrics.counter({
+                name: 'cache_hit',
+                help: 'Successful access to retrieve data from a cache.',
+                labelNames: ['name', 'method'],
+            }),
+            missCounter: metrics.counter({
+                name: 'cache_miss',
+                help: 'Failed request to retrieve data from a cache.',
+                labelNames: ['name', 'method'],
+            }),
+            cacheMaxGauge: metrics.gauge({
+                name: 'cache_max',
+                help: 'Maximum number of items in a cache.',
+                labelNames: ['name'],
+            }),
+            cacheSizeGauge: metrics.gauge({
+                name: 'cache_size',
+                help: 'The total number of items in a cache at the current moment.',
+                labelNames: ['name'],
+            }),
+        }
+        : undefined;
+    return {
+        onHit(name, method) {
+            cacheMetrics === null || cacheMetrics === void 0 ? void 0 : cacheMetrics.hitCounter.inc({ name, method });
+        },
+        onMiss(name, method) {
+            cacheMetrics === null || cacheMetrics === void 0 ? void 0 : cacheMetrics.missCounter.inc({ name, method });
+        },
+        onMax(name, size) {
+            cacheMetrics === null || cacheMetrics === void 0 ? void 0 : cacheMetrics.cacheMaxGauge.set({ name }, size);
+        },
+        onSize(name, size) {
+            cacheMetrics === null || cacheMetrics === void 0 ? void 0 : cacheMetrics.cacheSizeGauge.set({ name }, size);
+        },
+    };
+};
+const cacheMetricsServerProviders = [
+    provide({
+        provide: CACHE_METRICS_SERVER_TOKEN,
+        useFactory: cacheMetricsServerFactory,
+        scope: Scope.SINGLETON,
+        deps: {
+            metrics: { token: METRICS_MODULE_TOKEN, optional: true },
+        },
+    }),
+];
+
+export { cacheMetricsServerProviders };

package/lib/cache/cacheMetrics.js

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dippy = require('@tinkoff/dippy');
+var tokensCommon = require('@tramvai/tokens-common');
+var tokensMetrics = require('@tramvai/tokens-metrics');
+
+const cacheMetricsServerFactory = ({ metrics, }) => {
+    const cacheMetrics = metrics
+        ? {
+            hitCounter: metrics.counter({
+                name: 'cache_hit',
+                help: 'Successful access to retrieve data from a cache.',
+                labelNames: ['name', 'method'],
+            }),
+            missCounter: metrics.counter({
+                name: 'cache_miss',
+                help: 'Failed request to retrieve data from a cache.',
+                labelNames: ['name', 'method'],
+            }),
+            cacheMaxGauge: metrics.gauge({
+                name: 'cache_max',
+                help: 'Maximum number of items in a cache.',
+                labelNames: ['name'],
+            }),
+            cacheSizeGauge: metrics.gauge({
+                name: 'cache_size',
+                help: 'The total number of items in a cache at the current moment.',
+                labelNames: ['name'],
+            }),
+        }
+        : undefined;
+    return {
+        onHit(name, method) {
+            cacheMetrics === null || cacheMetrics === void 0 ? void 0 : cacheMetrics.hitCounter.inc({ name, method });
+        },
+        onMiss(name, method) {
+            cacheMetrics === null || cacheMetrics === void 0 ? void 0 : cacheMetrics.missCounter.inc({ name, method });
+        },
+        onMax(name, size) {
+            cacheMetrics === null || cacheMetrics === void 0 ? void 0 : cacheMetrics.cacheMaxGauge.set({ name }, size);
+        },
+        onSize(name, size) {
+            cacheMetrics === null || cacheMetrics === void 0 ? void 0 : cacheMetrics.cacheSizeGauge.set({ name }, size);
+        },
+    };
+};
+const cacheMetricsServerProviders = [
+    dippy.provide({
+        provide: tokensCommon.CACHE_METRICS_SERVER_TOKEN,
+        useFactory: cacheMetricsServerFactory,
+        scope: dippy.Scope.SINGLETON,
+        deps: {
+            metrics: { token: tokensMetrics.METRICS_MODULE_TOKEN, optional: true },
+        },
+    }),
+];
+
+exports.cacheMetricsServerProviders = cacheMetricsServerProviders;

package/lib/cache/cacheOptions.browser.js

@@ -0,0 +1,10 @@
+const CACHE_MAX_DEFAULT = 100;
+function getCacheOptions(cacheType, options) {
+    return {
+        type: cacheType,
+        max: CACHE_MAX_DEFAULT,
+        ...options,
+    };
+}
+
+export { getCacheOptions };

package/lib/cache/cacheOptions.d.ts

@@ -0,0 +1,3 @@
+import type { CacheFactoryOptions, CacheOptions, CacheType } from '@tramvai/tokens-common';
+export declare function getCacheOptions(cacheType: CacheType, options?: CacheFactoryOptions<typeof cacheType>): CacheOptions<typeof cacheType>;
+//# sourceMappingURL=cacheOptions.d.ts.map

package/lib/cache/cacheOptions.es.js

@@ -0,0 +1,10 @@
+const CACHE_MAX_DEFAULT = 100;
+function getCacheOptions(cacheType, options) {
+    return {
+        type: cacheType,
+        max: CACHE_MAX_DEFAULT,
+        ...options,
+    };
+}
+
+export { getCacheOptions };

package/lib/cache/cacheOptions.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const CACHE_MAX_DEFAULT = 100;
+function getCacheOptions(cacheType, options) {
+    return {
+        type: cacheType,
+        max: CACHE_MAX_DEFAULT,
+        ...options,
+    };
+}
+
+exports.getCacheOptions = getCacheOptions;

package/lib/cache/cacheRegistry.browser.js

@@ -0,0 +1,14 @@
+import { getCacheOptions } from './cacheOptions.browser.js';
+import { getCacheFactory } from './cacheFactory.browser.browser.js';
+
+function cacheRegistry({ caches, cacheNames, metrics, }) {
+    return function (cacheType = 'memory', options) {
+        const extendedOptions = getCacheOptions(cacheType, options);
+        const factory = getCacheFactory();
+        const cache = factory(cacheType, extendedOptions);
+        caches.push(cache);
+        return cache;
+    };
+}
+
+export { cacheRegistry };

package/lib/cache/cacheRegistry.d.ts

@@ -0,0 +1,7 @@
+import type { Cache, CacheFactory, CacheServerMetricsHandlers } from '@tramvai/tokens-common';
+export declare function cacheRegistry({ caches, cacheNames, metrics, }: {
+    caches: Cache[];
+    cacheNames: Set<string> | null;
+    metrics: CacheServerMetricsHandlers | null;
+}): CacheFactory;
+//# sourceMappingURL=cacheRegistry.d.ts.map

package/lib/cache/cacheRegistry.es.js

@@ -0,0 +1,14 @@
+import { getCacheOptions } from './cacheOptions.es.js';
+import { getCacheFactory } from './cacheFactory.es.js';
+
+function cacheRegistry({ caches, cacheNames, metrics, }) {
+    return function (cacheType = 'memory', options) {
+        const extendedOptions = getCacheOptions(cacheType, options);
+        const factory = getCacheFactory({ cacheNames, metrics });
+        const cache = factory(cacheType, extendedOptions);
+        caches.push(cache);
+        return cache;
+    };
+}
+
+export { cacheRegistry };

package/lib/cache/cacheRegistry.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cacheOptions = require('./cacheOptions.js');
+var cacheFactory = require('./cacheFactory.js');
+
+function cacheRegistry({ caches, cacheNames, metrics, }) {
+    return function (cacheType = 'memory', options) {
+        const extendedOptions = cacheOptions.getCacheOptions(cacheType, options);
+        const factory = cacheFactory.getCacheFactory({ cacheNames, metrics });
+        const cache = factory(cacheType, extendedOptions);
+        caches.push(cache);
+        return cache;
+    };
+}
+
+exports.cacheRegistry = cacheRegistry;

package/lib/cache/cacheType.d.ts

@@ -0,0 +1,5 @@
+import type { CacheOptions, CacheType } from '@tramvai/tokens-common';
+import { MEMORY_LRU, MEMORY_LFU } from '@tramvai/tokens-common';
+export declare function isMemoryLRU(options: CacheOptions<CacheType>): options is CacheOptions<typeof MEMORY_LRU>;
+export declare function isMemoryLFU(options: CacheOptions<CacheType>): options is CacheOptions<typeof MEMORY_LFU>;
+//# sourceMappingURL=cacheType.d.ts.map

package/lib/cache/cacheType.es.js

@@ -0,0 +1,10 @@
+import { MEMORY_LRU, MEMORY_LFU } from '@tramvai/tokens-common';
+
+function isMemoryLRU(options) {
+    return options.type === MEMORY_LRU;
+}
+function isMemoryLFU(options) {
+    return options.type === MEMORY_LFU;
+}
+
+export { isMemoryLFU, isMemoryLRU };

package/lib/cache/cacheType.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tokensCommon = require('@tramvai/tokens-common');
+
+function isMemoryLRU(options) {
+    return options.type === tokensCommon.MEMORY_LRU;
+}
+function isMemoryLFU(options) {
+    return options.type === tokensCommon.MEMORY_LFU;
+}
+
+exports.isMemoryLFU = isMemoryLFU;
+exports.isMemoryLRU = isMemoryLRU;

package/lib/cache/cacheWithMetricsProxy.d.ts

@@ -0,0 +1,25 @@
+import type { Cache, CacheOptions, CacheServerMetricsHandlers, CacheType } from '@tramvai/tokens-common';
+export declare class CacheWithMetricsProxy<T> implements Cache<T> {
+    private cache;
+    private options;
+    private metrics;
+    constructor(cache: Cache, options: CacheOptions<CacheType> | undefined, metrics: CacheServerMetricsHandlers | null);
+    private handleAccess;
+    private syncSize;
+    get(key: string): T | undefined;
+    peek(key: string): T | undefined;
+    has(key: string): boolean;
+    set(key: string, value: T, options?: {
+        ttl?: number;
+    }): void;
+    delete(key: string): boolean;
+    clear(): void;
+    dump(): Array<[string, {
+        value: T;
+    }]>;
+    load(entries: Array<[string, {
+        value: T;
+    }]>): void;
+    get size(): number;
+}
+//# sourceMappingURL=cacheWithMetricsProxy.d.ts.map

package/lib/cache/cacheWithMetricsProxy.es.js

@@ -0,0 +1,74 @@
+class CacheWithMetricsProxy {
+    constructor(cache, options, metrics) {
+        var _a;
+        this.cache = cache;
+        this.options = options;
+        this.metrics = metrics;
+        if (this.options &&
+            this.options.name &&
+            'max' in this.options &&
+            typeof this.options.max === 'number') {
+            (_a = this.metrics) === null || _a === void 0 ? void 0 : _a.onMax(this.options.name, this.options.max);
+        }
+    }
+    handleAccess(_key, value, method) {
+        var _a, _b, _c;
+        if (!((_a = this.options) === null || _a === void 0 ? void 0 : _a.name)) {
+            return;
+        }
+        if (value) {
+            (_b = this.metrics) === null || _b === void 0 ? void 0 : _b.onHit(this.options.name, method);
+        }
+        else {
+            (_c = this.metrics) === null || _c === void 0 ? void 0 : _c.onMiss(this.options.name, method);
+        }
+    }
+    syncSize() {
+        var _a, _b;
+        if (!((_a = this.options) === null || _a === void 0 ? void 0 : _a.name)) {
+            return;
+        }
+        (_b = this.metrics) === null || _b === void 0 ? void 0 : _b.onSize(this.options.name, this.cache.size);
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        this.handleAccess(key, value, 'get');
+        this.syncSize();
+        return value;
+    }
+    peek(key) {
+        const value = this.cache.peek(key);
+        this.handleAccess(key, value, 'peek');
+        return value;
+    }
+    has(key) {
+        const value = this.cache.has(key);
+        this.handleAccess(key, value, 'has');
+        return value;
+    }
+    set(key, value, options) {
+        this.cache.set(key, value, options);
+        this.syncSize();
+    }
+    delete(key) {
+        const result = this.cache.delete(key);
+        this.syncSize();
+        return result;
+    }
+    clear() {
+        this.cache.clear();
+        this.syncSize();
+    }
+    dump() {
+        return this.cache.dump();
+    }
+    load(entries) {
+        this.cache.load(entries);
+        this.syncSize();
+    }
+    get size() {
+        return this.cache.size;
+    }
+}
+
+export { CacheWithMetricsProxy };

package/lib/cache/cacheWithMetricsProxy.js

@@ -0,0 +1,78 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class CacheWithMetricsProxy {
+    constructor(cache, options, metrics) {
+        var _a;
+        this.cache = cache;
+        this.options = options;
+        this.metrics = metrics;
+        if (this.options &&
+            this.options.name &&
+            'max' in this.options &&
+            typeof this.options.max === 'number') {
+            (_a = this.metrics) === null || _a === void 0 ? void 0 : _a.onMax(this.options.name, this.options.max);
+        }
+    }
+    handleAccess(_key, value, method) {
+        var _a, _b, _c;
+        if (!((_a = this.options) === null || _a === void 0 ? void 0 : _a.name)) {
+            return;
+        }
+        if (value) {
+            (_b = this.metrics) === null || _b === void 0 ? void 0 : _b.onHit(this.options.name, method);
+        }
+        else {
+            (_c = this.metrics) === null || _c === void 0 ? void 0 : _c.onMiss(this.options.name, method);
+        }
+    }
+    syncSize() {
+        var _a, _b;
+        if (!((_a = this.options) === null || _a === void 0 ? void 0 : _a.name)) {
+            return;
+        }
+        (_b = this.metrics) === null || _b === void 0 ? void 0 : _b.onSize(this.options.name, this.cache.size);
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        this.handleAccess(key, value, 'get');
+        this.syncSize();
+        return value;
+    }
+    peek(key) {
+        const value = this.cache.peek(key);
+        this.handleAccess(key, value, 'peek');
+        return value;
+    }
+    has(key) {
+        const value = this.cache.has(key);
+        this.handleAccess(key, value, 'has');
+        return value;
+    }
+    set(key, value, options) {
+        this.cache.set(key, value, options);
+        this.syncSize();
+    }
+    delete(key) {
+        const result = this.cache.delete(key);
+        this.syncSize();
+        return result;
+    }
+    clear() {
+        this.cache.clear();
+        this.syncSize();
+    }
+    dump() {
+        return this.cache.dump();
+    }
+    load(entries) {
+        this.cache.load(entries);
+        this.syncSize();
+    }
+    get size() {
+        return this.cache.size;
+    }
+}
+
+exports.CacheWithMetricsProxy = CacheWithMetricsProxy;

package/lib/cache/serverProviders.es.js

@@ -1,9 +1,17 @@
-import { provide } from '@tramvai/core';
+import { provide, Scope } from '@tramvai/core';
 import { SERVER_MODULE_PAPI_PRIVATE_ROUTE } from '@tramvai/tokens-server';
 import { CLEAR_CACHE_TOKEN, LOGGER_TOKEN } from '@tramvai/tokens-common';
 import { papiClearCache } from './papi.es.js';
+import { CACHE_NAMES_LIST_TOKEN } from './tokens.es.js';
+import { cacheMetricsServerProviders } from './cacheMetrics.es.js';
 
 const providers = [
+    ...cacheMetricsServerProviders,
+    provide({
+        provide: CACHE_NAMES_LIST_TOKEN,
+        scope: Scope.SINGLETON,
+        useValue: new Set(),
+    }),
     provide({
         provide: SERVER_MODULE_PAPI_PRIVATE_ROUTE,
         multi: true,

package/lib/cache/serverProviders.js

@@ -6,8 +6,16 @@ var core = require('@tramvai/core');
 var tokensServer = require('@tramvai/tokens-server');
 var tokensCommon = require('@tramvai/tokens-common');
 var papi = require('./papi.js');
+var tokens = require('./tokens.js');
+var cacheMetrics = require('./cacheMetrics.js');
 
 const providers = [
+    ...cacheMetrics.cacheMetricsServerProviders,
+    core.provide({
+        provide: tokens.CACHE_NAMES_LIST_TOKEN,
+        scope: core.Scope.SINGLETON,
+        useValue: new Set(),
+    }),
     core.provide({
         provide: tokensServer.SERVER_MODULE_PAPI_PRIVATE_ROUTE,
         multi: true,

package/lib/cache/tokens.browser.js

@@ -0,0 +1,8 @@
+import { createToken } from '@tinkoff/dippy';
+
+/** Is used to perform all app caches clearing */
+const CACHES_LIST_TOKEN = createToken('_cachesList');
+/** Is used to check the uniqueness of metrics labels */
+const CACHE_NAMES_LIST_TOKEN = createToken('cache names list');
+
+export { CACHES_LIST_TOKEN, CACHE_NAMES_LIST_TOKEN };

package/lib/cache/tokens.d.ts

@@ -0,0 +1,10 @@
+import type { Cache } from '@tramvai/tokens-common';
+/** Is used to perform all app caches clearing */
+export declare const CACHES_LIST_TOKEN: Cache<any>[] & {
+    __type?: "base token" | undefined;
+};
+/** Is used to check the uniqueness of metrics labels */
+export declare const CACHE_NAMES_LIST_TOKEN: Set<string> & {
+    __type?: "base token" | undefined;
+};
+//# sourceMappingURL=tokens.d.ts.map

package/lib/cache/tokens.es.js

@@ -0,0 +1,8 @@
+import { createToken } from '@tinkoff/dippy';
+
+/** Is used to perform all app caches clearing */
+const CACHES_LIST_TOKEN = createToken('_cachesList');
+/** Is used to check the uniqueness of metrics labels */
+const CACHE_NAMES_LIST_TOKEN = createToken('cache names list');
+
+export { CACHES_LIST_TOKEN, CACHE_NAMES_LIST_TOKEN };

package/lib/cache/tokens.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dippy = require('@tinkoff/dippy');
+
+/** Is used to perform all app caches clearing */
+const CACHES_LIST_TOKEN = dippy.createToken('_cachesList');
+/** Is used to check the uniqueness of metrics labels */
+const CACHE_NAMES_LIST_TOKEN = dippy.createToken('cache names list');
+
+exports.CACHES_LIST_TOKEN = CACHES_LIST_TOKEN;
+exports.CACHE_NAMES_LIST_TOKEN = CACHE_NAMES_LIST_TOKEN;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-common",
-  "version": "4.36.0",
+  "version": "4.37.0",
   "description": "",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -30,36 +30,37 @@
     "watch": "tsc -w"
   },
   "dependencies": {
+    "@akashbabu/lfu-cache": "1.0.2",
     "@tinkoff/errors": "0.5.1",
     "@tinkoff/hook-runner": "0.6.1",
     "@tinkoff/lru-cache-nano": "^7.9.0",
-    "@akashbabu/lfu-cache": "1.0.2",
     "@tinkoff/pubsub": "0.7.1",
     "@tinkoff/url": "0.10.1",
-    "@tramvai/safe-strings": "0.7.2",
-    "@tramvai/experiments": "4.36.0",
-    "@tramvai/module-cookie": "4.36.0",
-    "@tramvai/module-environment": "4.36.0",
-    "@tramvai/module-log": "4.36.0",
-    "@tramvai/tokens-child-app": "4.36.0",
-    "@tramvai/tokens-core-private": "4.36.0",
-    "@tramvai/tokens-common": "4.36.0",
-    "@tramvai/tokens-render": "4.36.0",
-    "@tramvai/tokens-router": "4.36.0",
-    "@tramvai/tokens-server-private": "4.36.0",
-    "@tramvai/types-actions-state-context": "4.36.0",
+    "@tramvai/experiments": "4.37.0",
+    "@tramvai/module-cookie": "4.37.0",
+    "@tramvai/module-environment": "4.37.0",
+    "@tramvai/module-log": "4.37.0",
+    "@tramvai/safe-strings": "0.7.3",
+    "@tramvai/tokens-child-app": "4.37.0",
+    "@tramvai/tokens-common": "4.37.0",
+    "@tramvai/tokens-core-private": "4.37.0",
+    "@tramvai/tokens-metrics": "4.37.0",
+    "@tramvai/tokens-render": "4.37.0",
+    "@tramvai/tokens-router": "4.37.0",
+    "@tramvai/tokens-server-private": "4.37.0",
+    "@tramvai/types-actions-state-context": "4.37.0",
     "hoist-non-react-statics": "^3.3.1",
     "node-abort-controller": "^3.0.1"
   },
   "peerDependencies": {
     "@tinkoff/dippy": "0.10.8",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/cli": "4.36.0",
-    "@tramvai/core": "4.36.0",
-    "@tramvai/papi": "4.36.0",
-    "@tramvai/react": "4.36.0",
-    "@tramvai/state": "4.36.0",
-    "@tramvai/tokens-server": "4.36.0",
+    "@tramvai/cli": "4.37.0",
+    "@tramvai/core": "4.37.0",
+    "@tramvai/papi": "4.37.0",
+    "@tramvai/react": "4.37.0",
+    "@tramvai/state": "4.37.0",
+    "@tramvai/tokens-server": "4.37.0",
     "react": ">=16.14.0",
     "tslib": "^2.4.0"
   },