@eggjs/tegg-dns-cache 3.68.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-present Alibaba Group Holding Limited and other contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,144 @@
+# @eggjs/tegg-dns-cache
+
+DNS cache plugin for tegg framework. This plugin provides DNS caching capabilities to improve performance and reduce DNS lookup time.
+
+## Features
+
+- 🚀 DNS lookup caching with LRU algorithm
+- ⚖️ Round-robin address rotation for load balancing
+- 🔄 Support both `dns.lookup` and `dns.resolve` modes
+- ⏱️ Configurable cache TTL
+- 🔌 Automatic integration with egg httpclient
+- 🎯 Custom DNS nameservers support
+
+## Installation
+
+```bash
+npm install @eggjs/tegg-dns-cache --save
+```
+
+## Usage
+
+### Enable Plugin
+
+```js
+// config/plugin.js
+exports.dnsCache = {
+  enable: true,
+  package: '@eggjs/tegg-dns-cache',
+};
+```
+
+### Configuration
+
+```js
+// config/config.default.js
+exports.dnsCache = {
+  // DNS resolution mode: 'lookup' or 'resolve' (default: 'resolve')
+  // - lookup: Use dns.lookup, respects /etc/hosts, but no TTL support
+  // - resolve: Use dns.resolve, queries DNS directly, TTL supported
+  mode: 'resolve',
+  
+  // Custom DNS nameservers (only for 'resolve' mode)
+  dnsServers: ['8.8.8.8', '1.1.1.1'],
+  
+  // Maximum cache entries (default: 1000)
+  maxCacheLength: 1000,
+  
+  // Cache lookup interval in ms (only for 'lookup' mode, default: 10000)
+  lookupInterval: 10000,
+  
+  // Enable address rotation for multiple IPs (default: true)
+  addressRotation: true,
+};
+```
+
+## DNS Resolution Modes
+
+### Resolve Mode (Recommended)
+
+Uses `dns.resolve4()` to query DNS servers directly. Supports TTL from DNS records.
+
+**Advantages:**
+- Respects DNS TTL from authoritative servers
+- More control over DNS resolution
+- Can specify custom nameservers
+
+**Note:** Does not respect `/etc/hosts` file.
+
+```js
+exports.dnsCache = {
+  mode: 'resolve',
+  dnsServers: ['8.8.8.8', '1.1.1.1'], // Optional custom DNS servers
+};
+```
+
+### Lookup Mode
+
+Uses `dns.lookup()` which respects system DNS configuration and `/etc/hosts`.
+
+**Advantages:**
+- Respects `/etc/hosts` entries
+- Uses system DNS configuration
+
+**Disadvantages:**
+- Fixed cache interval (no real TTL)
+- Less control over resolution
+
+```js
+exports.dnsCache = {
+  mode: 'lookup',
+  lookupInterval: 10000, // Cache refresh interval in ms
+};
+```
+
+## API
+
+### Access DNS Resolver
+
+```js
+// In controller or service
+const resolver = this.app.dnsResolver;
+
+// Get cached DNS record
+const record = resolver.getCacheRecord('example.com');
+console.log(record); // { ip: '93.184.216.34', family: 4, ttl: 60000, ... }
+
+// Clear DNS cache
+resolver.resetCache();
+
+// Get the underlying LRU cache
+const cache = resolver.getDnsCache();
+```
+
+## Address Rotation
+
+When a hostname resolves to multiple IP addresses, the plugin can automatically rotate through them for load balancing:
+
+```js
+exports.dnsCache = {
+  addressRotation: true, // Enable round-robin rotation
+};
+```
+
+Each request to the same hostname will use the next IP address in rotation.
+
+## Integration with HttpClient
+
+The plugin automatically integrates with egg's built-in httpclient. All HTTP requests will benefit from DNS caching:
+
+```js
+// This request will use cached DNS
+await this.app.httpclient.request('https://example.com/api');
+```
+
+## Performance Benefits
+
+- **Reduced DNS lookup time**: Cached DNS results eliminate network round trips
+- **Lower DNS server load**: Fewer queries to DNS servers
+- **Improved request throughput**: Faster connection establishment
+- **Load distribution**: Address rotation spreads load across multiple IPs
+
+## License
+
+MIT

