@ndlib/ndlib-cdk2 1.0.13 → 1.0.14

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-cjs/write-request-body.js

@@ -2,14 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeRequestBody = void 0;
 const stream_1 = require("stream");
-function writeRequestBody(httpRequest, request) {
-    const expect = request.headers["Expect"] || request.headers["expect"];
+const MIN_WAIT_TIME = 1000;
+async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME) {
+    var _a;
+    const headers = (_a = request.headers) !== null && _a !== void 0 ? _a : {};
+    const expect = headers["Expect"] || headers["expect"];
+    let timeoutId = -1;
+    let hasError = false;
     if (expect === "100-continue") {
-        httpRequest.on("continue", () => {
-            writeBody(httpRequest, request.body);
-        });
+        await Promise.race([
+            new Promise((resolve) => {
+                timeoutId = Number(setTimeout(resolve, Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+            }),
+            new Promise((resolve) => {
+                httpRequest.on("continue", () => {
+                    clearTimeout(timeoutId);
+                    resolve();
+                });
+                httpRequest.on("error", () => {
+                    hasError = true;
+                    clearTimeout(timeoutId);
+                    resolve();
+                });
+            }),
+        ]);
     }
-    else {
+    if (!hasError) {
         writeBody(httpRequest, request.body);
     }
 }

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-es/node-http-handler.js

@@ -5,8 +5,10 @@ import { Agent as hsAgent, request as hsRequest } from "https";
 import { NODEJS_TIMEOUT_ERROR_CODES } from "./constants";
 import { getTransformedHeaders } from "./get-transformed-headers";
 import { setConnectionTimeout } from "./set-connection-timeout";
+import { setSocketKeepAlive } from "./set-socket-keep-alive";
 import { setSocketTimeout } from "./set-socket-timeout";
 import { writeRequestBody } from "./write-request-body";
+export const DEFAULT_REQUEST_TIMEOUT = 0;
 export class NodeHttpHandler {
     constructor(options) {
         this.metadata = { handlerProtocol: "http/1.1" };
@@ -24,12 +26,12 @@ export class NodeHttpHandler {
         });
     }
     resolveDefaultConfig(options) {
-        const { connectionTimeout, socketTimeout, httpAgent, httpsAgent } = options || {};
+        const { requestTimeout, connectionTimeout, socketTimeout, httpAgent, httpsAgent } = options || {};
         const keepAlive = true;
         const maxSockets = 50;
         return {
             connectionTimeout,
-            socketTimeout,
+            requestTimeout: requestTimeout ?? socketTimeout,
             httpAgent: httpAgent || new hAgent({ keepAlive, maxSockets }),
             httpsAgent: httpsAgent || new hsAgent({ keepAlive, maxSockets }),
         };
@@ -42,7 +44,16 @@ export class NodeHttpHandler {
         if (!this.config) {
             this.config = await this.configProvider;
         }
-        return new Promise((resolve, reject) => {
+        return new Promise((_resolve, _reject) => {
+            let writeRequestBodyPromise = undefined;
+            const resolve = async (arg) => {
+                await writeRequestBodyPromise;
+                _resolve(arg);
+            };
+            const reject = async (arg) => {
+                await writeRequestBodyPromise;
+                _reject(arg);
+            };
             if (!this.config) {
                 throw new Error("Node HTTP request handler config is not resolved");
             }
@@ -54,18 +65,33 @@ export class NodeHttpHandler {
             }
             const isSSL = request.protocol === "https:";
             const queryString = buildQueryString(request.query || {});
+            let auth = undefined;
+            if (request.username != null || request.password != null) {
+                const username = request.username ?? "";
+                const password = request.password ?? "";
+                auth = `${username}:${password}`;
+            }
+            let path = request.path;
+            if (queryString) {
+                path += `?${queryString}`;
+            }
+            if (request.fragment) {
+                path += `#${request.fragment}`;
+            }
             const nodeHttpsOptions = {
                 headers: request.headers,
                 host: request.hostname,
                 method: request.method,
-                path: queryString ? `${request.path}?${queryString}` : request.path,
+                path,
                 port: request.port,
                 agent: isSSL ? this.config.httpsAgent : this.config.httpAgent,
+                auth,
             };
             const requestFunc = isSSL ? hsRequest : hRequest;
             const req = requestFunc(nodeHttpsOptions, (res) => {
                 const httpResponse = new HttpResponse({
                     statusCode: res.statusCode || -1,
+                    reason: res.statusMessage,
                     headers: getTransformedHeaders(res.headers),
                     body: res,
                 });
@@ -80,7 +106,7 @@ export class NodeHttpHandler {
                 }
             });
             setConnectionTimeout(req, reject, this.config.connectionTimeout);
-            setSocketTimeout(req, reject, this.config.socketTimeout);
+            setSocketTimeout(req, reject, this.config.requestTimeout);
             if (abortSignal) {
                 abortSignal.onabort = () => {
                     req.abort();
@@ -89,7 +115,14 @@ export class NodeHttpHandler {
                     reject(abortError);
                 };
             }
-            writeRequestBody(req, request);
+            const httpAgent = nodeHttpsOptions.agent;
+            if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
+                setSocketKeepAlive(req, {
+                    keepAlive: httpAgent.keepAlive,
+                    keepAliveMsecs: httpAgent.keepAliveMsecs,
+                });
+            }
+            writeRequestBodyPromise = writeRequestBody(req, request, this.config.requestTimeout).catch(_reject);
         });
     }
 }

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-es/node-http2-connection-manager.js

@@ -0,0 +1,86 @@
+import http2 from "http2";
+import { NodeHttp2ConnectionPool } from "./node-http2-connection-pool";
+export class NodeHttp2ConnectionManager {
+    constructor(config) {
+        this.sessionCache = new Map();
+        this.config = config;
+        if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) {
+            throw new RangeError("maxConcurrency must be greater than zero.");
+        }
+    }
+    lease(requestContext, connectionConfiguration) {
+        const url = this.getUrlString(requestContext);
+        const existingPool = this.sessionCache.get(url);
+        if (existingPool) {
+            const existingSession = existingPool.poll();
+            if (existingSession && !this.config.disableConcurrency) {
+                return existingSession;
+            }
+        }
+        const session = http2.connect(url);
+        if (this.config.maxConcurrency) {
+            session.settings({ maxConcurrentStreams: this.config.maxConcurrency }, (err) => {
+                if (err) {
+                    throw new Error("Fail to set maxConcurrentStreams to " +
+                        this.config.maxConcurrency +
+                        "when creating new session for " +
+                        requestContext.destination.toString());
+                }
+            });
+        }
+        session.unref();
+        const destroySessionCb = () => {
+            session.destroy();
+            this.deleteSession(url, session);
+        };
+        session.on("goaway", destroySessionCb);
+        session.on("error", destroySessionCb);
+        session.on("frameError", destroySessionCb);
+        session.on("close", () => this.deleteSession(url, session));
+        if (connectionConfiguration.requestTimeout) {
+            session.setTimeout(connectionConfiguration.requestTimeout, destroySessionCb);
+        }
+        const connectionPool = this.sessionCache.get(url) || new NodeHttp2ConnectionPool();
+        connectionPool.offerLast(session);
+        this.sessionCache.set(url, connectionPool);
+        return session;
+    }
+    deleteSession(authority, session) {
+        const existingConnectionPool = this.sessionCache.get(authority);
+        if (!existingConnectionPool) {
+            return;
+        }
+        if (!existingConnectionPool.contains(session)) {
+            return;
+        }
+        existingConnectionPool.remove(session);
+        this.sessionCache.set(authority, existingConnectionPool);
+    }
+    release(requestContext, session) {
+        const cacheKey = this.getUrlString(requestContext);
+        this.sessionCache.get(cacheKey)?.offerLast(session);
+    }
+    destroy() {
+        for (const [key, connectionPool] of this.sessionCache) {
+            for (const session of connectionPool) {
+                if (!session.destroyed) {
+                    session.destroy();
+                }
+                connectionPool.remove(session);
+            }
+            this.sessionCache.delete(key);
+        }
+    }
+    setMaxConcurrentStreams(maxConcurrentStreams) {
+        if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) {
+            throw new RangeError("maxConcurrentStreams must be greater than zero.");
+        }
+        this.config.maxConcurrency = maxConcurrentStreams;
+    }
+    setDisableConcurrentStreams(disableConcurrentStreams) {
+        this.config.disableConcurrency = disableConcurrentStreams;
+    }
+    getUrlString(request) {
+        return request.destination.toString();
+    }
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-es/node-http2-connection-pool.js

@@ -0,0 +1,32 @@
+export class NodeHttp2ConnectionPool {
+    constructor(sessions) {
+        this.sessions = [];
+        this.sessions = sessions ?? [];
+    }
+    poll() {
+        if (this.sessions.length > 0) {
+            return this.sessions.shift();
+        }
+    }
+    offerLast(session) {
+        this.sessions.push(session);
+    }
+    contains(session) {
+        return this.sessions.includes(session);
+    }
+    remove(session) {
+        this.sessions = this.sessions.filter((s) => s !== session);
+    }
+    [Symbol.iterator]() {
+        return this.sessions[Symbol.iterator]();
+    }
+    destroy(connection) {
+        for (const session of this.sessions) {
+            if (session === connection) {
+                if (!session.destroyed) {
+                    session.destroy();
+                }
+            }
+        }
+    }
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-es/node-http2-handler.js

@@ -1,11 +1,13 @@
 import { HttpResponse } from "@aws-sdk/protocol-http";
 import { buildQueryString } from "@aws-sdk/querystring-builder";
-import { connect, constants } from "http2";
+import { constants } from "http2";
 import { getTransformedHeaders } from "./get-transformed-headers";
+import { NodeHttp2ConnectionManager } from "./node-http2-connection-manager";
 import { writeRequestBody } from "./write-request-body";
 export class NodeHttp2Handler {
     constructor(options) {
         this.metadata = { handlerProtocol: "h2" };
+        this.connectionManager = new NodeHttp2ConnectionManager({});
         this.configProvider = new Promise((resolve, reject) => {
             if (typeof options === "function") {
                 options()
@@ -18,42 +20,68 @@ export class NodeHttp2Handler {
                 resolve(options || {});
             }
         });
-        this.sessionCache = new Map();
     }
     destroy() {
-        for (const sessions of this.sessionCache.values()) {
-            sessions.forEach((session) => this.destroySession(session));
-        }
-        this.sessionCache.clear();
+        this.connectionManager.destroy();
     }
     async handle(request, { abortSignal } = {}) {
         if (!this.config) {
             this.config = await this.configProvider;
+            this.connectionManager.setDisableConcurrentStreams(this.config.disableConcurrentStreams || false);
+            if (this.config.maxConcurrentStreams) {
+                this.connectionManager.setMaxConcurrentStreams(this.config.maxConcurrentStreams);
+            }
         }
         const { requestTimeout, disableConcurrentStreams } = this.config;
-        return new Promise((resolve, rejectOriginal) => {
+        return new Promise((_resolve, _reject) => {
             let fulfilled = false;
+            let writeRequestBodyPromise = undefined;
+            const resolve = async (arg) => {
+                await writeRequestBodyPromise;
+                _resolve(arg);
+            };
+            const reject = async (arg) => {
+                await writeRequestBodyPromise;
+                _reject(arg);
+            };
             if (abortSignal?.aborted) {
                 fulfilled = true;
                 const abortError = new Error("Request aborted");
                 abortError.name = "AbortError";
-                rejectOriginal(abortError);
+                reject(abortError);
                 return;
             }
-            const { hostname, method, port, protocol, path, query } = request;
-            const authority = `${protocol}//${hostname}${port ? `:${port}` : ""}`;
-            const session = this.getSession(authority, disableConcurrentStreams || false);
-            const reject = (err) => {
+            const { hostname, method, port, protocol, query } = request;
+            let auth = "";
+            if (request.username != null || request.password != null) {
+                const username = request.username ?? "";
+                const password = request.password ?? "";
+                auth = `${username}:${password}@`;
+            }
+            const authority = `${protocol}//${auth}${hostname}${port ? `:${port}` : ""}`;
+            const requestContext = { destination: new URL(authority) };
+            const session = this.connectionManager.lease(requestContext, {
+                requestTimeout: this.config?.sessionTimeout,
+                disableConcurrentStreams: disableConcurrentStreams || false,
+            });
+            const rejectWithDestroy = (err) => {
                 if (disableConcurrentStreams) {
                     this.destroySession(session);
                 }
                 fulfilled = true;
-                rejectOriginal(err);
+                reject(err);
             };
             const queryString = buildQueryString(query || {});
+            let path = request.path;
+            if (queryString) {
+                path += `?${queryString}`;
+            }
+            if (request.fragment) {
+                path += `#${request.fragment}`;
+            }
             const req = session.request({
                 ...request.headers,
-                [constants.HTTP2_HEADER_PATH]: queryString ? `${path}?${queryString}` : path,
+                [constants.HTTP2_HEADER_PATH]: path,
                 [constants.HTTP2_HEADER_METHOD]: method,
             });
             session.ref();
@@ -67,7 +95,7 @@ export class NodeHttp2Handler {
                 resolve({ response: httpResponse });
                 if (disableConcurrentStreams) {
                     session.close();
-                    this.deleteSessionFromCache(authority, session);
+                    this.connectionManager.deleteSession(authority, session);
                 }
             });
             if (requestTimeout) {
@@ -75,7 +103,7 @@ export class NodeHttp2Handler {
                     req.close();
                     const timeoutError = new Error(`Stream timed out because of no activity for ${requestTimeout} ms`);
                     timeoutError.name = "TimeoutError";
-                    reject(timeoutError);
+                    rejectWithDestroy(timeoutError);
                 });
             }
             if (abortSignal) {
@@ -83,15 +111,15 @@ export class NodeHttp2Handler {
                     req.close();
                     const abortError = new Error("Request aborted");
                     abortError.name = "AbortError";
-                    reject(abortError);
+                    rejectWithDestroy(abortError);
                 };
             }
             req.on("frameError", (type, code, id) => {
-                reject(new Error(`Frame type id ${type} in stream id ${id} has failed with code ${code}.`));
+                rejectWithDestroy(new Error(`Frame type id ${type} in stream id ${id} has failed with code ${code}.`));
             });
-            req.on("error", reject);
+            req.on("error", rejectWithDestroy);
             req.on("aborted", () => {
-                reject(new Error(`HTTP/2 stream is abnormally aborted in mid-communication with result code ${req.rstCode}.`));
+                rejectWithDestroy(new Error(`HTTP/2 stream is abnormally aborted in mid-communication with result code ${req.rstCode}.`));
             });
             req.on("close", () => {
                 session.unref();
@@ -99,44 +127,15 @@ export class NodeHttp2Handler {
                     session.destroy();
                 }
                 if (!fulfilled) {
-                    reject(new Error("Unexpected error: http2 request did not get a response"));
+                    rejectWithDestroy(new Error("Unexpected error: http2 request did not get a response"));
                 }
             });
-            writeRequestBody(req, request);
+            writeRequestBodyPromise = writeRequestBody(req, request, requestTimeout);
         });
     }
-    getSession(authority, disableConcurrentStreams) {
-        const sessionCache = this.sessionCache;
-        const existingSessions = sessionCache.get(authority) || [];
-        if (existingSessions.length > 0 && !disableConcurrentStreams)
-            return existingSessions[0];
-        const newSession = connect(authority);
-        newSession.unref();
-        const destroySessionCb = () => {
-            this.destroySession(newSession);
-            this.deleteSessionFromCache(authority, newSession);
-        };
-        newSession.on("goaway", destroySessionCb);
-        newSession.on("error", destroySessionCb);
-        newSession.on("frameError", destroySessionCb);
-        newSession.on("close", () => this.deleteSessionFromCache(authority, newSession));
-        if (this.config?.sessionTimeout) {
-            newSession.setTimeout(this.config.sessionTimeout, destroySessionCb);
-        }
-        existingSessions.push(newSession);
-        sessionCache.set(authority, existingSessions);
-        return newSession;
-    }
     destroySession(session) {
         if (!session.destroyed) {
             session.destroy();
         }
     }
-    deleteSessionFromCache(authority, session) {
-        const existingSessions = this.sessionCache.get(authority) || [];
-        if (!existingSessions.includes(session)) {
-            return;
-        }
-        this.sessionCache.set(authority, existingSessions.filter((s) => s !== session));
-    }
 }

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-es/set-connection-timeout.js

@@ -2,17 +2,20 @@ export 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) {
-            const timeoutId = setTimeout(() => {
-                request.destroy();
-                reject(Object.assign(new Error(`Socket timed out without establishing a connection within ${timeoutInMs} ms`), {
-                    name: "TimeoutError",
-                }));
-            }, timeoutInMs);
             socket.on("connect", () => {
                 clearTimeout(timeoutId);
             });
         }
+        else {
+            clearTimeout(timeoutId);
+        }
     });
 };

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-es/set-socket-keep-alive.js

@@ -0,0 +1,8 @@
+export const setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }) => {
+    if (keepAlive !== true) {
+        return;
+    }
+    request.on("socket", (socket) => {
+        socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+    });
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-es/write-request-body.js

@@ -1,12 +1,29 @@
 import { Readable } from "stream";
-export function writeRequestBody(httpRequest, request) {
-    const expect = request.headers["Expect"] || request.headers["expect"];
+const MIN_WAIT_TIME = 1000;
+export async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME) {
+    const headers = request.headers ?? {};
+    const expect = headers["Expect"] || headers["expect"];
+    let timeoutId = -1;
+    let hasError = false;
     if (expect === "100-continue") {
-        httpRequest.on("continue", () => {
-            writeBody(httpRequest, request.body);
-        });
+        await Promise.race([
+            new Promise((resolve) => {
+                timeoutId = Number(setTimeout(resolve, Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+            }),
+            new Promise((resolve) => {
+                httpRequest.on("continue", () => {
+                    clearTimeout(timeoutId);
+                    resolve();
+                });
+                httpRequest.on("error", () => {
+                    hasError = true;
+                    clearTimeout(timeoutId);
+                    resolve();
+                });
+            }),
+        ]);
     }
-    else {
+    if (!hasError) {
         writeBody(httpRequest, request.body);
     }
 }

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-types/node-http-handler.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { HttpHandler, HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
 import { HttpHandlerOptions, Provider } from "@aws-sdk/types";
 import { Agent as hAgent } from "http";
@@ -10,9 +11,18 @@ export interface NodeHttpHandlerOptions {
     /**
      * The maximum time in milliseconds that the connection phase of a request
      * may take before the connection attempt is abandoned.
+     *
+     * Defaults to 0, which disables the timeout.
      */
     connectionTimeout?: number;
     /**
+     * The number of milliseconds a request can take before automatically being terminated.
+     * Defaults to 0, which disables the timeout.
+     */
+    requestTimeout?: number;
+    /**
+     * @deprecated Use {@link requestTimeout}
+     *
      * The maximum time in milliseconds that a socket may remain idle before it
      * is closed.
      */
@@ -20,6 +30,7 @@ export interface NodeHttpHandlerOptions {
     httpAgent?: hAgent;
     httpsAgent?: hsAgent;
 }
+export declare const DEFAULT_REQUEST_TIMEOUT = 0;
 export declare class NodeHttpHandler implements HttpHandler {
     private config?;
     private readonly configProvider;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-types/node-http2-connection-manager.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { RequestContext } from "@aws-sdk/types";
+import { ConnectConfiguration } from "@aws-sdk/types";
+import { ConnectionManager, ConnectionManagerConfiguration } from "@aws-sdk/types";
+import { ClientHttp2Session } from "http2";
+export declare class NodeHttp2ConnectionManager implements ConnectionManager<ClientHttp2Session> {
+    constructor(config: ConnectionManagerConfiguration);
+    private config;
+    private readonly sessionCache;
+    lease(requestContext: RequestContext, connectionConfiguration: ConnectConfiguration): ClientHttp2Session;
+    /**
+     * Delete a session from the connection pool.
+     * @param authority The authority of the session to delete.
+     * @param session The session to delete.
+     */
+    deleteSession(authority: string, session: ClientHttp2Session): void;
+    release(requestContext: RequestContext, session: ClientHttp2Session): void;
+    destroy(): void;
+    setMaxConcurrentStreams(maxConcurrentStreams: number): void;
+    setDisableConcurrentStreams(disableConcurrentStreams: boolean): void;
+    private getUrlString;
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-types/node-http2-connection-pool.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { ConnectionPool } from "@aws-sdk/types";
+import { ClientHttp2Session } from "http2";
+export declare class NodeHttp2ConnectionPool implements ConnectionPool<ClientHttp2Session> {
+    private sessions;
+    constructor(sessions?: ClientHttp2Session[]);
+    poll(): ClientHttp2Session | void;
+    offerLast(session: ClientHttp2Session): void;
+    contains(session: ClientHttp2Session): boolean;
+    remove(session: ClientHttp2Session): void;
+    [Symbol.iterator](): IterableIterator<ClientHttp2Session>;
+    destroy(connection: ClientHttp2Session): void;
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-types/node-http2-handler.d.ts

@@ -17,11 +17,18 @@ export interface NodeHttp2HandlerOptions {
     sessionTimeout?: number;
     /**
      * Disables processing concurrent streams on a ClientHttp2Session instance. When set
-     * to true, the handler will create a new session instance for each request to a URL.
+     * to true, a new session instance is created for each request to a URL.
      * **Default:** false.
      * https://nodejs.org/api/http2.html#http2_class_clienthttp2session
      */
     disableConcurrentStreams?: boolean;
+    /**
+     * Maximum number of concurrent Http2Stream instances per ClientHttp2Session. Each session
+     * may have up to 2^31-1 Http2Stream instances over its lifetime.
+     * This value must be greater than or equal to 0.
+     * https://nodejs.org/api/http2.html#class-http2stream
+     */
+    maxConcurrentStreams?: number;
 }
 export declare class NodeHttp2Handler implements HttpHandler {
     private config?;
@@ -29,29 +36,15 @@ export declare class NodeHttp2Handler implements HttpHandler {
     readonly metadata: {
         handlerProtocol: string;
     };
-    private sessionCache;
+    private readonly connectionManager;
     constructor(options?: NodeHttp2HandlerOptions | Provider<NodeHttp2HandlerOptions | void>);
     destroy(): void;
     handle(request: HttpRequest, { abortSignal }?: HttpHandlerOptions): Promise<{
         response: HttpResponse;
     }>;
-    /**
-     * Returns a session for the given URL.
-     *
-     * @param authority The URL to create a session for.
-     * @param disableConcurrentStreams If true, a new session will be created for each request.
-     * @returns A session for the given URL.
-     */
-    private getSession;
     /**
      * Destroys a session.
      * @param session The session to destroy.
      */
     private destroySession;
-    /**
-     * Delete a session from the connection pool.
-     * @param authority The authority of the session to delete.
-     * @param session The session to delete.
-     */
-    private deleteSessionFromCache;
 }

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-types/readable.mock.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Readable, ReadableOptions } from "stream";
 export interface ReadFromBuffersOptions extends ReadableOptions {
     buffers: Buffer[];

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-types/set-socket-keep-alive.d.ts

@@ -0,0 +1,6 @@
+import { ClientRequest } from "http";
+export interface SocketKeepAliveOptions {
+    keepAlive: boolean;
+    keepAliveMsecs?: number;
+}
+export declare const setSocketKeepAlive: (request: ClientRequest, { keepAlive, keepAliveMsecs }: SocketKeepAliveOptions) => void;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-types/stream-collector/collector.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Writable } from "stream";
 export declare class Collector extends Writable {
     readonly bufferedBytes: Buffer[];

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/node-http-handler/dist-types/stream-collector/readable.mock.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Readable, ReadableOptions } from "stream";
 export interface ReadFromBuffersOptions extends ReadableOptions {
     buffers: Buffer[];