@yxw007/translate 0.0.2 → 0.0.3

package/dist/node/index.cjs

@@ -1,4 +1,4 @@
-// translate v0.0.2 Copyright (c) 2024 Potter<aa4790139@gmail.com> and contributors
+// translate v0.0.3 Copyright (c) 2024 Potter<aa4790139@gmail.com> and contributors
 'use strict';
 
 Object.defineProperty(exports, '__esModule', { value: true });
@@ -742,16 +742,6 @@ const resolveEndpoint = (ruleSetObject, options) => {
         }
     }
     const endpoint = evaluateRules(rules, { endpointParams, logger, referenceRecord: {} });
-    if (options.endpointParams?.Endpoint) {
-        try {
-            const givenEndpoint = new URL(options.endpointParams.Endpoint);
-            const { protocol, port } = givenEndpoint;
-            endpoint.url.protocol = protocol;
-            endpoint.url.port = port;
-        }
-        catch (e) {
-        }
-    }
     options.logger?.debug?.(`${debugId} Resolved endpoint: ${toDebugString(endpoint)}`);
     return endpoint;
 };
@@ -1726,7 +1716,7 @@ const getEndpointUrlConfig = (serviceId) => ({
     default: undefined,
 });
 
-const getEndpointFromConfig = async (serviceId) => loadConfig(getEndpointUrlConfig(serviceId))();
+const getEndpointFromConfig = async (serviceId) => loadConfig(getEndpointUrlConfig(serviceId ?? ""))();
 
 function parseQueryString(querystring) {
     const query = {};
@@ -1782,7 +1772,13 @@ const toEndpointV1 = (endpoint) => {
 
 const getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => {
     if (!clientConfig.endpoint) {
-        const endpointFromConfig = await getEndpointFromConfig(clientConfig.serviceId || "");
+        let endpointFromConfig;
+        if (clientConfig.serviceConfiguredEndpoint) {
+            endpointFromConfig = await clientConfig.serviceConfiguredEndpoint();
+        }
+        else {
+            endpointFromConfig = await getEndpointFromConfig(clientConfig.serviceId);
+        }
         if (endpointFromConfig) {
             clientConfig.endpoint = () => Promise.resolve(toEndpointV1(endpointFromConfig));
         }
@@ -1936,7 +1932,7 @@ const resolveEndpointConfig = (input) => {
     const { endpoint } = input;
     const customEndpointProvider = endpoint != null ? async () => toEndpointV1(await normalizeProvider$1(endpoint)()) : undefined;
     const isCustomEndpoint = !!endpoint;
-    return {
+    const resolvedConfig = {
         ...input,
         endpoint: customEndpointProvider,
         tls,
@@ -1944,6 +1940,14 @@ const resolveEndpointConfig = (input) => {
         useDualstackEndpoint: normalizeProvider$1(input.useDualstackEndpoint ?? false),
         useFipsEndpoint: normalizeProvider$1(input.useFipsEndpoint ?? false),
     };
+    let configuredEndpointPromise = undefined;
+    resolvedConfig.serviceConfiguredEndpoint = async () => {
+        if (input.serviceId && !configuredEndpointPromise) {
+            configuredEndpointPromise = getEndpointFromConfig(input.serviceId);
+        }
+        return configuredEndpointPromise;
+    };
+    return resolvedConfig;
 };
 
 const httpAuthSchemeEndpointRuleSetMiddlewareOptions = {
@@ -2667,13 +2671,31 @@ const priorityWeights = {
 
 class Client {
     constructor(config) {
-        this.middlewareStack = constructStack();
         this.config = config;
+        this.middlewareStack = constructStack();
     }
     send(command, optionsOrCb, cb) {
         const options = typeof optionsOrCb !== "function" ? optionsOrCb : undefined;
         const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
-        const handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
+        const useHandlerCache = options === undefined && this.config.cacheMiddleware === true;
+        let handler;
+        if (useHandlerCache) {
+            if (!this.handlers) {
+                this.handlers = new WeakMap();
+            }
+            const handlers = this.handlers;
+            if (handlers.has(command.constructor)) {
+                handler = handlers.get(command.constructor);
+            }
+            else {
+                handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
+                handlers.set(command.constructor, handler);
+            }
+        }
+        else {
+            delete this.handlers;
+            handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
+        }
         if (callback) {
             handler(command)
                 .then((result) => callback(null, result.output), (err) => callback(err))
@@ -2684,8 +2706,8 @@ class Client {
         }
     }
     destroy() {
-        if (this.config.requestHandler.destroy)
-            this.config.requestHandler.destroy();
+        this.config?.requestHandler?.destroy?.();
+        delete this.handlers;
     }
 }
 
@@ -2822,42 +2844,77 @@ const getTransformedHeaders = (headers) => {
     return transformedHeaders;
 };
 
+const DEFER_EVENT_LISTENER_TIME$2 = 1000;
 const setConnectionTimeout = (request, reject, timeoutInMs = 0) => {
     if (!timeoutInMs) {
-        return;
-    }
-    const timeoutId = setTimeout(() => {
-        request.destroy();
-        reject(Object.assign(new Error(`Socket timed out without establishing a connection within ${timeoutInMs} ms`), {
-            name: "TimeoutError",
-        }));
-    }, timeoutInMs);
-    request.on("socket", (socket) => {
-        if (socket.connecting) {
-            socket.on("connect", () => {
+        return -1;
+    }
+    const registerTimeout = (offset) => {
+        const timeoutId = setTimeout(() => {
+            request.destroy();
+            reject(Object.assign(new Error(`Socket timed out without establishing a connection within ${timeoutInMs} ms`), {
+                name: "TimeoutError",
+            }));
+        }, timeoutInMs - offset);
+        const doWithSocket = (socket) => {
+            if (socket?.connecting) {
+                socket.on("connect", () => {
+                    clearTimeout(timeoutId);
+                });
+            }
+            else {
                 clearTimeout(timeoutId);
-            });
+            }
+        };
+        if (request.socket) {
+            doWithSocket(request.socket);
         }
         else {
-            clearTimeout(timeoutId);
+            request.on("socket", doWithSocket);
         }
-    });
+    };
+    if (timeoutInMs < 2000) {
+        registerTimeout(0);
+        return 0;
+    }
+    return setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME$2), DEFER_EVENT_LISTENER_TIME$2);
 };
 
-const setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }) => {
+const DEFER_EVENT_LISTENER_TIME$1 = 3000;
+const setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME$1) => {
     if (keepAlive !== true) {
-        return;
+        return -1;
     }
-    request.on("socket", (socket) => {
-        socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
-    });
+    const registerListener = () => {
+        if (request.socket) {
+            request.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+        }
+        else {
+            request.on("socket", (socket) => {
+                socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+            });
+        }
+    };
+    if (deferTimeMs === 0) {
+        registerListener();
+        return 0;
+    }
+    return setTimeout(registerListener, deferTimeMs);
 };
 
+const DEFER_EVENT_LISTENER_TIME = 3000;
 const setSocketTimeout = (request, reject, timeoutInMs = 0) => {
-    request.setTimeout(timeoutInMs, () => {
-        request.destroy();
-        reject(Object.assign(new Error(`Connection timed out after ${timeoutInMs} ms`), { name: "TimeoutError" }));
-    });
+    const registerTimeout = (offset) => {
+        request.setTimeout(timeoutInMs - offset, () => {
+            request.destroy();
+            reject(Object.assign(new Error(`Connection timed out after ${timeoutInMs} ms`), { name: "TimeoutError" }));
+        });
+    };
+    if (0 < timeoutInMs && timeoutInMs < 6000) {
+        registerTimeout(0);
+        return 0;
+    }
+    return setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
 };
 
 const MIN_WAIT_TIME = 1000;
@@ -2988,17 +3045,17 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         if (!this.config) {
             this.config = await this.configProvider;
         }
-        let socketCheckTimeoutId;
         return new Promise((_resolve, _reject) => {
             let writeRequestBodyPromise = undefined;
+            const timeouts = [];
             const resolve = async (arg) => {
                 await writeRequestBodyPromise;
-                clearTimeout(socketCheckTimeoutId);
+                timeouts.forEach(clearTimeout);
                 _resolve(arg);
             };
             const reject = async (arg) => {
                 await writeRequestBodyPromise;
-                clearTimeout(socketCheckTimeoutId);
+                timeouts.forEach(clearTimeout);
                 _reject(arg);
             };
             if (!this.config) {
@@ -3012,10 +3069,10 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             }
             const isSSL = request.protocol === "https:";
             const agent = isSSL ? this.config.httpsAgent : this.config.httpAgent;
-            socketCheckTimeoutId = setTimeout(() => {
+            timeouts.push(setTimeout(() => {
                 this.socketWarningTimestamp = NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, this.config.logger);
             }, this.config.socketAcquisitionWarningTimeout ??
-                (this.config.requestTimeout ?? 2000) + (this.config.connectionTimeout ?? 1000));
+                (this.config.requestTimeout ?? 2000) + (this.config.connectionTimeout ?? 1000)));
             const queryString = buildQueryString(request.query || {});
             let auth = undefined;
             if (request.username != null || request.password != null) {
@@ -3057,8 +3114,6 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
                     reject(err);
                 }
             });
-            setConnectionTimeout(req, reject, this.config.connectionTimeout);
-            setSocketTimeout(req, reject, this.config.requestTimeout);
             if (abortSignal) {
                 const onAbort = () => {
                     req.destroy();
@@ -3075,15 +3130,17 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
                     abortSignal.onabort = onAbort;
                 }
             }
+            timeouts.push(setConnectionTimeout(req, reject, this.config.connectionTimeout));
+            timeouts.push(setSocketTimeout(req, reject, this.config.requestTimeout));
             const httpAgent = nodeHttpsOptions.agent;
             if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
-                setSocketKeepAlive(req, {
+                timeouts.push(setSocketKeepAlive(req, {
                     keepAlive: httpAgent.keepAlive,
                     keepAliveMsecs: httpAgent.keepAliveMsecs,
-                });
+                }));
             }
             writeRequestBodyPromise = writeRequestBody(req, request, this.config.requestTimeout).catch((e) => {
-                clearTimeout(socketCheckTimeoutId);
+                timeouts.forEach(clearTimeout);
                 return _reject(e);
             });
         });