package/app.d.ts

@@ -0,0 +1,10 @@
+import { Application } from 'egg';
+export default class DnsCacheAppHook {
+    private readonly app;
+    private dnsResolver;
+    constructor(app: Application);
+    configWillLoad(): void;
+    configDidLoad(): void;
+    didLoad(): Promise<void>;
+    beforeClose(): void;
+}

package/app.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DnsResolver_1 = require("./lib/DnsResolver");
+class DnsCacheAppHook {
+    constructor(app) {
+        this.app = app;
+    }
+    configWillLoad() {
+        if (!this.app.config.dnsCache) {
+            this.app.logger.warn('[tegg-dns-cache-plugin] DNS cache is disabled, please setup dnsCache config.');
+        }
+        const config = this.app.config.dnsCache || {};
+        // Create DNS resolver instance
+        const useDNSResolver = config.mode !== 'lookup';
+        this.dnsResolver = new DnsResolver_1.DnsResolver({
+            useResolver: useDNSResolver,
+            servers: config.dnsServers,
+            max: config.maxCacheLength || 1000,
+            dnsCacheLookupInterval: config.lookupInterval || 10000,
+            addressRotation: config.addressRotation !== false,
+        }, { logger: this.app.logger });
+        const lookupFunction = this.dnsResolver.getLookupFunction();
+        this.app.config.httpclient = this.app.config.httpclient || {};
+        this.app.config.httpclient.lookup = lookupFunction;
+    }
+    configDidLoad() {
+        // Add dnsResolver to app
+        this.app.dnsResolver = this.dnsResolver;
+    }
+    async didLoad() {
+        await this.app.moduleHandler.ready();
+    }
+    beforeClose() {
+        // Cleanup DNS cache resources
+        this.dnsResolver.resetCache();
+    }
+}
+exports.default = DnsCacheAppHook;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiYXBwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQ0EsbURBQWdEO0FBRWhELE1BQXFCLGVBQWU7SUFJbEMsWUFBWSxHQUFnQjtRQUMxQixJQUFJLENBQUMsR0FBRyxHQUFHLEdBQUcsQ0FBQztJQUNqQixDQUFDO0lBRUQsY0FBYztRQUNaLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUM5QixJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQ2xCLDhFQUE4RSxDQUMvRSxDQUFDO1FBQ0osQ0FBQztRQUNELE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLFFBQVEsSUFBSSxFQUFFLENBQUM7UUFFOUMsK0JBQStCO1FBQy9CLE1BQU0sY0FBYyxHQUFHLE1BQU0sQ0FBQyxJQUFJLEtBQUssUUFBUSxDQUFDO1FBQ2hELElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSx5QkFBVyxDQUNoQztZQUNFLFdBQVcsRUFBRSxjQUFjO1lBQzNCLE9BQU8sRUFBRSxNQUFNLENBQUMsVUFBVTtZQUMxQixHQUFHLEVBQUUsTUFBTSxDQUFDLGNBQWMsSUFBSSxJQUFJO1lBQ2xDLHNCQUFzQixFQUFFLE1BQU0sQ0FBQyxjQUFjLElBQUksS0FBSztZQUN0RCxlQUFlLEVBQUUsTUFBTSxDQUFDLGVBQWUsS0FBSyxLQUFLO1NBQ2xELEVBQ0QsRUFBRSxNQUFNLEVBQUUsSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsQ0FDNUIsQ0FBQztRQUNGLE1BQU0sY0FBYyxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztRQUM1RCxJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsVUFBVSxJQUFJLEVBQUUsQ0FBQztRQUM5RCxJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxHQUFHLGNBQWMsQ0FBQztJQUNyRCxDQUFDO0lBRUQsYUFBYTtRQUNYLHlCQUF5QjtRQUN6QixJQUFJLENBQUMsR0FBRyxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDO0lBQzFDLENBQUM7SUFFRCxLQUFLLENBQUMsT0FBTztRQUNYLE1BQU0sSUFBSSxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDdkMsQ0FBQztJQUVELFdBQVc7UUFDVCw4QkFBOEI7UUFDOUIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxVQUFVLEVBQUUsQ0FBQztJQUNoQyxDQUFDO0NBQ0Y7QUE5Q0Qsa0NBOENDIn0=

