@aws-sdk/util-dns 3.972.16 → 3.972.17

package/dist-cjs/index.js

@@ -1,3 +1,266 @@
-var __exportStar = (m, e) => { Object.assign(e, m); };
-__exportStar(require("./HostResolver"), exports);
-__exportStar(require("./NodeDnsLookupHostResolver"), exports);
+const { HostAddressType } = require("@aws-sdk/types");
+const { promises, V4MAPPED, ALL } = require("dns");
+
+class HostAddressEntryCollection {
+    data = [];
+    get length() {
+        return this.data.length;
+    }
+    cycle(collection) {
+        if (this.data.length === 0) {
+            throw new Error("Cannot cycle an empty collection");
+        }
+        const entry = this.data.shift();
+        (collection || this).append(entry);
+        return entry;
+    }
+    append(entry) {
+        this.data.push(entry);
+    }
+    remove(entry) {
+        if (this.length === 0) {
+            throw new Error("Cannot remove from an empty collection");
+        }
+        const index = this.data.findIndex((e) => e.address === entry.address);
+        const removedEntry = this.data[index];
+        this.data.splice(index, 1);
+        return removedEntry;
+    }
+    [Symbol.iterator]() {
+        return this.data[Symbol.iterator]();
+    }
+}
+
+class HostEntry {
+    aaaaRecords;
+    aRecords;
+    failedAaaaRecords;
+    failedARecords;
+    nextTimestampToUpdateMs;
+    constructor(nextTimestampToProcessMs) {
+        this.aaaaRecords = new HostAddressEntryCollection();
+        this.aRecords = new HostAddressEntryCollection();
+        this.failedAaaaRecords = new HostAddressEntryCollection();
+        this.failedARecords = new HostAddressEntryCollection();
+        this.nextTimestampToUpdateMs = nextTimestampToProcessMs;
+    }
+    updateRecords(addresses, expirationTtlMs) {
+        this.nextTimestampToUpdateMs = expirationTtlMs;
+        const addressesToAppend = [];
+        for (const freshAddress of addresses) {
+            const hostAddressEntry = this.findAddress(freshAddress);
+            if (hostAddressEntry !== undefined) {
+                hostAddressEntry.expirationTtlMs = expirationTtlMs;
+                continue;
+            }
+            addressesToAppend.push(freshAddress);
+        }
+        for (const addressToAppend of addressesToAppend) {
+            const hostAddressEntry = this.findAddress(addressToAppend);
+            if (hostAddressEntry !== undefined) {
+                continue;
+            }
+            const successRecords = this.getGoodRecords(addressToAppend);
+            successRecords.append(Object.assign(addressToAppend, {
+                expirationTtlMs,
+            }));
+        }
+    }
+    processRecords() {
+        this.processRecordsAddressType(this.aRecords, this.failedARecords);
+        this.processRecordsAddressType(this.aaaaRecords, this.failedAaaaRecords);
+    }
+    failAddressInRecords(address) {
+        const successRecords = this.getGoodRecords(address);
+        const failedRecords = this.getFailedRecords(address);
+        const recordsToRemove = [];
+        for (const hostAddressEntry of successRecords) {
+            if (hostAddressEntry.address === address.address) {
+                recordsToRemove.push(hostAddressEntry);
+                failedRecords.append(hostAddressEntry);
+            }
+        }
+        for (const recordToRemove of recordsToRemove) {
+            successRecords.remove(recordToRemove);
+        }
+    }
+    findAddress(address) {
+        const successRecords = this.getGoodRecords(address);
+        for (const hostAddressEntry of successRecords) {
+            if (address.address === hostAddressEntry.address) {
+                return hostAddressEntry;
+            }
+        }
+        const failedRecords = this.getFailedRecords(address);
+        for (const hostAddressEntry of failedRecords) {
+            if (address.address === hostAddressEntry.address) {
+                return hostAddressEntry;
+            }
+        }
+        return undefined;
+    }
+    processRecordsAddressType(successRecords, failedRecords) {
+        const successRecordsToRemove = [];
+        let successIndex = 0;
+        for (const hostAddressEntry of successRecords) {
+            if (successIndex === successRecords.length - 1) {
+                break;
+            }
+            if (Date.now() >= hostAddressEntry.expirationTtlMs) {
+                successRecordsToRemove.push(hostAddressEntry);
+            }
+            successIndex++;
+        }
+        for (const recordToRemove of successRecordsToRemove) {
+            successRecords.remove(recordToRemove);
+        }
+        const failedRecordsToRemove = [];
+        let failedIndex = 0;
+        for (const hostAddressEntry of failedRecords) {
+            if (failedIndex === failedRecords.length - 1) {
+                break;
+            }
+            if (Date.now() >= hostAddressEntry.expirationTtlMs) {
+                failedRecordsToRemove.push(hostAddressEntry);
+            }
+            failedIndex++;
+        }
+        for (const recordToRemove of failedRecordsToRemove) {
+            failedRecords.remove(recordToRemove);
+        }
+        if (successRecords.length === 0) {
+            let hostAddressEntryToPromote = undefined;
+            for (const hostAddressEntry of failedRecords) {
+                if (Date.now() >= hostAddressEntry.expirationTtlMs) {
+                    continue;
+                }
+                hostAddressEntryToPromote = hostAddressEntry;
+                break;
+            }
+            if (hostAddressEntryToPromote !== undefined) {
+                failedRecords.remove(hostAddressEntryToPromote);
+                successRecords.append(hostAddressEntryToPromote);
+            }
+        }
+    }
+    getGoodRecords(address) {
+        return address.addressType === HostAddressType.AAAA ? this.aaaaRecords : this.aRecords;
+    }
+    getFailedRecords(address) {
+        return address.addressType === HostAddressType.AAAA ? this.failedAaaaRecords : this.failedARecords;
+    }
+}
+
+class HostEntryTable {
+    map;
+    constructor() {
+        this.map = new Map();
+    }
+    set(args, addresses, nextTimestampToProcessMs) {
+        const hostEntry = new HostEntry(nextTimestampToProcessMs);
+        hostEntry.updateRecords(addresses, nextTimestampToProcessMs);
+        this.map.set(args.hostName, hostEntry);
+    }
+    get(hostName) {
+        return this.map.get(hostName);
+    }
+    delete(hostName) {
+        this.map.delete(hostName);
+    }
+    clear() {
+        this.map.clear();
+    }
+    get size() {
+        return this.map.size;
+    }
+}
+
+const NODE_DNS_FAMILY_TO_HOST_ADDRESS_TYPE = {
+    4: HostAddressType.A,
+    6: HostAddressType.AAAA,
+};
+const DNS_LOOKUP_OPTIONS = {
+    all: true,
+    hints: V4MAPPED | ALL,
+    verbatim: true,
+};
+class NodeDnsLookupHostResolver {
+    static DEFAULT_TTL_MS = 30_000;
+    static createDefaultCacheProvider = () => new HostEntryTable();
+    static DEFAULT_NODE_DNS_LOOKUP = promises.lookup;
+    ttlMs;
+    cache;
+    nodeDnsLookup;
+    constructor({ ttlMs = NodeDnsLookupHostResolver.DEFAULT_TTL_MS, cache = NodeDnsLookupHostResolver.createDefaultCacheProvider(), nodeDnsLookup = NodeDnsLookupHostResolver.DEFAULT_NODE_DNS_LOOKUP, } = {}) {
+        this.ttlMs = ttlMs;
+        this.cache = cache;
+        this.nodeDnsLookup = nodeDnsLookup;
+    }
+    async resolveAddress(args) {
+        const possibleHostEntry = this.cache.get(args.hostName);
+        const newNextTimestampToUpdateMs = Date.now() + this.ttlMs;
+        if (possibleHostEntry === undefined) {
+            const addresses = await this.nodeDnsLookupResolveAddress(args);
+            this.cache.set(args, addresses, newNextTimestampToUpdateMs);
+        }
+        const hostEntry = this.cache.get(args.hostName);
+        if (possibleHostEntry !== undefined && Date.now() >= hostEntry.nextTimestampToUpdateMs) {
+            try {
+                const addresses = await this.nodeDnsLookupResolveAddress(args);
+                hostEntry.updateRecords(addresses, newNextTimestampToUpdateMs);
+            }
+            catch (error) {
+                console.error(`Could not update DNS address cache for "${args.hostName}": ${error}`);
+            }
+        }
+        hostEntry.processRecords();
+        const result = [];
+        if (hostEntry.aRecords.length > 0) {
+            result.push(hostEntry.aRecords.cycle());
+        }
+        if (hostEntry.aaaaRecords.length > 0) {
+            result.push(hostEntry.aaaaRecords.cycle());
+        }
+        if (result.length === 0) {
+            throw new Error(`Could not resolve addresses for "${args.hostName}"`);
+        }
+        return result;
+    }
+    reportFailureOnAddress(addr) {
+        const hostEntry = this.cache.get(addr.hostName);
+        if (hostEntry === undefined) {
+            throw new Error(`Could not find cached host name "${addr.hostName}"`);
+        }
+        hostEntry.failAddressInRecords(addr);
+    }
+    purgeCache(args) {
+        if (args?.hostName) {
+            this.cache.delete(args.hostName);
+        }
+        else {
+            this.cache.clear();
+        }
+    }
+    async nodeDnsLookupResolveAddress(args) {
+        const addresses = [];
+        const ipEntries = await this.nodeDnsLookup(args.hostName, DNS_LOOKUP_OPTIONS);
+        for (const { address, family } of ipEntries) {
+            const addressType = NODE_DNS_FAMILY_TO_HOST_ADDRESS_TYPE[family];
+            if (addressType === undefined) {
+                throw new Error(`dns.lookup() Node DNS family \`${family}\` is not supported`);
+            }
+            addresses.push({
+                addressType,
+                address,
+                hostName: args.hostName,
+                service: args.service,
+            });
+        }
+        return addresses;
+    }
+}
+
+const HostResolver = NodeDnsLookupHostResolver;
+
+exports.HostResolver = HostResolver;
+exports.NodeDnsLookupHostResolver = NodeDnsLookupHostResolver;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/util-dns",
-  "version": "3.972.16",
+  "version": "3.972.17",
   "description": "Implementations of DNS host resolvers.",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -27,7 +27,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/types": "^3.973.13",
