@tramvai/module-dns-cache 2.117.0

package/README.md

@@ -0,0 +1,64 @@
+# @tramvai/module-dns-cache
+
+
+DNS lookup cache for Node.js - [cacheable-lookup](https://github.com/szmarczak/cacheable-lookup) library integration.
+
+## Explanation
+
+DNS lookup cache can speed up your server-side HTTP requests to external API's.
+
+Usually, DNS lookup is a fast process, but Node.js (`libuv` under the hood) has a [default limit of 4 concurrent threads](https://nodejs.org/docs/latest-v18.x/api/cli.html#uv_threadpool_sizesize), used for a [set of synchronous operations](https://nodejs.org/en/docs/guides/dont-block-the-event-loop), including DNS lookup, so lookup can be queued. Or if application is under high load, or while any network problems, DNS lookup time can be increased.
+
+First main optimization of HTTP connections is already used in `tramvai` [HTTP clients](03-features/09-data-fetching/02-http-client.md) - [keepAlive option](https://nodejs.org/api/http.html#new-agentoptions) for `http` and `https` agents. With `keepAlive`, TCP sockets are reused for multiple HTTP requests, and count of DNS lookups is decreased dramatically.
+
+Because of that, DNS cache it's a nice and cheap optimization, but don't expect some huge performance boost.
+
+Potential disadvantages - external services can change their IP addresses, and HTTP requests will use outdated DNS cache, you can detect this by search `ENOTFOUND` errors is server logs, so long cache TTL is not recommended.
+
+## Installation
+
+You need to install `@tramvai/module-dns-cache` module:
+
+```bash
+npx tramvai add @tramvai/module-dns-cache
+```
+
+Then, connect `TramvaiDnsCacheModule` from this package to `createApp` function:
+
+```ts
+import { createApp } from '@tramvai/core';
+import { TramvaiDnsCacheModule } from '@tramvai/module-dns-cache';
+
+createApp({
+  name: 'tincoin',
+  modules: [TramvaiDnsCacheModule],
+});
+```
+
+## Configuration
+
+### Enable/disable
+
+By default, DNS lookup cache is **enabled**.
+
+To disable it, you need to provide `DNS_LOOKUP_CACHE_ENABLE` environment variable:
+
+```bash
+DNS_LOOKUP_CACHE_ENABLE=false
+```
+
+### Cache TTL
+
+Default TTL for DNS lookup cache is 60 seconds. You can change it by providing `DNS_LOOKUP_CACHE_TTL` environment variable:
+
+```bash
+DNS_LOOKUP_CACHE_TTL=120000
+```
+
+### Cache size
+
+Default cache size is 200 entries. You can change it by providing `DNS_LOOKUP_CACHE_LIMIT` environment variable:
+
+```bash
+DNS_LOOKUP_CACHE_LIMIT=500
+```

package/lib/browser.d.ts

@@ -0,0 +1,3 @@
+export declare const TramvaiDnsCacheModule: import("@tinkoff/dippy/lib/modules/module.h").ModuleClass & Partial<import("@tinkoff/dippy/lib/modules/module.h").ModuleSecretParameters> & {
+    [x: string]: (...args: any[]) => import("@tramvai/core").ModuleType<import("@tinkoff/dippy/lib/modules/module.h").ModuleClass>;
+};

package/lib/browser.js

@@ -0,0 +1,9 @@
+import { declareModule } from '@tramvai/core';
+
+const TramvaiDnsCacheModule = declareModule({
+    name: 'TramvaiDnsCacheModule',
+    imports: [],
+    providers: [],
+});
+
+export { TramvaiDnsCacheModule };

package/lib/server.d.ts

@@ -0,0 +1,3 @@
+export declare const TramvaiDnsCacheModule: import("@tinkoff/dippy/lib/modules/module.h").ModuleClass & Partial<import("@tinkoff/dippy/lib/modules/module.h").ModuleSecretParameters> & {
+    [x: string]: (...args: any[]) => import("@tramvai/core").ModuleType<import("@tinkoff/dippy/lib/modules/module.h").ModuleClass>;
+};

package/lib/server.es.js

@@ -0,0 +1,81 @@
+import noop from '@tinkoff/utils/function/noop';
+import http from 'http';
+import https from 'https';
+import dns from 'dns';
+import CacheableLookup from 'cacheable-lookup';
+import { createToken, declareModule, provide, commandLineListTokens, Scope } from '@tramvai/core';
+import { ENV_MANAGER_TOKEN, CREATE_CACHE_TOKEN, ENV_USED_TOKEN } from '@tramvai/tokens-common';
+
+const DNS_LOOKUP_CACHE_TOKEN = createToken('dnsLookupCache');
+const TramvaiDnsCacheModule = declareModule({
+    name: 'TramvaiDnsCacheModule',
+    imports: [],
+    providers: [
+        provide({
+            provide: commandLineListTokens.init,
+            multi: true,
+            useFactory: ({ envManager, cache }) => {
+                if (envManager.get('DNS_LOOKUP_CACHE_ENABLE') !== 'true') {
+                    return noop;
+                }
+                return () => {
+                    const maxTtl = Number(envManager.get('DNS_LOOKUP_CACHE_TTL'));
+                    const cacheable = new CacheableLookup({
+                        cache,
+                        maxTtl,
+                    });
+                    const originalLookup = cacheable.lookup;
+                    // workaround for https://github.com/szmarczak/cacheable-lookup/issues/68,
+                    // use original dns.lookup for localhost because cacheable-lookup doesn't handle `ESERVFAIL` error when resolving ipv6
+                    // @ts-expect-error
+                    cacheable.lookup = (hostname, options, callback) => {
+                        if (hostname === 'localhost') {
+                            return dns.lookup(hostname, options, callback);
+                        }
+                        originalLookup.call(cacheable, hostname, options, callback);
+                    };
+                    cacheable.install(http.globalAgent);
+                    cacheable.install(https.globalAgent);
+                };
+            },
+            deps: {
+                envManager: ENV_MANAGER_TOKEN,
+                cache: DNS_LOOKUP_CACHE_TOKEN,
+            },
+        }),
+        provide({
+            provide: DNS_LOOKUP_CACHE_TOKEN,
+            scope: Scope.SINGLETON,
+            useFactory: ({ createCache, envManager }) => {
+                const max = Number(envManager.get('DNS_LOOKUP_CACHE_LIMIT'));
+                const ttl = Number(envManager.get('DNS_LOOKUP_CACHE_TTL'));
+                return createCache('memory', { max, ttl });
+            },
+            deps: {
+                createCache: CREATE_CACHE_TOKEN,
+                envManager: ENV_MANAGER_TOKEN,
+            },
+        }),
+        provide({
+            provide: ENV_USED_TOKEN,
+            multi: true,
+            useValue: [
+                { key: 'DNS_LOOKUP_CACHE_ENABLE', dehydrate: false, optional: true, value: 'true' },
+                {
+                    key: 'DNS_LOOKUP_CACHE_LIMIT',
+                    value: '200',
+                    dehydrate: false,
+                    optional: true,
+                },
+                {
+                    key: 'DNS_LOOKUP_CACHE_TTL',
+                    value: '60000',
+                    dehydrate: false,
+                    optional: true,
+                },
+            ],
+        }),
+    ],
+});
+
+export { TramvaiDnsCacheModule };

package/lib/server.js

@@ -0,0 +1,93 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var noop = require('@tinkoff/utils/function/noop');
+var http = require('http');
+var https = require('https');
+var dns = require('dns');
+var CacheableLookup = require('cacheable-lookup');
+var core = require('@tramvai/core');
+var tokensCommon = require('@tramvai/tokens-common');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var noop__default = /*#__PURE__*/_interopDefaultLegacy(noop);
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
+var dns__default = /*#__PURE__*/_interopDefaultLegacy(dns);
+var CacheableLookup__default = /*#__PURE__*/_interopDefaultLegacy(CacheableLookup);
+
+const DNS_LOOKUP_CACHE_TOKEN = core.createToken('dnsLookupCache');
+const TramvaiDnsCacheModule = core.declareModule({
+    name: 'TramvaiDnsCacheModule',
+    imports: [],
+    providers: [
+        core.provide({
+            provide: core.commandLineListTokens.init,
+            multi: true,
+            useFactory: ({ envManager, cache }) => {
+                if (envManager.get('DNS_LOOKUP_CACHE_ENABLE') !== 'true') {
+                    return noop__default["default"];
+                }
+                return () => {
+                    const maxTtl = Number(envManager.get('DNS_LOOKUP_CACHE_TTL'));
+                    const cacheable = new CacheableLookup__default["default"]({
+                        cache,
+                        maxTtl,
+                    });
+                    const originalLookup = cacheable.lookup;
+                    // workaround for https://github.com/szmarczak/cacheable-lookup/issues/68,
+                    // use original dns.lookup for localhost because cacheable-lookup doesn't handle `ESERVFAIL` error when resolving ipv6
+                    // @ts-expect-error
+                    cacheable.lookup = (hostname, options, callback) => {
+                        if (hostname === 'localhost') {
+                            return dns__default["default"].lookup(hostname, options, callback);
+                        }
+                        originalLookup.call(cacheable, hostname, options, callback);
+                    };
+                    cacheable.install(http__default["default"].globalAgent);
+                    cacheable.install(https__default["default"].globalAgent);
+                };
+            },
+            deps: {
+                envManager: tokensCommon.ENV_MANAGER_TOKEN,
+                cache: DNS_LOOKUP_CACHE_TOKEN,
+            },
+        }),
+        core.provide({
+            provide: DNS_LOOKUP_CACHE_TOKEN,
+            scope: core.Scope.SINGLETON,
+            useFactory: ({ createCache, envManager }) => {
+                const max = Number(envManager.get('DNS_LOOKUP_CACHE_LIMIT'));
+                const ttl = Number(envManager.get('DNS_LOOKUP_CACHE_TTL'));
+                return createCache('memory', { max, ttl });
+            },
+            deps: {
+                createCache: tokensCommon.CREATE_CACHE_TOKEN,
+                envManager: tokensCommon.ENV_MANAGER_TOKEN,
+            },
+        }),
+        core.provide({
+            provide: tokensCommon.ENV_USED_TOKEN,
+            multi: true,
+            useValue: [
+                { key: 'DNS_LOOKUP_CACHE_ENABLE', dehydrate: false, optional: true, value: 'true' },
+                {
+                    key: 'DNS_LOOKUP_CACHE_LIMIT',
+                    value: '200',
+                    dehydrate: false,
+                    optional: true,
+                },
+                {
+                    key: 'DNS_LOOKUP_CACHE_TTL',
+                    value: '60000',
+                    dehydrate: false,
+                    optional: true,
+                },
+            ],
+        }),
+    ],
+});
+
+exports.TramvaiDnsCacheModule = TramvaiDnsCacheModule;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@tramvai/module-dns-cache",
+  "version": "2.117.0",
+  "description": "DNS lookup cache",
+  "browser": "lib/browser.js",
+  "main": "lib/server.js",
+  "module": "lib/server.es.js",
+  "typings": "lib/server.d.ts",
+  "files": [
+    "lib"
+  ],
+  "sideEffects": false,
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:Tinkoff/tramvai.git"
+  },
+  "scripts": {
+    "build": "tramvai-build --forPublish --preserveModules",
+    "watch": "tsc -w"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@tinkoff/utils": "^2.1.2",
+    "@tramvai/core": "2.117.0",
+    "@tramvai/tokens-common": "2.117.0",
+    "cacheable-lookup": "^7.0.0"
+  },
+  "devDependencies": {},
+  "peerDependencies": {
+    "tslib": "^2.4.0"
+  }
+}