package/config/config.default.d.ts

@@ -0,0 +1,26 @@
+/**
+ * DNS Cache Configuration
+ *
+ * The DNS cache plugin provides DNS caching and resolution capabilities to improve performance
+ * by caching DNS lookups and supports both dns.lookup and dns.resolve modes with address rotation.
+ *
+ * @property {'lookup' | 'resolve'} mode - Use dns.lookup or dns.resolve, default is 'resolve'.
+ *   - lookup: Use dns.lookup mode (old behavior), respects system DNS configuration and /etc/hosts, but does not support ttl.
+ *   - resolve: Use dns.resolve mode (new feature), queries DNS servers directly, ttl supported.
+ *     Note: When using resolve mode, /etc/hosts is not respected. You may need to implement custom logic
+ *     if you want to include /etc/hosts resolution.
+ * @property {Number} maxCacheLength - Maximum number of DNS cache entries, default is 1000.
+ *   Uses LRU (Least Recently Used) algorithm to evict old entries when cache is full.
+ * @property {Number} lookupInterval - Only works when mode is 'lookup'. DNS cache lookup interval in milliseconds, default is 10000 (10 seconds).
+ * @property {Boolean} addressRotation - Enable round-robin address rotation when multiple IP addresses
+ *   are returned for a hostname, default is true. Helps distribute load across multiple servers.
+ * @property {Array<String>} dnsServers - Custom DNS nameservers for dns.resolve mode, e.g. ['8.8.8.8', '1.1.1.1'].
+ *   Only effective when mode is 'resolve'. If not set, uses system default DNS servers.
+ */
+export declare const dnsCache: {
+    mode: "lookup" | "resolve";
+    maxCacheLength: number;
+    lookupInterval: number;
+    addressRotation: boolean;
+    dnsServers: string[] | undefined;
+};

