@ndlib/ndlib-cdk2 1.0.24 → 1.0.26

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/dist-types/ts3.4/protocols/coercing-serializers.d.ts

@@ -0,0 +1,3 @@
+export declare const _toStr: (val: unknown) => string | undefined;
+export declare const _toBool: (val: unknown) => boolean | undefined;
+export declare const _toNum: (val: unknown) => number | undefined;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/dist-types/ts3.4/protocols/common.d.ts

@@ -0,0 +1,5 @@
+import { SerdeContext } from "@smithy/types";
+export declare const collectBodyString: (
+  streamBody: any,
+  context: SerdeContext
+) => Promise<string>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/dist-types/ts3.4/protocols/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./coercing-serializers";
+export * from "./json/awsExpectUnion";
+export * from "./json/parseJsonBody";
+export * from "./xml/parseXmlBody";

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/dist-types/ts3.4/protocols/json/awsExpectUnion.d.ts

@@ -0,0 +1,3 @@
+export declare const awsExpectUnion: (
+  value: unknown
+) => Record<string, any> | undefined;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/dist-types/ts3.4/protocols/json/parseJsonBody.d.ts

@@ -0,0 +1,13 @@
+import { HttpResponse, SerdeContext } from "@smithy/types";
+export declare const parseJsonBody: (
+  streamBody: any,
+  context: SerdeContext
+) => any;
+export declare const parseJsonErrorBody: (
+  errorBody: any,
+  context: SerdeContext
+) => Promise<any>;
+export declare const loadRestJsonErrorCode: (
+  output: HttpResponse,
+  data: any
+) => string | undefined;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/dist-types/ts3.4/protocols/xml/parseXmlBody.d.ts

@@ -0,0 +1,13 @@
+import { HttpResponse, SerdeContext } from "@smithy/types";
+export declare const parseXmlBody: (
+  streamBody: any,
+  context: SerdeContext
+) => any;
+export declare const parseXmlErrorBody: (
+  errorBody: any,
+  context: SerdeContext
+) => Promise<any>;
+export declare const loadRestXmlErrorCode: (
+  output: HttpResponse,
+  data: any
+) => string | undefined;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/integ/request-handlers/request-handlers.integ.spec.ts