+    "@aws-sdk/types": "^3.973.14",
     "tslib": "^2.6.2"
   },
   "devDependencies": {
@@ -66,9 +66,6 @@
   "react-native": {
     "./dist-es/index": "./dist-es/index.browser",
     "./dist-es/HostResolver": "./dist-es/HostResolver.browser",
-    "./dist-es/NodeDnsLookupHostResolver": false,
-    "./dist-cjs/index": "./dist-cjs/index.browser",
-    "./dist-cjs/HostResolver": "./dist-cjs/HostResolver.browser",
-    "./dist-cjs/NodeDnsLookupHostResolver": false
+    "./dist-es/NodeDnsLookupHostResolver": false
   }
 }

package/dist-cjs/HostResolver.browser.js

@@ -1,7 +0,0 @@
-exports.HostResolver = class HostResolver {
-    async resolveAddress(args) {
-        return [];
-    }
-    reportFailureOnAddress(addr) { }
-    purgeCache(args) { }
-};

package/dist-cjs/HostResolver.js

@@ -1,2 +0,0 @@
-const { NodeDnsLookupHostResolver } = require("./NodeDnsLookupHostResolver");
-exports.HostResolver = NodeDnsLookupHostResolver;

package/dist-cjs/NodeDnsLookupHostResolver.js