package/config/config.default.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * DNS Cache Configuration
+ *
+ * The DNS cache plugin provides DNS caching and resolution capabilities to improve performance
+ * by caching DNS lookups and supports both dns.lookup and dns.resolve modes with address rotation.
+ *
+ * @property {'lookup' | 'resolve'} mode - Use dns.lookup or dns.resolve, default is 'resolve'.
+ *   - lookup: Use dns.lookup mode (old behavior), respects system DNS configuration and /etc/hosts, but does not support ttl.
+ *   - resolve: Use dns.resolve mode (new feature), queries DNS servers directly, ttl supported.
+ *     Note: When using resolve mode, /etc/hosts is not respected. You may need to implement custom logic
+ *     if you want to include /etc/hosts resolution.
+ * @property {Number} maxCacheLength - Maximum number of DNS cache entries, default is 1000.
+ *   Uses LRU (Least Recently Used) algorithm to evict old entries when cache is full.
+ * @property {Number} lookupInterval - Only works when mode is 'lookup'. DNS cache lookup interval in milliseconds, default is 10000 (10 seconds).
+ * @property {Boolean} addressRotation - Enable round-robin address rotation when multiple IP addresses
+ *   are returned for a hostname, default is true. Helps distribute load across multiple servers.
+ * @property {Array<String>} dnsServers - Custom DNS nameservers for dns.resolve mode, e.g. ['8.8.8.8', '1.1.1.1'].
+ *   Only effective when mode is 'resolve'. If not set, uses system default DNS servers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dnsCache = void 0;
+exports.dnsCache = {
+    mode: 'resolve',
+    maxCacheLength: 1000,
+    lookupInterval: 10000,
+    addressRotation: true,
+    dnsServers: undefined,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmRlZmF1bHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjb25maWcuZGVmYXVsdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQWtCRzs7O0FBRVUsUUFBQSxRQUFRLEdBQUc7SUFDdEIsSUFBSSxFQUFFLFNBQWlDO0lBQ3ZDLGNBQWMsRUFBRSxJQUFJO0lBQ3BCLGNBQWMsRUFBRSxLQUFLO0lBQ3JCLGVBQWUsRUFBRSxJQUFJO0lBQ3JCLFVBQVUsRUFBRSxTQUFpQztDQUM5QyxDQUFDIn0=

package/lib/DnsResolver.d.ts

@@ -0,0 +1,97 @@
+import * as dns from 'node:dns';
+import { LRU } from 'ylru';
+import { EggLogger } from 'egg';
+import { LookupAddress } from 'node:dns';
+export interface DnsResolverOptions {
+    useResolver?: boolean;
+    max?: number;
+    dnsCacheLookupInterval?: number;
+    servers?: string[];
+    addressRotation?: boolean;
+}
+export interface DnsCacheRecord {
+    ip: string;
+    family: number;
+    ttl: number;
+    timestamp: number;
+    index: number;
+}
+export declare class DnsResolver {
+    private _maxCacheSize;
+    private _dnsCache;
+    private useResolver;
+    private dnsCacheLookupInterval;
+    private enableAddressRotation;
+    private resolver?;
+    private _resolve4?;
+    private _lookup?;
+    logger: EggLogger;
+    /**
+     * Create a DNS cache resolver instance
+     * @param options - Configuration options
+     * @param options.useResolver - enable dns.resolver, otherwise use dns.lookup by default
+     * @param options.max - Maximum cache size, default is 1000
+     * @param options.dnsCacheLookupInterval - DNS cache lookup interval in milliseconds, effective when useResolver == false, default is 10000
+     * @param options.servers - Custom DNS nameservers, effective when useResolver == true, e.g. ['8.8.8.8', '1.1.1.1']
+     * @param options.addressRotation - Enable address rotation for both lookup and resolve modes, default is true
+     */
+    constructor(options: DnsResolverOptions | undefined, args: {
+        logger: EggLogger;
+    });
+    get maxCacheSize(): number;
+    private _debugLog;
+    resetCacheSize(size: number): void;
+    /**
+     * Initialize DNS resolver with custom nameservers if provided
+     * @param defaultServers - Custom DNS nameservers
+     * @private
+     */
+    private _initializeResolver;
+    /**
+     * Get the lookup function compatible with dns.lookup signature
+     */
+    getLookupFunction(): typeof dns.lookup;
+    /**
+     * This method may throw error if there is dns query in progress!
+     * @throws Error
+     * @param {string[]} servers eg. ['8.8.8.8']
+     */
+    setServers(servers: string[]): void;
+    getDnsCache(): LRU;
+    /**
+     * Callback with record, handling rotation
+     * @param record - DNS record with rotation state
+     * @param options - Lookup options
+     * @param callback - Callback function
+     * @private
+     */
+    private _callbackWithRecord;
+    lookup(hostname: string): Promise<LookupAddress[]>;
+    resolve4(hostname: string): Promise<dns.RecordWithTtl[]>;
+    /**
+     * Update DNS cache with fresh resolution
+     * Supports both dns.lookup and dns.resolve modes
+     * @param hostname - The hostname to resolve
+     * @private
+     */
+    private _updateDNS;
+    /**
+     * Debug DNS errors
+     * @param err - Error object
+     * @param mode - 'lookup' or 'resolve'
+     * @private
+     */
+    private _errorDNS;
+    /**
+     * Clear the DNS cache
+     * @param recreate - Whether to recreate the cache instance, default is false.
+     *   If true, creates a new LRU instance even if cache already exists.
+     */
+    resetCache(recreate?: boolean): void;
+    /**
+     * Get a specific hostname's single record from cache
+     * @param hostname - Hostname to query
+     * @return {DnsCacheRecord | null} cache record
+     */
+    getCacheRecord(hostname: string): DnsCacheRecord | null;
+}

package/lib/DnsResolver.js

@@ -0,0 +1,346 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DnsResolver = void 0;
+const util = __importStar(require("node:util"));
+const dns = __importStar(require("node:dns"));
+const ylru_1 = require("ylru");
+const IP_REGEX = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+class DnsResolver {
+    /**
+     * Create a DNS cache resolver instance
+     * @param options - Configuration options
+     * @param options.useResolver - enable dns.resolver, otherwise use dns.lookup by default
+     * @param options.max - Maximum cache size, default is 1000
+     * @param options.dnsCacheLookupInterval - DNS cache lookup interval in milliseconds, effective when useResolver == false, default is 10000
+     * @param options.servers - Custom DNS nameservers, effective when useResolver == true, e.g. ['8.8.8.8', '1.1.1.1']
+     * @param options.addressRotation - Enable address rotation for both lookup and resolve modes, default is true
+     */
+    constructor(options = {}, args) {
+        this._maxCacheSize = options.max || 1000;
+        this._dnsCache = new ylru_1.LRU(this._maxCacheSize);
+        this.logger = args.logger;
+        // Set useResolver before using it
+        this.useResolver = options.useResolver === true;
+        this.dnsCacheLookupInterval = options.dnsCacheLookupInterval || 10000;
+        // Address rotation is enabled by default
+        this.enableAddressRotation = options.addressRotation !== false;
+        if (this.useResolver) {
+            this._initializeResolver(options.servers);
+        }
+        else {
+            // Use dns.lookup mode (old behavior)
+            this._lookup = util.promisify(dns.lookup);
+        }
+        this.resetCache = this.resetCache.bind(this);
+        this.logger.debug(`[dns-cache] DNS Resolver initialized in ${this.useResolver ? 'resolve' : 'lookup'} mode, maxCacheSize: ${this._maxCacheSize}, addressRotation: ${this.enableAddressRotation}`);
+    }
+    get maxCacheSize() {
+        return this._maxCacheSize;
+    }
+    _debugLog(msg, ...args) {
+        this.logger.debug.apply(this.logger, [msg, ...args]);
+    }
+    resetCacheSize(size) {
+        this._maxCacheSize = size;
+        this.resetCache(true);
+    }
+    /**
+     * Initialize DNS resolver with custom nameservers if provided
+     * @param defaultServers - Custom DNS nameservers
+     * @private
+     */
+    _initializeResolver(defaultServers) {
+        this.resolver = new dns.Resolver({
+            timeout: 3000,
+            tries: 2,
+        });
+        const hasDefaultServers = defaultServers &&
+            Array.isArray(defaultServers) &&
+            defaultServers.length > 0;
+        if (hasDefaultServers) {
+            this.resolver.setServers(defaultServers);
+            this._debugLog(`[dns-cache] Custom DNS servers configured: ${defaultServers.join(', ')}`);
+        }
+        this._resolve4 = util.promisify(this.resolver.resolve4.bind(this.resolver));
+    }
+    /**
+     * Get the lookup function compatible with dns.lookup signature
+     */
+    getLookupFunction() {
+        return ((hostname, options, callback) => {
+            // signature handling: lookup(hostname, cb) or lookup(hostname, options, cb)
+            if (typeof options === 'function') {
+                callback = options;
+                options = {};
+            }
+            if (typeof options === 'number') {
+                options = { family: options };
+            }
+            if (typeof callback !== 'function') {
+                throw new TypeError('callback must be a function');
+            }
+            options = options || {};
+            if (!options.family) {
+                options.family = 4;
+            }
+            // keep original dns.lookup behavior for literal IPs without hitting the network
+            if (IP_REGEX.test(hostname)) {
+                // theoretically this code will never be reached because urllib will
+                // directly return for literal IPs before calling lookup function
+                const family = typeof options.family === 'number' ? options.family : 4;
+                this.logger.debug(`[dns-cache] literal IP ${hostname} lookup, bypassing cache`);
+                if (options === null || options === void 0 ? void 0 : options.all) {
+                    return callback(null, [{ address: hostname, family }]);
+                }
+                return callback(null, hostname, family);
+            }
+            const record = this._dnsCache.get(hostname);
+            const now = Date.now();
+            if (record) {
+                // Check TTL - use the first record's TTL and timestamp
+                const firstRecord = record.records[0];
+                const ttl = firstRecord.ttl || 0;
+                const timestamp = firstRecord.timestamp || now;
+                if (now - timestamp >= ttl) {
+                    // refresh in background, keep serving cached value
+                    this._debugLog(`[dns-cache] Cache TTL expired for ${hostname}, refreshing in background. Age: ${now - timestamp}ms, TTL: ${ttl}ms`);
+                    this._updateDNS(hostname).catch(() => {
+                        // do nothing, error already logged in _updateDNS
+                    });
+                }
+                else {
+                    this._debugLog(`[dns-cache] Cache hit for ${hostname}, remaining TTL: ${ttl - (now - timestamp)}ms, records: ${record.records.length}`);
+                }
+                return this._callbackWithRecord(record, options, callback);
+            }
+            // No cached record, resolve and respond when ready
+            this._debugLog(`[dns-cache] Cache miss for ${hostname}, resolving...`);
+            this._updateDNS(hostname)
+                .then(record => {
+                this._callbackWithRecord(record, options, callback);
+            })
+                .catch(err => {
+                callback(err, '');
+            });
+        });
+    }
+    /**
+     * This method may throw error if there is dns query in progress!
+     * @throws Error
+     * @param {string[]} servers eg. ['8.8.8.8']
+     */
+    setServers(servers) {
+        if (this.resolver) {
+            this.resolver.setServers(servers);
+        }
+        else {
+            this.logger.warn('[dns-cache] Cannot set DNS servers when useResolver is false');
+        }
+    }
+    getDnsCache() {
+        return this._dnsCache;
+    }
+    /**
+     * Callback with record, handling rotation
+     * @param record - DNS record with rotation state
+     * @param options - Lookup options
+     * @param callback - Callback function
+     * @private
+     */
+    _callbackWithRecord(record, options, callback) {
+        // All records use the unified structure with rotation
+        if (record.records && Array.isArray(record.records)) {
+            const records = record.records;
+            const currentRecord = records[record.currentIndex % records.length];
+            if (records.length > 1) {
+                this._debugLog(`[dns-cache] Address rotation: using ${currentRecord.ip} (index ${record.currentIndex % records.length}/${records.length})`);
+            }
+            // Rotate to next address for next call (if enabled)
+            if (this.enableAddressRotation) {
+                record.currentIndex = (record.currentIndex + 1) % records.length;
+            }
+            if (options.all) {
+                return callback(null, [
+                    { address: currentRecord.ip, family: currentRecord.family || 4 },
+                ]);
+            }
+            return callback(null, currentRecord.ip, currentRecord.family || 4);
+        }
+        // Should not reach here, all records should use records structure
+        throw new Error('[dns_cache_error]: Invalid cache record structure');
+    }
+    async lookup(hostname) {
+        // handle localhost (some name servers may not resolve it)
+        if (hostname === 'localhost') {
+            this.logger.debug('[dns-cache] localhost lookup, bypassing cache');
+            return [{ address: '127.0.0.1', family: 4 }];
+        }
+        if (!this._lookup) {
+            throw new Error('DNS Resolver not initialized for lookup mode');
+        }
+        // Use { all: true } to get all addresses for rotation support
+        const addresses = await this._lookup(hostname, {
+            family: 4,
+            all: true,
+        });
+        return addresses;
+    }
+    async resolve4(hostname) {
+        // handle localhost (some name servers may not resolve it)
+        if (hostname === 'localhost') {
+            this.logger.debug('[dns-cache] localhost resolve, bypassing cache');
+            return [
+                {
+                    address: '127.0.0.1',
+                    ttl: Math.floor(Number.MAX_SAFE_INTEGER / 1000),
+                },
+            ]; // provide a default TTL
+        }
+        if (!this._resolve4) {
+            throw new Error('DNS Resolver not initialized for resolve mode');
+        }
+        const addresses = await this._resolve4(hostname, {
+            ttl: true,
+        });
+        return addresses;
+    }
+    /**
+     * Update DNS cache with fresh resolution
+     * Supports both dns.lookup and dns.resolve modes
+     * @param hostname - The hostname to resolve
+     * @private
+     */
+    async _updateDNS(hostname) {
+        // Use dns.lookup
+        if (!this.useResolver) {
+            try {
+                const addresses = await this.lookup(hostname);
+                const addressArray = Array.isArray(addresses) ? addresses : [addresses];
+                if (addressArray.length === 0) {
+                    throw new Error(`empty address for ${hostname}`);
+                }
+                const records = addressArray.map((addr, index) => ({
+                    ip: addr.address,
+                    family: addr.family || 4,
+                    ttl: this.dnsCacheLookupInterval,
+                    timestamp: Date.now(),
+                    index,
+                }));
+                const cacheEntry = {
+                    records,
+                    currentIndex: 0,
+                };
+                this._dnsCache.set(hostname, cacheEntry);
+                this._debugLog(`[dns-cache] dns.lookup succeeded for ${hostname}, resolved ${records.length} address(es): ${records.map(r => r.ip).join(', ')}, TTL: ${this.dnsCacheLookupInterval}ms`);
+                return cacheEntry;
+            }
+            catch (err) {
+                this._errorDNS(err, 'lookup', hostname);
+                throw err;
+            }
+        }
+        // Use dns.resolve
+        try {
+            const addresses = await this.resolve4(hostname);
+            const addressArray = Array.isArray(addresses) ? addresses : [addresses];
+            // Store all addresses with rotation index
+            const records = addressArray.map((addr, index) => {
+                const address = typeof addr === 'string' ? addr : addr.address;
+                const ttlSeconds = addr && Number.isInteger(addr.ttl) && addr.ttl >= 0 ? addr.ttl : 0;
+                return {
+                    ip: address,
+                    family: 4,
+                    ttl: ttlSeconds * 1000,
+                    timestamp: Date.now(),
+                    index,
+                };
+            });
+            if (records.length === 0 || !records[0].ip) {
+                throw new Error(`empty address for ${hostname}`);
+            }
+            // Store all records with rotation state
+            const cacheEntry = {
+                records,
+                currentIndex: 0,
+            };
+            this._dnsCache.set(hostname, cacheEntry);
+            this._debugLog(`[dns-cache] dns.resolve4 succeeded for ${hostname}, resolved ${records.length} address(es): ${records
+                .map(r => `${r.ip} (TTL: ${r.ttl}ms)`)
+                .join(', ')}`);
+            return cacheEntry;
+        }
+        catch (err) {
+            this._errorDNS(err, 'resolve', hostname);
+            throw err;
+        }
+    }
+    /**
+     * Debug DNS errors
+     * @param err - Error object
+     * @param mode - 'lookup' or 'resolve'
+     * @private
+     */
+    _errorDNS(err, mode, hostname) {
+        this.logger.error(`error occurred when resolving ${hostname} with dns.${mode}: ${err && err.message ? err.message : err}`);
+    }
+    /**
+     * Clear the DNS cache
+     * @param recreate - Whether to recreate the cache instance, default is false.
+     *   If true, creates a new LRU instance even if cache already exists.
+     */
+    resetCache(recreate = false) {
+        this._debugLog(`[dns-cache] Resetting DNS cache (recreate: ${recreate})`);
+        if (this._dnsCache)
+            this._dnsCache.reset();
+        if (recreate) {
+            this._dnsCache = new ylru_1.LRU(this._maxCacheSize);
+        }
+    }
+    /**
+     * Get a specific hostname's single record from cache
+     * @param hostname - Hostname to query
+     * @return {DnsCacheRecord | null} cache record
+     */
+    getCacheRecord(hostname) {
+        const entry = this._dnsCache.get(hostname);
+        if (entry && entry.records && Array.isArray(entry.records)) {
+            return entry.records[entry.currentIndex % entry.records.length];
+        }
+        return null;
+    }
+}
+exports.DnsResolver = DnsResolver;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DnsResolver.js","sourceRoot":"","sources":["DnsResolver.ts"],"names":[],"mappings":"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"}

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './DnsResolver';

package/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DnsResolver"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsZ0RBQThCIn0=

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@eggjs/tegg-dns-cache",
+  "eggPlugin": {
+    "name": "dnsCache",
+    "dependencies": [
+      "tegg"
+    ]
+  },
+  "version": "3.68.0",
+  "types": "typings/index.d.ts",
+  "description": "tegg dns cache plugin",
+  "keywords": [
+    "egg",
+    "typescript",
+    "dns",
+    "cache",
+    "tegg"
+  ],
+  "files": [
+    "app.js",
+    "app.d.ts",
+    "agent.js",
+    "agent.d.ts",
+    "index.js",
+    "index.d.ts",
+    "types.js",
+    "types.d.ts",
+    "config/**/*.js",
+    "config/**/*.d.ts",
+    "lib/**/*.js",
+    "lib/**/*.d.ts",
+    "app/**/*.js",
+    "app/**/*.d.ts",
+    "typings/*.d.ts"
+  ],
+  "eggModule": {
+    "name": "teggDnsCache"
+  },
+  "scripts": {
+    "test": "cross-env NODE_ENV=test NODE_OPTIONS='--no-deprecation' mocha",
+    "clean": "tsc -b --clean",
+    "tsc": "ut run clean && tsc -p ./tsconfig.json",
+    "tsc:pub": "ut run clean && tsc -p ./tsconfig.pub.json",
+    "prepublishOnly": "ut tsc:pub"
+  },
+  "homepage": "https://github.com/eggjs/tegg",
+  "bugs": {
+    "url": "https://github.com/eggjs/tegg/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:eggjs/tegg.git",
+    "directory": "plugin/dns-cache"
+  },
+  "egg": {
+    "typescript": true
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "egg": ">=3.32.0"
+  },
+  "dependencies": {
+    "@eggjs/tegg": "^3.68.0",
+    "ylru": "^2.0.0"
+  },
+  "devDependencies": {
+    "@eggjs/tegg-config": "^3.68.0",
+    "@eggjs/tegg-plugin": "^3.68.0",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^20.2.4",
+    "cross-env": "^7.0.3",
+    "egg": "^3.32.0",
+    "egg-mock": "^5.5.0",
+    "mocha": "^10.2.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "c8c089bee4aaf48ccdea3d56d142c82044223ae3"
+}

package/typings/index.d.ts

@@ -0,0 +1,34 @@
+import 'egg';
+import '@eggjs/tegg-plugin';
+import * as dns from 'node:dns';
+import { DnsResolver, DnsCacheRecord } from '../lib';
+export { DnsResolver, DnsCacheRecord };
+
+declare module 'egg' {
+  interface TeggDnsCacheApplication {
+    /**
+     * DNS resolver instance, provides DNS caching capabilities
+     */
+    dnsResolver: DnsResolver;
+  }
+
+  interface Application extends TeggDnsCacheApplication {}
+
+  interface EggAppConfig {
+    /**
+     * DNS Cache Configuration
+     */
+    dnsCache: {
+      /** Use dns.lookup or dns.resolve, default is 'resolve' */
+      mode?: 'lookup' | 'resolve';
+      /** Custom DNS nameservers for dns.resolve mode */
+      dnsServers?: string[];
+      /** Maximum number of DNS cache entries, default is 1000 */
+      maxCacheLength?: number;
+      /** DNS cache lookup interval in milliseconds, default is 10000 */
+      lookupInterval?: number;
+      /** Enable round-robin address rotation, default is true */
+      addressRotation?: boolean;
+    };
+  }
+}