@@ -0,0 +1,158 @@
+import { Kinesis } from "@aws-sdk/client-kinesis";
+import { S3 } from "@aws-sdk/client-s3";
+import { TranscribeStreaming } from "@aws-sdk/client-transcribe-streaming";
+import { WebSocketFetchHandler } from "@aws-sdk/middleware-websocket";
+import { XhrHttpHandler } from "@aws-sdk/xhr-http-handler";
+import { FetchHttpHandler } from "@smithy/fetch-http-handler";
+import { NodeHttp2Handler, NodeHttpHandler } from "@smithy/node-http-handler";
+import { Agent } from "https";
+
+describe("request handler initialization", () => {
+  describe("http", () => {
+    it("should init with instances", async () => {
+      let instance: NodeHttpHandler;
+      let agentInstance: Agent;
+      const client = new S3({
+        requestHandler: (instance = new NodeHttpHandler({
+          requestTimeout: 2_000,
+          httpsAgent: (agentInstance = new Agent({ maxSockets: 25 })),
+        })),
+      });
+      expect(client.config.requestHandler).toBe(instance);
+      (instance as any).config = await (instance as any).configProvider;
+      expect((instance as any).config.httpsAgent).toBe(agentInstance);
+      expect((instance as any).config.requestTimeout).toEqual(2_000);
+      expect(agentInstance.maxSockets).toEqual(25);
+    });
+    it("should init with Agent pass-through", async () => {
+      let instance: NodeHttpHandler;
+      const client = new S3({
+        requestHandler: (instance = new NodeHttpHandler({
+          requestTimeout: 2_000,
+          httpsAgent: { maxSockets: 25 },
+        })),
+      });
+      expect(client.config.requestHandler).toBe(instance);
+      (instance as any).config = await (instance as any).configProvider;
+      expect((instance as any).config.requestTimeout).toEqual(2_000);
+      expect((instance as any).config.httpsAgent.maxSockets).toEqual(25);
+    });
+    it("should init with ctor pass-through with Agent instance", async () => {
+      let agentInstance: Agent;
+      const client = new S3({
+        requestHandler: {
+          requestTimeout: 2_000,
+          httpsAgent: (agentInstance = new Agent({ maxSockets: 25 })),
+        },
+      });
+      expect(client.config.requestHandler).toBeInstanceOf(NodeHttpHandler);
+      const instance = client.config.requestHandler;
+      (instance as any).config = await (instance as any).configProvider;
+      expect((instance as any).config.httpsAgent).toBe(agentInstance);
+      expect((instance as any).config.requestTimeout).toEqual(2_000);
+      expect(agentInstance.maxSockets).toEqual(25);
+    });
+    it("should init with ctor and Agent pass-through", async () => {
+      const client = new S3({
+        requestHandler: {
+          requestTimeout: 2_000,
+          httpsAgent: {
+            maxSockets: 25,
+          },
+        },
+      });
+      expect(client.config.requestHandler).toBeInstanceOf(NodeHttpHandler);
+      const instance = client.config.requestHandler;
+      (instance as any).config = await (instance as any).configProvider;
+      expect((instance as any).config.httpsAgent).toBeInstanceOf(Agent);
+      const agentInstance = (instance as any).config.httpsAgent;
+      expect((instance as any).config.requestTimeout).toEqual(2_000);
+      expect(agentInstance.maxSockets).toEqual(25);
+    });
+  });
+
+  describe("http2", () => {
+    it("should init with instances", async () => {
+      let instance: NodeHttp2Handler;
+      const client = new Kinesis({
+        requestHandler: (instance = new NodeHttp2Handler({
+          requestTimeout: 2_000,
+        })),
+      });
+      expect(client.config.requestHandler).toBe(instance);
+      (instance as any).config = await (instance as any).configProvider;
+      expect((instance as any).config.requestTimeout).toEqual(2_000);
+    });
+    it("should init with ctor pass-through", async () => {
+      const client = new Kinesis({
+        requestHandler: {
+          requestTimeout: 2_000,
+        },
+      });
+      expect(client.config.requestHandler).toBeInstanceOf(NodeHttp2Handler);
+      const instance = client.config.requestHandler;
+      (instance as any).config = await (instance as any).configProvider;
+      expect((instance as any).config.requestTimeout).toEqual(2_000);
+    });
+  });
+
+  describe("fetch", () => {
+    it("should init with instances", async () => {
+      let instance: FetchHttpHandler;
+      const handler = FetchHttpHandler.create((instance = new FetchHttpHandler({ requestTimeout: 2_000 })));
+      expect(handler).toBe(instance);
+      expect((instance as any).config.requestTimeout).toEqual(2_000);
+    });
+    it("should init with ctor pass-through", async () => {
+      const handler = FetchHttpHandler.create({ requestTimeout: 2_000 });
+      expect(handler).toBeInstanceOf(FetchHttpHandler);
+      expect((handler as any).config.requestTimeout).toEqual(2_000);
+    });
+  });
+
+  describe("websocket", () => {
+    it("should init with instances", async () => {
+      let instance: WebSocketFetchHandler;
+      const handler = WebSocketFetchHandler.create(
+        (instance = new WebSocketFetchHandler({ connectionTimeout: 2_000 }))
+      );
+      const client = new TranscribeStreaming({
+        requestHandler: handler,
+      });
+      expect(client.config.requestHandler).toBe(instance);
+      expect(handler).toBe(instance);
+      expect((await (handler as any).configPromise).connectionTimeout).toEqual(2_000);
+    });
+    it("should init with ctor pass-through", async () => {
+      const handler = WebSocketFetchHandler.create({ connectionTimeout: 2_000 });
+      const client = new TranscribeStreaming({
+        requestHandler: handler,
+      });
+      expect(client.config.requestHandler).toBe(handler);
+      expect(handler).toBeInstanceOf(WebSocketFetchHandler);
+      expect((await (handler as any).configPromise).connectionTimeout).toEqual(2_000);
+    });
+  });
+
+  describe("xhr", () => {
+    it("should init with instances", async () => {
+      let instance: XhrHttpHandler;
+      const handler = XhrHttpHandler.create((instance = new XhrHttpHandler({ requestTimeout: 2_000 })));
+      const client = new S3({
+        requestHandler: instance,
+      });
+      expect(client.config.requestHandler).toBe(handler);
+      expect(handler).toBe(instance);
+      expect((handler as any).config.requestTimeout).toEqual(2_000);
+    });
+    it("should init with ctor pass-through", async () => {
+      const handler = XhrHttpHandler.create({ requestTimeout: 2_000 });
+      const client = new S3({
+        requestHandler: handler,
+      });
+      expect(client.config.requestHandler).toBe(handler);
+      expect(handler).toBeInstanceOf(XhrHttpHandler);
+      expect((handler as any).config.requestTimeout).toEqual(2_000);
+    });
+  });
+});

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/jest.config.integ.js