@@ -1,87 +0,0 @@
-const { HostAddressType } = require("@aws-sdk/types");
-const { ALL, promises: dnsPromises, V4MAPPED } = require("dns");
-const { HostEntryTable } = require("./util/HostEntryTable");
-const NODE_DNS_FAMILY_TO_HOST_ADDRESS_TYPE = {
-    4: HostAddressType.A,
-    6: HostAddressType.AAAA,
-};
-const DNS_LOOKUP_OPTIONS = {
-    all: true,
-    hints: V4MAPPED | ALL,
-    verbatim: true,
-};
-exports.NodeDnsLookupHostResolver = class NodeDnsLookupHostResolver {
-    static DEFAULT_TTL_MS = 30_000;
-    static createDefaultCacheProvider = () => new HostEntryTable();
-    static DEFAULT_NODE_DNS_LOOKUP = dnsPromises.lookup;
-    ttlMs;
-    cache;
-    nodeDnsLookup;
-    constructor({ ttlMs = NodeDnsLookupHostResolver.DEFAULT_TTL_MS, cache = NodeDnsLookupHostResolver.createDefaultCacheProvider(), nodeDnsLookup = NodeDnsLookupHostResolver.DEFAULT_NODE_DNS_LOOKUP, } = {}) {
-        this.ttlMs = ttlMs;
-        this.cache = cache;
-        this.nodeDnsLookup = nodeDnsLookup;
-    }
-    async resolveAddress(args) {
-        const possibleHostEntry = this.cache.get(args.hostName);
-        const newNextTimestampToUpdateMs = Date.now() + this.ttlMs;
-        if (possibleHostEntry === undefined) {
-            const addresses = await this.nodeDnsLookupResolveAddress(args);
-            this.cache.set(args, addresses, newNextTimestampToUpdateMs);
-        }
-        const hostEntry = this.cache.get(args.hostName);
-        if (possibleHostEntry !== undefined && Date.now() >= hostEntry.nextTimestampToUpdateMs) {
-            try {
-                const addresses = await this.nodeDnsLookupResolveAddress(args);
-                hostEntry.updateRecords(addresses, newNextTimestampToUpdateMs);
-            }
-            catch (error) {
-                console.error(`Could not update DNS address cache for "${args.hostName}": ${error}`);
-            }
-        }
-        hostEntry.processRecords();
-        const result = [];
-        if (hostEntry.aRecords.length > 0) {
-            result.push(hostEntry.aRecords.cycle());
-        }
-        if (hostEntry.aaaaRecords.length > 0) {
-            result.push(hostEntry.aaaaRecords.cycle());
-        }
-        if (result.length === 0) {
-            throw new Error(`Could not resolve addresses for "${args.hostName}"`);
-        }
-        return result;
-    }
-    reportFailureOnAddress(addr) {
-        const hostEntry = this.cache.get(addr.hostName);
-        if (hostEntry === undefined) {
-            throw new Error(`Could not find cached host name "${addr.hostName}"`);
-        }
-        hostEntry.failAddressInRecords(addr);
-    }
-    purgeCache(args) {
-        if (args?.hostName) {
-            this.cache.delete(args.hostName);
-        }
-        else {
-            this.cache.clear();
-        }
-    }
-    async nodeDnsLookupResolveAddress(args) {
-        const addresses = [];
-        const ipEntries = await this.nodeDnsLookup(args.hostName, DNS_LOOKUP_OPTIONS);
-        for (const { address, family } of ipEntries) {
-            const addressType = NODE_DNS_FAMILY_TO_HOST_ADDRESS_TYPE[family];
-            if (addressType === undefined) {
-                throw new Error(`dns.lookup() Node DNS family \`${family}\` is not supported`);
-            }
-            addresses.push({
-                addressType,
-                address,
-                hostName: args.hostName,
-                service: args.service,
-            });
-        }
-        return addresses;
-    }
-};

