@cdklabs/cdk-construct-connect-datalake 0.0.13 → 0.0.15

package/node_modules/@smithy/core/dist-es/submodules/cbor/cbor-encode.js

@@ -1,83 +1,64 @@
-import { NumericValue, fromUtf8 } from "@smithy/core/serde";
+import { NumericValue } from "@smithy/core/serde";
 import { alloc, extendedFloat16, extendedFloat32, extendedFloat64, majorList, majorMap, majorNegativeInt64, majorSpecial, majorTag, majorUint64, majorUnstructuredByteString, majorUtf8String, specialFalse, specialNull, specialTrue, tagSymbol, } from "./cbor-types";
 const USE_BUFFER = typeof Buffer !== "undefined";
+const encodeStringCache = new Map();
+let encodeCacheEpoch = 0;
+let encodeCacheSaturated = false;
 const initialSize = 2048;
 let data = alloc(initialSize);
 let dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
 let cursor = 0;
-function ensureSpace(bytes) {
-    const remaining = data.byteLength - cursor;
-    if (remaining < bytes) {
-        if (cursor < 16_000_000) {
-            resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
-        }
-        else {
-            resize(data.byteLength + bytes + 16_000_000);
-        }
-    }
-}
-export function toUint8Array() {
-    const out = alloc(cursor);
-    out.set(data.subarray(0, cursor), 0);
-    cursor = 0;
-    return out;
-}
-export function resize(size) {
-    const old = data;
-    data = alloc(size);
-    if (old) {
-        if (old.copy) {
-            old.copy(data, 0, 0, old.byteLength);
-        }
-        else {
-            data.set(old, 0);
-        }
-    }
-    dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
-}
-function encodeHeader(major, value) {
-    if (value < 24) {
-        data[cursor++] = (major << 5) | value;
-    }
-    else if (value < 1 << 8) {
-        data[cursor++] = (major << 5) | 24;
-        data[cursor++] = value;
-    }
-    else if (value < 1 << 16) {
-        data[cursor++] = (major << 5) | extendedFloat16;
-        dataView.setUint16(cursor, value);
-        cursor += 2;
-    }
-    else if (value < 2 ** 32) {
-        data[cursor++] = (major << 5) | extendedFloat32;
-        dataView.setUint32(cursor, value);
-        cursor += 4;
-    }
-    else {
-        data[cursor++] = (major << 5) | extendedFloat64;
-        dataView.setBigUint64(cursor, typeof value === "bigint" ? value : BigInt(value));
-        cursor += 8;
-    }
-}
 export function encode(_input) {
     const encodeStack = [_input];
     while (encodeStack.length) {
         const input = encodeStack.pop();
-        ensureSpace(typeof input === "string" ? input.length * 4 : 64);
         if (typeof input === "string") {
+            const len = input.length;
             if (USE_BUFFER) {
-                encodeHeader(majorUtf8String, Buffer.byteLength(input));
-                cursor += data.write(input, cursor);
+                ensureSpace(len * 3 + 9);
+                if (len > 23) {
+                    encodeHeader(majorUtf8String, Buffer.byteLength(input));
+                    cursor += data.write(input, cursor);
+                }
+                else {
+                    encodeStringCached(input);
+                }
             }
             else {
-                const bytes = fromUtf8(input);
-                encodeHeader(majorUtf8String, bytes.byteLength);
-                data.set(bytes, cursor);
-                cursor += bytes.byteLength;
+                const maxBytes = len * 3;
+                ensureSpace(maxBytes + 9);
+                const headerPos = cursor;
+                const result = new TextEncoder().encodeInto(input, data.subarray(cursor + 9));
+                const byteLen = result.written;
+                let headerSize;
+                if (byteLen < 24) {
+                    headerSize = 1;
+                }
+                else if (byteLen < 256) {
+                    headerSize = 2;
+                }
+                else if (byteLen < 65536) {
+                    headerSize = 3;
+                }
+                else if (byteLen < 4294967296) {
+                    headerSize = 5;
+                }
+                else {
+                    headerSize = 9;
+                }
+                if (headerSize < 9) {
+                    data.copyWithin(headerPos + headerSize, headerPos + 9, headerPos + 9 + byteLen);
+                }
+                cursor = headerPos;
+                encodeInteger(majorUtf8String, byteLen);
+                cursor += byteLen;
             }
             continue;
         }
-        else if (typeof input === "number") {
+        if (data.byteLength - cursor < 9) {
+            ensureSpace(64);
+        }
+        if (typeof input === "number") {
             if (Number.isInteger(input)) {
                 const nonNegative = input >= 0;
                 const major = nonNegative ? majorUint64 : majorNegativeInt64;
@@ -92,7 +73,7 @@ export function encode(_input) {
                 else if (value < 65536) {
                     data[cursor++] = (major << 5) | extendedFloat16;
                     data[cursor++] = value >> 8;
-                    data[cursor++] = value;
+                    data[cursor++] = value & 0xff;
                 }
                 else if (value < 4294967296) {
                     data[cursor++] = (major << 5) | extendedFloat32;
@@ -101,7 +82,10 @@ export function encode(_input) {
                 }
                 else {
                     data[cursor++] = (major << 5) | extendedFloat64;
-                    dataView.setBigUint64(cursor, BigInt(value));
+                    const hi = (value / 4294967296) | 0;
+                    const lo = (value - hi * 4294967296) | 0;
+                    dataView.setUint32(cursor, hi);
+                    dataView.setUint32(cursor + 4, lo);
                     cursor += 8;
                 }
                 continue;
@@ -115,28 +99,16 @@ export function encode(_input) {
             const nonNegative = input >= 0;
             const major = nonNegative ? majorUint64 : majorNegativeInt64;
             const value = nonNegative ? input : -input - BigInt(1);
-            const n = Number(value);
-            if (n < 24) {
-                data[cursor++] = (major << 5) | n;
-            }
-            else if (n < 256) {
-                data[cursor++] = (major << 5) | 24;
-                data[cursor++] = n;
-            }
-            else if (n < 65536) {
-                data[cursor++] = (major << 5) | extendedFloat16;
-                data[cursor++] = n >> 8;
-                data[cursor++] = n & 0b1111_1111;
-            }
-            else if (n < 4294967296) {
-                data[cursor++] = (major << 5) | extendedFloat32;
-                dataView.setUint32(cursor, n);
-                cursor += 4;
-            }
-            else if (value < BigInt("18446744073709551616")) {
-                data[cursor++] = (major << 5) | extendedFloat64;
-                dataView.setBigUint64(cursor, value);
-                cursor += 8;
+            if (value < BigInt("18446744073709551616")) {
+                const n = Number(value);
+                if (n < 4294967296) {
+                    encodeInteger(major, n);
+                }
+                else {
+                    data[cursor++] = (major << 5) | extendedFloat64;
+                    dataView.setBigUint64(cursor, value);
+                    cursor += 8;
+                }
             }
             else {
                 const binaryBigInt = value.toString(2);
@@ -147,14 +119,9 @@ export function encode(_input) {
                     bigIntBytes[bigIntBytes.byteLength - i] = Number(b & BigInt(255));
                     b >>= BigInt(8);
                 }
-                ensureSpace(bigIntBytes.byteLength * 2);
+                ensureSpace(bigIntBytes.byteLength * 2 + 16);
                 data[cursor++] = nonNegative ? 0b110_00010 : 0b110_00011;
-                if (USE_BUFFER) {
-                    encodeHeader(majorUnstructuredByteString, Buffer.byteLength(bigIntBytes));
-                }
-                else {
-                    encodeHeader(majorUnstructuredByteString, bigIntBytes.byteLength);
-                }
+                encodeHeader(majorUnstructuredByteString, bigIntBytes.byteLength);
                 data.set(bigIntBytes, cursor);
                 cursor += bigIntBytes.byteLength;
             }
@@ -172,15 +139,16 @@ export function encode(_input) {
             throw new Error("@smithy/core/cbor: client may not serialize undefined value.");
         }
         else if (Array.isArray(input)) {
+            encodeInteger(majorList, input.length);
+            ensureSpace(input.length * 9 + 64);
             for (let i = input.length - 1; i >= 0; --i) {
                 encodeStack.push(input[i]);
             }
-            encodeHeader(majorList, input.length);
             continue;
         }
         else if (typeof input.byteLength === "number") {
-            ensureSpace(input.length * 2);
-            encodeHeader(majorUnstructuredByteString, input.length);
+            ensureSpace(input.length * 2 + 9);
+            encodeInteger(majorUnstructuredByteString, input.length);
             data.set(input, cursor);
             cursor += input.byteLength;
             continue;
@@ -191,9 +159,9 @@ export function encode(_input) {
                 const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
                 const mantissa = BigInt(input.string.replace(".", ""));
                 data[cursor++] = 0b110_00100;
+                encodeInteger(majorList, 2);
                 encodeStack.push(mantissa);
                 encodeStack.push(exponent);
-                encodeHeader(majorList, 2);
                 continue;
             }
             if (input[tagSymbol]) {
@@ -207,14 +175,135 @@ export function encode(_input) {
                 }
             }
             const keys = Object.keys(input);
-            for (let i = keys.length - 1; i >= 0; --i) {
-                const key = keys[i];
-                encodeStack.push(input[key]);
-                encodeStack.push(key);
+            const len = keys.length;
+            encodeInteger(majorMap, len);
+            for (let i = len - 1; i >= 0; --i) {
+                encodeStack.push(input[keys[i]]);
+                encodeStack.push(keys[i]);
             }
-            encodeHeader(majorMap, keys.length);
             continue;
         }
         throw new Error(`data type ${input?.constructor?.name ?? typeof input} not compatible for encoding.`);
     }
 }
+export function advanceEncodingEpoch() {
+    encodeCacheEpoch = (encodeCacheEpoch + 1) & 0b1111_1111_1111_1111;
+    encodeCacheSaturated = false;
+}
+export function toUint8Array() {
+    const out = alloc(cursor);
+    out.set(data.subarray(0, cursor), 0);
+    cursor = 0;
+    return out;
+}
+export function resize(size) {
+    const old = data;
+    data = alloc(size);
+    if (old) {
+        if (old.copy) {
+            old.copy(data, 0, 0, old.byteLength);
+        }
+        else {
+            data.set(old, 0);
+        }
+    }
+    dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+}
+function encodeStringCached(input) {
+    const cached = encodeStringCache.get(input);
+    if (cached !== undefined) {
+        data.set(cached.bytes, cursor);
+        cursor += cached.bytes.length;
+        cached.epoch = encodeCacheEpoch;
+        return;
+    }
+    const start = cursor;
+    const byteLen = Buffer.byteLength(input);
+    encodeInteger(majorUtf8String, byteLen);
+    cursor += data.write(input, cursor);
+    const bytes = Uint8Array.prototype.slice.call(data, start, cursor);
+    if (encodeStringCache.size >= 2048) {
+        if (encodeCacheSaturated) {
+            return;
+        }
+        let evicted = 0;
+        for (const [key, entry] of encodeStringCache) {
+            if (evicted >= 1024) {
+                break;
+            }
+            if (entry.epoch !== encodeCacheEpoch) {
+                encodeStringCache.delete(key);
+                evicted++;
+            }
+        }
+        if (evicted === 0) {
+            encodeCacheSaturated = true;
+            return;
+        }
+    }
+    if (encodeStringCache.size < 2048) {
+        encodeStringCache.set(input, { epoch: encodeCacheEpoch, bytes });
+    }
+}
+function ensureSpace(bytes) {
+    const remaining = data.byteLength - cursor;
+    if (remaining < bytes) {
+        if (cursor < 16_000_000) {
+            resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
+        }
+        else {
+            resize(data.byteLength + bytes + 16_000_000);
+        }
+    }
+}
+function encodeHeader(major, value) {
+    if (value < 24) {
+        data[cursor++] = (major << 5) | value;
+    }
+    else if (value < 256) {
+        data[cursor++] = (major << 5) | 24;
+        data[cursor++] = value;
+    }
+    else if (value < 65536) {
+        data[cursor++] = (major << 5) | extendedFloat16;
+        dataView.setUint16(cursor, value);
+        cursor += 2;
+    }
+    else if (value < 4294967296) {
+        data[cursor++] = (major << 5) | extendedFloat32;
+        dataView.setUint32(cursor, value);
+        cursor += 4;
+    }
+    else {
+        data[cursor++] = (major << 5) | extendedFloat64;
+        dataView.setBigUint64(cursor, typeof value === "bigint" ? value : BigInt(value));
+        cursor += 8;
+    }
+}
+function encodeInteger(major, value) {
+    if (value < 24) {
+        data[cursor++] = (major << 5) | value;
+    }
+    else if (value < 256) {
+        data[cursor++] = (major << 5) | 24;
+        data[cursor++] = value;
+    }
+    else if (value < 65536) {
+        data[cursor++] = (major << 5) | extendedFloat16;
+        data[cursor++] = value >> 8;
+        data[cursor++] = value & 0xff;
+    }
+    else if (value < 4294967296) {
+        data[cursor++] = (major << 5) | extendedFloat32;
+        dataView.setUint32(cursor, value);
+        cursor += 4;
+    }
+    else {
+        data[cursor++] = (major << 5) | extendedFloat64;
+        const hi = (value / 4294967296) | 0;
+        const lo = (value - hi * 4294967296) | 0;
+        dataView.setUint32(cursor, hi);
+        dataView.setUint32(cursor + 4, lo);
+        cursor += 8;
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/cbor/cbor.js

@@ -1,11 +1,13 @@
-import { decode, setPayload } from "./cbor-decode";
-import { encode, resize, toUint8Array } from "./cbor-encode";
+import { advanceDecodingEpoch, decode, setPayload } from "./cbor-decode";
+import { advanceEncodingEpoch, encode, resize, toUint8Array } from "./cbor-encode";
 export const cbor = {
     deserialize(payload) {
+        advanceDecodingEpoch();
         setPayload(payload);
         return decode(0, payload.length);
     },
     serialize(input) {
+        advanceEncodingEpoch();
         try {
             encode(input);
             return toUint8Array();

package/node_modules/@smithy/core/dist-es/submodules/client/smithy-client/get-value-from-text-node.js

@@ -1,7 +1,7 @@
 export const getValueFromTextNode = (obj) => {
     const textNodeName = "#text";
     for (const key in obj) {
-        if (obj.hasOwnProperty(key) && obj[key][textNodeName] !== undefined) {
+        if (Object.prototype.hasOwnProperty.call(obj, key) && obj[key][textNodeName] !== undefined) {
             obj[key] = obj[key][textNodeName];
         }
         else if (typeof obj[key] === "object" && obj[key] !== null) {

package/node_modules/@smithy/core/dist-es/submodules/endpoints/middleware-endpoint/endpointMiddleware.js

@@ -1,4 +1,4 @@
-import { getSmithyContext } from "@smithy/core/client";
+import { getSmithyContext } from "@smithy/core/transport";
 import { bindGetEndpointFromInstructions } from "./adaptors/getEndpointFromInstructions";
 function setFeature(context, feature, value) {
     if (!context.__smithy_context) {

package/node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js

@@ -112,15 +112,23 @@ export class HttpProtocol extends SerdeContext {
         });
     }
     async loadEventStreamCapability() {
-        const { EventStreamSerde } = await import("@smithy/core/event-streams");
+        const { EventStreamSerde, eventStreamSerdeProvider } = await import("@smithy/core/event-streams");
+        const marshaller = this.resolveEventStreamMarshaller(eventStreamSerdeProvider);
         return new EventStreamSerde({
-            marshaller: this.getEventStreamMarshaller(),
+            marshaller,
             serializer: this.serializer,
             deserializer: this.deserializer,
             serdeContext: this.serdeContext,
             defaultContentType: this.getDefaultContentType(),
         });
     }
+    resolveEventStreamMarshaller(importedProvider) {
+        const context = this.serdeContext;
+        if (context.eventStreamMarshaller) {
+            return context.eventStreamMarshaller;
+        }
+        return importedProvider(this.serdeContext);
+    }
     getDefaultContentType() {
         throw new Error(`@smithy/core/protocols - ${this.constructor.name} getDefaultContentType() implementation missing.`);
     }

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/retry-pre-sra-deprecated/StandardRetryStrategy.js

@@ -89,7 +89,7 @@ const getDelayFromRetryAfterHeader = (response) => {
     const retryAfter = response.headers[retryAfterHeaderName];
     const retryAfterSeconds = Number(retryAfter);
     if (!Number.isNaN(retryAfterSeconds))
-        return retryAfterSeconds * 1000;
+        return Math.min(retryAfterSeconds * 1000, 20_000);
     const retryAfterDate = new Date(retryAfter);
-    return retryAfterDate.getTime() - Date.now();
+    return Math.min(retryAfterDate.getTime() - Date.now(), 20_000);
 };

package/node_modules/@smithy/core/dist-es/submodules/retry/util-retry/DefaultRateLimiter.js

@@ -1,6 +1,6 @@
 import { isThrottlingError } from "../service-error-classification/service-error-classification";
 export class DefaultRateLimiter {
-    static setTimeoutFn = setTimeout;
+    static setTimeoutFn = (fn, delay) => setTimeout(fn, delay);
     beta;
     minCapacity;
     minFillRate;

package/node_modules/@smithy/core/dist-types/submodules/cbor/cbor-decode.d.ts

@@ -16,3 +16,7 @@ export declare function decode(at: Uint32, to: Uint32): CborValueType;
  * @internal
  */
 export declare function bytesToFloat16(a: Uint8, b: Uint8): Float32;
+/**
+ * @internal
+ */
+export declare function advanceDecodingEpoch(): void;

package/node_modules/@smithy/core/dist-types/submodules/cbor/cbor-encode.d.ts

@@ -1,9 +1,13 @@
+/**
+ * @param _input - JS data object.
+ */
+export declare function encode(_input: any): void;
 /**
  * @internal
  */
-export declare function toUint8Array(): Uint8Array;
-export declare function resize(size: number): void;
+export declare function advanceEncodingEpoch(): void;
 /**
- * @param _input - JS data object.
+ * @internal
  */
-export declare function encode(_input: any): void;
+export declare function toUint8Array(): Uint8Array;
+export declare function resize(size: number): void;

package/node_modules/@smithy/core/dist-types/submodules/protocols/HttpProtocol.d.ts

@@ -74,6 +74,12 @@ export declare abstract class HttpProtocol extends SerdeContext implements Clien
      * Loads eventStream capability async (for chunking).
      */
     protected loadEventStreamCapability(): Promise<EventStreamSerde>;
+    /**
+     * Returns a platform-specific EventStreamMarshaller.
+     * Prefers user-injected marshaller from serdeContext (via client config),
+     * falls back to the dynamically imported provider.
+     */
+    private resolveEventStreamMarshaller;
     /**
      * @returns content-type default header value for event stream events and other documents.
      */

package/node_modules/@smithy/core/dist-types/submodules/schema/TypeRegistry.d.ts

@@ -62,7 +62,7 @@ export declare class TypeRegistry {
      * @param predicate - criterion.
      * @returns a schema in this registry matching the predicate.
      */
-    find(predicate: (schema: ISchema) => boolean): number | import("@smithy/types").StaticSimpleSchema | import("@smithy/types").StaticListSchema | import("@smithy/types").StaticMapSchema | import("@smithy/types").StaticStructureSchema | import("@smithy/types").StaticUnionSchema | StaticErrorSchema | import("@smithy/types").StaticOperationSchema | "unit" | import("@smithy/types").NormalizedSchema | import("@smithy/types").TraitsSchema | import("@smithy/types").MemberSchema | undefined;
+    find(predicate: (schema: ISchema) => boolean): number | "unit" | import("@smithy/types").StaticSimpleSchema | import("@smithy/types").StaticListSchema | import("@smithy/types").StaticMapSchema | import("@smithy/types").StaticStructureSchema | import("@smithy/types").StaticUnionSchema | StaticErrorSchema | import("@smithy/types").StaticOperationSchema | import("@smithy/types").NormalizedSchema | import("@smithy/types").TraitsSchema | import("@smithy/types").MemberSchema | undefined;
     /**
      * Unloads the current TypeRegistry.
      */

package/node_modules/@smithy/core/package.json

@@ -1,21 +1,22 @@
 {
   "name": "@smithy/core",
-  "version": "3.24.6",
+  "version": "3.26.0",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es:cjs'",
-    "build:es:cjs": "yarn g:tsc -p tsconfig.es.json && node ../../scripts/inline core",
-    "build:types": "yarn g:tsc -p tsconfig.types.json",
+    "build:es:cjs": "premove dist-es && yarn g:tsc -p tsconfig.es.json && node ../../scripts/inline",
+    "build:types": "premove dist-types && yarn g:tsc -p tsconfig.types.json",
     "build:types:downlevel": "premove dist-types/ts3.4 && downlevel-dts dist-types dist-types/ts3.4",
-    "clean": "premove dist-cjs dist-es dist-types tsconfig.cjs.tsbuildinfo tsconfig.es.tsbuildinfo tsconfig.types.tsbuildinfo",
+    "clean": "premove dist-cjs dist-es dist-types",
     "extract:docs": "api-extractor run --local",
     "format": "prettier --config ../../prettier.config.js --ignore-path ../../.prettierignore --write \"**/*.{ts,md,json}\"",
-    "lint": "npx eslint -c ../../.eslintrc.js \"src/**/*.ts\" --fix && node ./scripts/lint",
+    "lint": "node ../../scripts/validation/submodules-linter.js",
+    "prebuild": "yarn lint",
     "stage-release": "premove .release && yarn pack && mkdir ./.release && tar zxvf ./package.tgz --directory ./.release && rm ./package.tgz",
     "test": "yarn g:vitest run",
-    "test:cbor:perf": "node ./scripts/cbor-perf.mjs",
+    "test:watch": "yarn g:vitest watch",
     "test:integration": "yarn g:vitest run -c vitest.config.integ.mts",
     "test:integration:watch": "yarn g:vitest watch -c vitest.config.integ.mts",
-    "test:watch": "yarn g:vitest watch"
+    "test:cbor:perf": "node ./scripts/cbor-perf.mjs"
   },
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -169,9 +170,18 @@
   "sideEffects": false,
   "dependencies": {
     "@aws-crypto/crc32": "5.2.0",
-    "@smithy/types": "^4.14.3",
+    "@smithy/types": "^4.15.0",
     "tslib": "^2.6.2"
   },
+  "devDependencies": {
+    "@types/node": "^18.11.9",
+    "concurrently": "7.0.0",
+    "downlevel-dts": "0.10.1",
+    "hash-test-vectors": "^1.3.2",
+    "json-bigint": "^1.0.0",
+    "premove": "4.0.0",
+    "typedoc": "0.23.23"
+  },
   "engines": {
     "node": ">=18.0.0"
   },
@@ -213,15 +223,6 @@
     "url": "https://github.com/smithy-lang/smithy-typescript.git",
     "directory": "packages/core"
   },
-  "devDependencies": {
-    "@types/node": "^18.11.9",
-    "concurrently": "7.0.0",
-    "downlevel-dts": "0.10.1",
-    "hash-test-vectors": "^1.3.2",
-    "json-bigint": "^1.0.0",
-    "premove": "4.0.0",
-    "typedoc": "0.23.23"
-  },
   "typedoc": {
     "entryPoint": "src/index.ts"
   },