@@ -0,0 +1,4 @@
+module.exports = {
+  preset: "ts-jest",
+  testMatch: ["**/*.integ.spec.ts"],
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/jest.config.js

@@ -0,0 +1,6 @@
+const base = require("../../jest.config.base.js");
+
+module.exports = {
+  ...base,
+  testPathIgnorePatterns: ["/node_modules/"],
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/scripts/lint.js

@@ -0,0 +1,24 @@
+const fs = require("fs");
+const path = require("path");
+const assert = require("assert");
+
+const root = path.join(__dirname, "..");
+
+const pkgJson = require(path.join(root, "package.json"));
+const srcFolders = fs.readdirSync(path.join(root, "src"));
+
+assert(pkgJson.exports === undefined, "We cannot support package.json exports yet.");
+
+/**
+ * We probably can't enable package.json exports until
+ * dropping support for Node.js 14.x and TypeScript 4.6.
+ */
+process.exit(0);
+
+for (const srcFolder of srcFolders) {
+  if (fs.lstatSync(path.join(root, "src", srcFolder)).isDirectory()) {
+    if (!pkgJson.exports["./" + srcFolder]) {
+      throw new Error(`${srcFolder} is missing exports statement in package.json`);
+    }
+  }
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/client/emitWarningIfUnsupportedVersion.spec.ts

@@ -0,0 +1,70 @@
+describe("emitWarningIfUnsupportedVersion", () => {
+  let emitWarningIfUnsupportedVersion;
+  const emitWarning = process.emitWarning;
+  const supportedVersion = "16.0.0";
+
+  beforeEach(() => {
+    const module = require("./emitWarningIfUnsupportedVersion");
+    emitWarningIfUnsupportedVersion = module.emitWarningIfUnsupportedVersion;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.resetModules();
+    process.emitWarning = emitWarning;
+  });
+
+  describe(`emits warning for Node.js <${supportedVersion}`, () => {
+    const getPreviousMajorVersion = (major: number) => (major === 0 ? 0 : major - 1);
+
+    const getPreviousMinorVersion = ([major, minor]: [number, number]) =>
+      minor === 0 ? [getPreviousMajorVersion(major), 9] : [major, minor - 1];
+
+    const getPreviousPatchVersion = ([major, minor, patch]: [number, number, number]) =>
+      patch === 0 ? [...getPreviousMinorVersion([major, minor]), 9] : [major, minor, patch - 1];
+
+    const [major, minor, patch] = supportedVersion.split(".").map(Number);
+    it.each(
+      [
+        getPreviousPatchVersion([major, minor, patch]),
+        [...getPreviousMinorVersion([major, minor]), 0],
+        [getPreviousMajorVersion(major), 0, 0],
+      ].map((arr) => `v${arr.join(".")}`)
+    )(`%s`, async (unsupportedVersion) => {
+      process.emitWarning = jest.fn();
+      emitWarningIfUnsupportedVersion(unsupportedVersion);
+
+      // Verify that the warning was emitted.
+      expect(process.emitWarning).toHaveBeenCalledTimes(1);
+      expect(process.emitWarning).toHaveBeenCalledWith(
+        `NodeDeprecationWarning: The AWS SDK for JavaScript (v3) will
+no longer support Node.js 14.x on May 1, 2024.
+
+To continue receiving updates to AWS services, bug fixes, and security
+updates please upgrade to an active Node.js LTS version.
+
+More information can be found at: https://a.co/dzr2AJd`
+      );
+
+      // Verify that the warning emits only once.
+      emitWarningIfUnsupportedVersion(unsupportedVersion);
+      expect(process.emitWarning).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe(`emits no warning for Node.js >=${supportedVersion}`, () => {
+    const [major, minor, patch] = supportedVersion.split(".").map(Number);
+    it.each(
+      [
+        [major, minor, patch],
+        [major, minor, patch + 1],
+        [major, minor + 1, 0],
+        [major + 1, 0, 0],
+      ].map((arr) => `v${arr.join(".")}`)
+    )(`%s`, async (unsupportedVersion) => {
+      process.emitWarning = jest.fn();
+      emitWarningIfUnsupportedVersion(unsupportedVersion);
+      expect(process.emitWarning).not.toHaveBeenCalled();
+    });
+  });
+});

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/client/emitWarningIfUnsupportedVersion.ts

@@ -0,0 +1,25 @@
+// Stores whether the warning was already emitted.
+let warningEmitted = false;
+
+/**
+ * @internal
+ *
+ * Emits warning if the provided Node.js version string is
+ * pending deprecation by AWS SDK JSv3.
+ *
+ * @param version - The Node.js version string.
+ */
+export const emitWarningIfUnsupportedVersion = (version: string) => {
+  if (version && !warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 16) {
+    warningEmitted = true;
+    process.emitWarning(
+      `NodeDeprecationWarning: The AWS SDK for JavaScript (v3) will
+no longer support Node.js 14.x on May 1, 2024.
+
+To continue receiving updates to AWS services, bug fixes, and security
+updates please upgrade to an active Node.js LTS version.
+
+More information can be found at: https://a.co/dzr2AJd`
+    );
+  }
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/client/index.ts

@@ -0,0 +1 @@
+export * from "./emitWarningIfUnsupportedVersion";

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/httpAuthSchemes/aws_sdk/AwsSdkSigV4Signer.spec.ts

@@ -0,0 +1,30 @@
+import { AwsSdkSigV4Signer } from "./AwsSdkSigV4Signer";
+
+describe(AwsSdkSigV4Signer.name, () => {
+  it("sets clockSkewCorrected metadata in error handler if systemClockOffset was updated", async () => {
+    const signer = new AwsSdkSigV4Signer();
+
+    let error: Error | any;
+    try {
+      signer.errorHandler({
+        config: {
+          systemClockOffset: 30 * 60 * 1000,
+        },
+      })(
+        Object.assign(new Error("uh oh"), {
+          $metadata: {},
+          $response: {
+            headers: {
+              date: new Date().toISOString(),
+            },
+            statusCode: 500,
+          },
+        })
+      );
+    } catch (e) {
+      error = e as Error;
+    }
+
+    expect((error as any).$metadata.clockSkewCorrected).toBe(true);
+  });
+});

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/httpAuthSchemes/aws_sdk/AwsSdkSigV4Signer.ts

@@ -0,0 +1,134 @@
+import { HttpRequest } from "@smithy/protocol-http";
+import { ServiceException } from "@smithy/smithy-client";
+import {
+  AuthScheme,
+  AwsCredentialIdentity,
+  HandlerExecutionContext,
+  HttpRequest as IHttpRequest,
+  HttpResponse,
+  HttpSigner,
+  RequestSigner,
+} from "@smithy/types";
+
+import { getDateHeader, getSkewCorrectedDate, getUpdatedSystemClockOffset } from "../utils";
+
+/**
+ * @internal
+ */
+const throwSigningPropertyError = <T>(name: string, property: T | undefined): T | never => {
+  if (!property) {
+    throw new Error(`Property \`${name}\` is not resolved for AWS SDK SigV4Auth`);
+  }
+  return property;
+};
+
+/**
+ * @internal
+ */
+interface AwsSdkSigV4Config {
+  systemClockOffset: number;
+  signer: (authScheme?: AuthScheme) => Promise<RequestSigner>;
+}
+
+/**
+ * @internal
+ */
+interface AwsSdkSigV4AuthSigningProperties {
+  config: AwsSdkSigV4Config;
+  signer: RequestSigner;
+  signingRegion?: string;
+  signingName?: string;
+}
+
+/**
+ * @internal
+ */
+interface AwsSdkSigV4Exception extends ServiceException {
+  ServerTime?: string;
+  $metadata: ServiceException["$metadata"] & {
+    clockSkewCorrected?: boolean;
+  };
+}
+
+/**
+ * @internal
+ */
+const validateSigningProperties = async (
+  signingProperties: Record<string, unknown>
+): Promise<AwsSdkSigV4AuthSigningProperties> => {
+  const context = throwSigningPropertyError(
+    "context",
+    signingProperties.context as HandlerExecutionContext | undefined
+  );
+  const config = throwSigningPropertyError("config", signingProperties.config as AwsSdkSigV4Config | undefined);
+  const authScheme = context.endpointV2?.properties?.authSchemes?.[0];
+  const signerFunction = throwSigningPropertyError(
+    "signer",
+    config.signer as ((authScheme?: AuthScheme) => Promise<RequestSigner>) | undefined
+  );
+  const signer = await signerFunction(authScheme);
+  const signingRegion: string | undefined = signingProperties?.signingRegion as string | undefined;
+  const signingName = signingProperties?.signingName as string | undefined;
+  return {
+    config,
+    signer,
+    signingRegion,
+    signingName,
+  };
+};
+
+/**
+ * @internal
+ */
+export class AwsSdkSigV4Signer implements HttpSigner {
+  async sign(
+    httpRequest: IHttpRequest,
+    /**
+     * `identity` is bound in {@link resolveAWSSDKSigV4Config}
+     */
+    identity: AwsCredentialIdentity,
+    signingProperties: Record<string, unknown>
+  ): Promise<IHttpRequest> {
+    if (!HttpRequest.isInstance(httpRequest)) {
+      throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
+    }
+    const { config, signer, signingRegion, signingName } = await validateSigningProperties(signingProperties);
+
+    const signedRequest = await signer.sign(httpRequest, {
+      signingDate: getSkewCorrectedDate(config.systemClockOffset),
+      signingRegion: signingRegion,
+      signingService: signingName,
+    });
+    return signedRequest;
+  }
+
+  errorHandler(signingProperties: Record<string, unknown>): (error: Error) => never {
+    return (error: Error) => {
+      const serverTime: string | undefined =
+        (error as AwsSdkSigV4Exception).ServerTime ?? getDateHeader((error as AwsSdkSigV4Exception).$response);
+      if (serverTime) {
+        const config = throwSigningPropertyError("config", signingProperties.config as AwsSdkSigV4Config | undefined);
+        const initialSystemClockOffset = config.systemClockOffset;
+        config.systemClockOffset = getUpdatedSystemClockOffset(serverTime, config.systemClockOffset);
+        const clockSkewCorrected = config.systemClockOffset !== initialSystemClockOffset;
+        if (clockSkewCorrected && (error as AwsSdkSigV4Exception).$metadata) {
+          (error as AwsSdkSigV4Exception).$metadata.clockSkewCorrected = true;
+        }
+      }
+      throw error;
+    };
+  }
+
+  successHandler(httpResponse: HttpResponse | unknown, signingProperties: Record<string, unknown>): void {
+    const dateHeader = getDateHeader(httpResponse);
+    if (dateHeader) {
+      const config = throwSigningPropertyError("config", signingProperties.config as AwsSdkSigV4Config | undefined);
+      config.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, config.systemClockOffset);
+    }
+  }
+}
+
+/**
+ * @deprecated renamed to {@link AwsSdkSigV4Signer}
+ */
+export const AWSSDKSigV4Signer = AwsSdkSigV4Signer;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/httpAuthSchemes/aws_sdk/index.ts

@@ -0,0 +1,2 @@
+export * from "./AwsSdkSigV4Signer";
+export * from "./resolveAwsSdkSigV4Config";