package/dist-cjs/index.browser.js

@@ -1,2 +0,0 @@
-var __exportStar = (m, e) => { Object.assign(e, m); };
-__exportStar(require("./HostResolver"), exports);

package/dist-cjs/util/HostAddressEntryCollection.js

@@ -1,29 +0,0 @@
-exports.HostAddressEntryCollection = class HostAddressEntryCollection {
-    data = [];
-    get length() {
-        return this.data.length;
-    }
-    cycle(collection) {
-        if (this.data.length === 0) {
-            throw new Error("Cannot cycle an empty collection");
-        }
-        const entry = this.data.shift();
-        (collection || this).append(entry);
-        return entry;
-    }
-    append(entry) {
-        this.data.push(entry);
-    }
-    remove(entry) {
-        if (this.length === 0) {
-            throw new Error("Cannot remove from an empty collection");
-        }
-        const index = this.data.findIndex((e) => e.address === entry.address);
-        const removedEntry = this.data[index];
-        this.data.splice(index, 1);
-        return removedEntry;
-    }
-    [Symbol.iterator]() {
-        return this.data[Symbol.iterator]();
-    }
-};

package/dist-cjs/util/HostEntry.js

@@ -1,121 +0,0 @@
-const { HostAddressType } = require("@aws-sdk/types");
-const { HostAddressEntryCollection } = require("./HostAddressEntryCollection");
-exports.HostEntry = class HostEntry {
-    aaaaRecords;
-    aRecords;
-    failedAaaaRecords;
-    failedARecords;
-    nextTimestampToUpdateMs;
-    constructor(nextTimestampToProcessMs) {
-        this.aaaaRecords = new HostAddressEntryCollection();
-        this.aRecords = new HostAddressEntryCollection();
-        this.failedAaaaRecords = new HostAddressEntryCollection();
-        this.failedARecords = new HostAddressEntryCollection();
-        this.nextTimestampToUpdateMs = nextTimestampToProcessMs;
-    }
-    updateRecords(addresses, expirationTtlMs) {
-        this.nextTimestampToUpdateMs = expirationTtlMs;
-        const addressesToAppend = [];
-        for (const freshAddress of addresses) {
-            const hostAddressEntry = this.findAddress(freshAddress);
-            if (hostAddressEntry !== undefined) {
-                hostAddressEntry.expirationTtlMs = expirationTtlMs;
-                continue;
-            }
-            addressesToAppend.push(freshAddress);
-        }
-        for (const addressToAppend of addressesToAppend) {
-            const hostAddressEntry = this.findAddress(addressToAppend);
-            if (hostAddressEntry !== undefined) {
-                continue;
-            }
-            const successRecords = this.getGoodRecords(addressToAppend);
-            successRecords.append(Object.assign(addressToAppend, {
-                expirationTtlMs,
-            }));
-        }
-    }
-    processRecords() {
-        this.processRecordsAddressType(this.aRecords, this.failedARecords);
-        this.processRecordsAddressType(this.aaaaRecords, this.failedAaaaRecords);
-    }
-    failAddressInRecords(address) {
-        const successRecords = this.getGoodRecords(address);
-        const failedRecords = this.getFailedRecords(address);
-        const recordsToRemove = [];
-        for (const hostAddressEntry of successRecords) {
-            if (hostAddressEntry.address === address.address) {
-                recordsToRemove.push(hostAddressEntry);
-                failedRecords.append(hostAddressEntry);
-            }
-        }
-        for (const recordToRemove of recordsToRemove) {
-            successRecords.remove(recordToRemove);
-        }
-    }
-    findAddress(address) {
-        const successRecords = this.getGoodRecords(address);
-        for (const hostAddressEntry of successRecords) {
-            if (address.address === hostAddressEntry.address) {
-                return hostAddressEntry;
-            }
-        }
-        const failedRecords = this.getFailedRecords(address);
-        for (const hostAddressEntry of failedRecords) {
-            if (address.address === hostAddressEntry.address) {
-                return hostAddressEntry;
-            }
-        }
-        return undefined;
-    }
-    processRecordsAddressType(successRecords, failedRecords) {
-        const successRecordsToRemove = [];
-        let successIndex = 0;
-        for (const hostAddressEntry of successRecords) {
-            if (successIndex === successRecords.length - 1) {
-                break;
-            }
-            if (Date.now() >= hostAddressEntry.expirationTtlMs) {
-                successRecordsToRemove.push(hostAddressEntry);
-            }
-            successIndex++;
-        }
-        for (const recordToRemove of successRecordsToRemove) {
-            successRecords.remove(recordToRemove);
-        }
-        const failedRecordsToRemove = [];
-        let failedIndex = 0;
-        for (const hostAddressEntry of failedRecords) {
-            if (failedIndex === failedRecords.length - 1) {
-                break;
-            }
-            if (Date.now() >= hostAddressEntry.expirationTtlMs) {
-                failedRecordsToRemove.push(hostAddressEntry);
-            }
-            failedIndex++;
-        }
-        for (const recordToRemove of failedRecordsToRemove) {
-            failedRecords.remove(recordToRemove);
-        }
-        if (successRecords.length === 0) {
-            let hostAddressEntryToPromote = undefined;
-            for (const hostAddressEntry of failedRecords) {
-                if (Date.now() >= hostAddressEntry.expirationTtlMs) {
-                    continue;
-                }
-                hostAddressEntryToPromote = hostAddressEntry;
-                break;
-            }
-            if (hostAddressEntryToPromote !== undefined) {
-                failedRecords.remove(hostAddressEntryToPromote);
-                successRecords.append(hostAddressEntryToPromote);
-            }
-        }
-    }
-    getGoodRecords(address) {
-        return address.addressType === HostAddressType.AAAA ? this.aaaaRecords : this.aRecords;
-    }
-    getFailedRecords(address) {
-        return address.addressType === HostAddressType.AAAA ? this.failedAaaaRecords : this.failedARecords;
-    }
-};

package/dist-cjs/util/HostEntryTable.js

@@ -1,24 +0,0 @@
-const { HostEntry } = require("./HostEntry");
-exports.HostEntryTable = class HostEntryTable {
-    map;
-    constructor() {
-        this.map = new Map();
-    }
-    set(args, addresses, nextTimestampToProcessMs) {
-        const hostEntry = new HostEntry(nextTimestampToProcessMs);
-        hostEntry.updateRecords(addresses, nextTimestampToProcessMs);
-        this.map.set(args.hostName, hostEntry);
-    }
-    get(hostName) {
-        return this.map.get(hostName);
-    }
-    delete(hostName) {
-        this.map.delete(hostName);
-    }
-    clear() {
-        this.map.clear();
-    }
-    get size() {
-        return this.map.size;
-    }
-};