@jjrawlins/cdk-iam-policy-builder-helper 0.0.2 → 0.0.3

package/node_modules/@smithy/util-stream/dist-es/createBufferedReadableStream.js

@@ -0,0 +1,95 @@
+import { ByteArrayCollector } from "./ByteArrayCollector";
+export function createBufferedReadableStream(upstream, size, logger) {
+    const reader = upstream.getReader();
+    let streamBufferingLoggedWarning = false;
+    let bytesSeen = 0;
+    const buffers = ["", new ByteArrayCollector((size) => new Uint8Array(size))];
+    let mode = -1;
+    const pull = async (controller) => {
+        const { value, done } = await reader.read();
+        const chunk = value;
+        if (done) {
+            if (mode !== -1) {
+                const remainder = flush(buffers, mode);
+                if (sizeOf(remainder) > 0) {
+                    controller.enqueue(remainder);
+                }
+            }
+            controller.close();
+        }
+        else {
+            const chunkMode = modeOf(chunk);
+            if (mode !== chunkMode) {
+                if (mode >= 0) {
+                    controller.enqueue(flush(buffers, mode));
+                }
+                mode = chunkMode;
+            }
+            if (mode === -1) {
+                controller.enqueue(chunk);
+                return;
+            }
+            const chunkSize = sizeOf(chunk);
+            bytesSeen += chunkSize;
+            const bufferSize = sizeOf(buffers[mode]);
+            if (chunkSize >= size && bufferSize === 0) {
+                controller.enqueue(chunk);
+            }
+            else {
+                const newSize = merge(buffers, mode, chunk);
+                if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
+                    streamBufferingLoggedWarning = true;
+                    logger?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
+                }
+                if (newSize >= size) {
+                    controller.enqueue(flush(buffers, mode));
+                }
+                else {
+                    await pull(controller);
+                }
+            }
+        }
+    };
+    return new ReadableStream({
+        pull,
+    });
+}
+export const createBufferedReadable = createBufferedReadableStream;
+export function merge(buffers, mode, chunk) {
+    switch (mode) {
+        case 0:
+            buffers[0] += chunk;
+            return sizeOf(buffers[0]);
+        case 1:
+        case 2:
+            buffers[mode].push(chunk);
+            return sizeOf(buffers[mode]);
+    }
+}
+export function flush(buffers, mode) {
+    switch (mode) {
+        case 0:
+            const s = buffers[0];
+            buffers[0] = "";
+            return s;
+        case 1:
+        case 2:
+            return buffers[mode].flush();
+    }
+    throw new Error(`@smithy/util-stream - invalid index ${mode} given to flush()`);
+}
+export function sizeOf(chunk) {
+    return chunk?.byteLength ?? chunk?.length ?? 0;
+}
+export function modeOf(chunk) {
+    if (typeof Buffer !== "undefined" && chunk instanceof Buffer) {
+        return 2;
+    }
+    if (chunk instanceof Uint8Array) {
+        return 1;
+    }
+    if (typeof chunk === "string") {
+        return 0;
+    }
+    return -1;
+}

package/node_modules/@smithy/util-stream/dist-es/headStream.browser.js

@@ -0,0 +1,31 @@
+export async function headStream(stream, bytes) {
+    let byteLengthCounter = 0;
+    const chunks = [];
+    const reader = stream.getReader();
+    let isDone = false;
+    while (!isDone) {
+        const { done, value } = await reader.read();
+        if (value) {
+            chunks.push(value);
+            byteLengthCounter += value?.byteLength ?? 0;
+        }
+        if (byteLengthCounter >= bytes) {
+            break;
+        }
+        isDone = done;
+    }
+    reader.releaseLock();
+    const collected = new Uint8Array(Math.min(bytes, byteLengthCounter));
+    let offset = 0;
+    for (const chunk of chunks) {
+        if (chunk.byteLength > collected.byteLength - offset) {
+            collected.set(chunk.subarray(0, collected.byteLength - offset), offset);
+            break;
+        }
+        else {
+            collected.set(chunk, offset);
+        }
+        offset += chunk.length;
+    }
+    return collected;
+}

package/node_modules/@smithy/util-stream/dist-es/headStream.js

@@ -0,0 +1,41 @@
+import { Writable } from "stream";
+import { headStream as headWebStream } from "./headStream.browser";
+import { isReadableStream } from "./stream-type-check";
+export const headStream = (stream, bytes) => {
+    if (isReadableStream(stream)) {
+        return headWebStream(stream, bytes);
+    }
+    return new Promise((resolve, reject) => {
+        const collector = new Collector();
+        collector.limit = bytes;
+        stream.pipe(collector);
+        stream.on("error", (err) => {
+            collector.end();
+            reject(err);
+        });
+        collector.on("error", reject);
+        collector.on("finish", function () {
+            const bytes = new Uint8Array(Buffer.concat(this.buffers));
+            resolve(bytes);
+        });
+    });
+};
+class Collector extends Writable {
+    constructor() {
+        super(...arguments);
+        this.buffers = [];
+        this.limit = Infinity;
+        this.bytesBuffered = 0;
+    }
+    _write(chunk, encoding, callback) {
+        this.buffers.push(chunk);
+        this.bytesBuffered += chunk.byteLength ?? 0;
+        if (this.bytesBuffered >= this.limit) {
+            const excess = this.bytesBuffered - this.limit;
+            const tailBuffer = this.buffers[this.buffers.length - 1];
+            this.buffers[this.buffers.length - 1] = tailBuffer.subarray(0, tailBuffer.byteLength - excess);
+            this.emit("finish");
+        }
+        callback();
+    }
+}

package/node_modules/@smithy/util-stream/dist-es/index.js

@@ -1,3 +1,9 @@
 export * from "./blob/Uint8ArrayBlobAdapter";
+export * from "./checksum/ChecksumStream";
+export * from "./checksum/createChecksumStream";
+export * from "./createBufferedReadable";
 export * from "./getAwsChunkedEncodingStream";
+export * from "./headStream";
 export * from "./sdk-stream-mixin";
+export * from "./splitStream";
+export * from "./stream-type-check";

package/node_modules/@smithy/util-stream/dist-es/sdk-stream-mixin.browser.js

@@ -2,9 +2,10 @@ import { streamCollector } from "@smithy/fetch-http-handler";
 import { toBase64 } from "@smithy/util-base64";
 import { toHex } from "@smithy/util-hex-encoding";
 import { toUtf8 } from "@smithy/util-utf8";
+import { isReadableStream } from "./stream-type-check";
 const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
 export const sdkStreamMixin = (stream) => {
-    if (!isBlobInstance(stream) && !isReadableStreamInstance(stream)) {
+    if (!isBlobInstance(stream) && !isReadableStream(stream)) {
         const name = stream?.__proto__?.constructor?.name || stream;
         throw new Error(`Unexpected stream implementation, expect Blob or ReadableStream, got ${name}`);
     }
@@ -51,7 +52,7 @@ export const sdkStreamMixin = (stream) => {
             if (isBlobInstance(stream)) {
                 return blobToWebStream(stream);
             }
-            else if (isReadableStreamInstance(stream)) {
+            else if (isReadableStream(stream)) {
                 return stream;
             }
             else {
@@ -61,4 +62,3 @@ export const sdkStreamMixin = (stream) => {
     });
 };
 const isBlobInstance = (stream) => typeof Blob === "function" && stream instanceof Blob;
-const isReadableStreamInstance = (stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream;

package/node_modules/@smithy/util-stream/dist-es/sdk-stream-mixin.js

@@ -1,12 +1,17 @@
 import { streamCollector } from "@smithy/node-http-handler";
 import { fromArrayBuffer } from "@smithy/util-buffer-from";
 import { Readable } from "stream";
-import { TextDecoder } from "util";
+import { sdkStreamMixin as sdkStreamMixinReadableStream } from "./sdk-stream-mixin.browser";
 const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
 export const sdkStreamMixin = (stream) => {
     if (!(stream instanceof Readable)) {
-        const name = stream?.__proto__?.constructor?.name || stream;
-        throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${name}`);
+        try {
+            return sdkStreamMixinReadableStream(stream);
+        }
+        catch (e) {
+            const name = stream?.__proto__?.constructor?.name || stream;
+            throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${name}`);
+        }
     }
     let transformed = false;
     const transformToByteArray = async () => {
@@ -36,7 +41,7 @@ export const sdkStreamMixin = (stream) => {
                 throw new Error("The stream has been consumed by other callbacks.");
             }
             if (typeof Readable.toWeb !== "function") {
-                throw new Error("Readable.toWeb() is not supported. Please make sure you are using Node.js >= 17.0.0, or polyfill is available.");
+                throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available.");
             }
             transformed = true;
             return Readable.toWeb(stream);

package/node_modules/@smithy/util-stream/dist-es/splitStream.browser.js

@@ -0,0 +1,7 @@
+export async function splitStream(stream) {
+    if (typeof stream.stream === "function") {
+        stream = stream.stream();
+    }
+    const readableStream = stream;
+    return readableStream.tee();
+}

package/node_modules/@smithy/util-stream/dist-es/splitStream.js

@@ -0,0 +1,13 @@
+import { PassThrough } from "stream";
+import { splitStream as splitWebStream } from "./splitStream.browser";
+import { isBlob, isReadableStream } from "./stream-type-check";
+export async function splitStream(stream) {
+    if (isReadableStream(stream) || isBlob(stream)) {
+        return splitWebStream(stream);
+    }
+    const stream1 = new PassThrough();
+    const stream2 = new PassThrough();
+    stream.pipe(stream1);
+    stream.pipe(stream2);
+    return [stream1, stream2];
+}

package/node_modules/@smithy/util-stream/dist-es/stream-type-check.js

@@ -0,0 +1,5 @@
+export const isReadableStream = (stream) => typeof ReadableStream === "function" &&
+    (stream?.constructor?.name === ReadableStream.name || stream instanceof ReadableStream);
+export const isBlob = (blob) => {
+    return typeof Blob === "function" && (blob?.constructor?.name === Blob.name || blob instanceof Blob);
+};

package/node_modules/@smithy/util-stream/dist-types/ByteArrayCollector.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Aggregates byteArrays on demand.
+ * @internal
+ */
+export declare class ByteArrayCollector {
+    readonly allocByteArray: (size: number) => Uint8Array;
+    byteLength: number;
+    private byteArrays;
+    constructor(allocByteArray: (size: number) => Uint8Array);
+    push(byteArray: Uint8Array): void;
+    flush(): Uint8Array;
+    private reset;
+}

package/node_modules/@smithy/util-stream/dist-types/checksum/ChecksumStream.browser.d.ts

@@ -0,0 +1,37 @@
+import { Checksum, Encoder } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface ChecksumStreamInit {
+    /**
+     * Base64 value of the expected checksum.
+     */
+    expectedChecksum: string;
+    /**
+     * For error messaging, the location from which the checksum value was read.
+     */
+    checksumSourceLocation: string;
+    /**
+     * The checksum calculator.
+     */
+    checksum: Checksum;
+    /**
+     * The stream to be checked.
+     */
+    source: ReadableStream;
+    /**
+     * Optional base 64 encoder if calling from a request context.
+     */
+    base64Encoder?: Encoder;
+}
+declare const ChecksumStream_base: any;
+/**
+ * This stub exists so that the readable returned by createChecksumStream
+ * identifies as "ChecksumStream" in alignment with the Node.js
+ * implementation.
+ *
+ * @extends ReadableStream
+ */
+export declare class ChecksumStream extends ChecksumStream_base {
+}
+export {};

package/node_modules/@smithy/util-stream/dist-types/checksum/ChecksumStream.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Checksum, Encoder } from "@smithy/types";
+import { Duplex, Readable } from "stream";
+/**
+ * @internal
+ */
+export interface ChecksumStreamInit<T extends Readable | ReadableStream> {
+    /**
+     * Base64 value of the expected checksum.
+     */
+    expectedChecksum: string;
+    /**
+     * For error messaging, the location from which the checksum value was read.
+     */
+    checksumSourceLocation: string;
+    /**
+     * The checksum calculator.
+     */
+    checksum: Checksum;
+    /**
+     * The stream to be checked.
+     */
+    source: T;
+    /**
+     * Optional base 64 encoder if calling from a request context.
+     */
+    base64Encoder?: Encoder;
+}
+/**
+ * @internal
+ *
+ * Wrapper for throwing checksum errors for streams without
+ * buffering the stream.
+ *
+ */
+export declare class ChecksumStream extends Duplex {
+    private expectedChecksum;
+    private checksumSourceLocation;
+    private checksum;
+    private source?;
+    private base64Encoder;
+    constructor({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }: ChecksumStreamInit<Readable>);
+    /**
+     * @internal do not call this directly.
+     */
+    _read(size: number): void;
+    /**
+     * @internal do not call this directly.
+     *
+     * When the upstream source flows data to this stream,
+     * calculate a step update of the checksum.
+     */
+    _write(chunk: Buffer, encoding: string, callback: (err?: Error) => void): void;
+    /**
+     * @internal do not call this directly.
+     *
+     * When the upstream source finishes, perform the checksum comparison.
+     */
+    _final(callback: (err?: Error) => void): Promise<void>;
+}

package/node_modules/@smithy/util-stream/dist-types/checksum/createChecksumStream.browser.d.ts

@@ -0,0 +1,15 @@
+import { ChecksumStreamInit } from "./ChecksumStream.browser";
+/**
+ * @internal
+ * Alias prevents compiler from turning
+ * ReadableStream into ReadableStream<any>, which is incompatible
+ * with the NodeJS.ReadableStream global type.
+ */
+export type ReadableStreamType = ReadableStream;
+/**
+ * @internal
+ *
+ * Creates a stream adapter for throwing checksum errors for streams without
+ * buffering the stream.
+ */
+export declare const createChecksumStream: ({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }: ChecksumStreamInit) => ReadableStreamType;

package/node_modules/@smithy/util-stream/dist-types/checksum/createChecksumStream.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { Readable } from "stream";
+import { ChecksumStreamInit } from "./ChecksumStream";
+import { ReadableStreamType } from "./createChecksumStream.browser";
+/**
+ * @internal
+ *
+ * Creates a stream mirroring the input stream's interface, but
+ * performs checksumming when reading to the end of the stream.
+ */
+export declare function createChecksumStream(init: ChecksumStreamInit<ReadableStreamType>): ReadableStreamType;
+export declare function createChecksumStream(init: ChecksumStreamInit<Readable>): Readable;

package/node_modules/@smithy/util-stream/dist-types/createBufferedReadable.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import type { Logger } from "@smithy/types";
+import { Readable } from "node:stream";
+/**
+ * @internal
+ * @param upstream - any Readable or ReadableStream.
+ * @param size - byte or character length minimum. Buffering occurs when a chunk fails to meet this value.
+ * @param onBuffer - for emitting warnings when buffering occurs.
+ * @returns another stream of the same data and stream class, but buffers chunks until
+ * the minimum size is met, except for the last chunk.
+ */
+export declare function createBufferedReadable(upstream: Readable, size: number, logger?: Logger): Readable;
+export declare function createBufferedReadable(upstream: ReadableStream, size: number, logger?: Logger): ReadableStream;

package/node_modules/@smithy/util-stream/dist-types/createBufferedReadableStream.d.ts

@@ -0,0 +1,49 @@
+import type { Logger } from "@smithy/types";
+import { ByteArrayCollector } from "./ByteArrayCollector";
+export type BufferStore = [string, ByteArrayCollector, ByteArrayCollector?];
+export type BufferUnion = string | Uint8Array;
+export type Modes = 0 | 1 | 2;
+/**
+ * @internal
+ * @param upstream - any ReadableStream.
+ * @param size - byte or character length minimum. Buffering occurs when a chunk fails to meet this value.
+ * @param onBuffer - for emitting warnings when buffering occurs.
+ * @returns another stream of the same data, but buffers chunks until
+ * the minimum size is met, except for the last chunk.
+ */
+export declare function createBufferedReadableStream(upstream: ReadableStream, size: number, logger?: Logger): ReadableStream;
+/**
+ * Replaces R/RS polymorphic implementation in environments with only ReadableStream.
+ * @internal
+ */
+export declare const createBufferedReadable: typeof createBufferedReadableStream;
+/**
+ * @internal
+ * @param buffers
+ * @param mode
+ * @param chunk
+ * @returns the new buffer size after merging the chunk with its appropriate buffer.
+ */
+export declare function merge(buffers: BufferStore, mode: Modes, chunk: string | Uint8Array): number;
+/**
+ * @internal
+ * @param buffers
+ * @param mode
+ * @returns the buffer matching the mode.
+ */
+export declare function flush(buffers: BufferStore, mode: Modes | -1): BufferUnion;
+/**
+ * @internal
+ * @param chunk
+ * @returns size of the chunk in bytes or characters.
+ */
+export declare function sizeOf(chunk?: {
+    byteLength?: number;
+    length?: number;
+}): number;
+/**
+ * @internal
+ * @param chunk - from upstream Readable.
+ * @returns type index of the chunk.
+ */
+export declare function modeOf(chunk: BufferUnion): Modes | -1;

package/node_modules/@smithy/util-stream/dist-types/headStream.browser.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ * @param stream
+ * @param bytes - read head bytes from the stream and discard the rest of it.
+ *
+ * Caution: the input stream must be destroyed separately, this function does not do so.
+ */
+export declare function headStream(stream: ReadableStream, bytes: number): Promise<Uint8Array>;

package/node_modules/@smithy/util-stream/dist-types/headStream.d.ts

@@ -0,0 +1,9 @@
+import { Readable } from "stream";
+/**
+ * @internal
+ * @param stream - to be read.
+ * @param bytes - read head bytes from the stream and discard the rest of it.
+ *
+ * Caution: the input stream must be destroyed separately, this function does not do so.
+ */
+export declare const headStream: (stream: Readable | ReadableStream, bytes: number) => Promise<Uint8Array>;

package/node_modules/@smithy/util-stream/dist-types/index.d.ts

@@ -1,3 +1,9 @@
 export * from "./blob/Uint8ArrayBlobAdapter";
+export * from "./checksum/ChecksumStream";
+export * from "./checksum/createChecksumStream";
+export * from "./createBufferedReadable";
 export * from "./getAwsChunkedEncodingStream";
+export * from "./headStream";
 export * from "./sdk-stream-mixin";
+export * from "./splitStream";
+export * from "./stream-type-check";

package/node_modules/@smithy/util-stream/dist-types/sdk-stream-mixin.d.ts

@@ -5,4 +5,4 @@ import { Readable } from "stream";
  *
  * @internal
  */
-export declare const sdkStreamMixin: (stream: unknown) => SdkStream<Readable>;
+export declare const sdkStreamMixin: (stream: unknown) => SdkStream<ReadableStream | Blob> | SdkStream<Readable>;

package/node_modules/@smithy/util-stream/dist-types/splitStream.browser.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param stream
+ * @returns stream split into two identical streams.
+ */
+export declare function splitStream(stream: ReadableStream | Blob): Promise<[ReadableStream, ReadableStream]>;

package/node_modules/@smithy/util-stream/dist-types/splitStream.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import type { Readable } from "stream";
+/**
+ * @internal
+ * @param stream - to be split.
+ * @returns stream split into two identical streams.
+ */
+export declare function splitStream(stream: Readable): Promise<[Readable, Readable]>;
+export declare function splitStream(stream: ReadableStream): Promise<[ReadableStream, ReadableStream]>;

package/node_modules/@smithy/util-stream/dist-types/stream-type-check.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @internal
+ * Alias prevents compiler from turning
+ * ReadableStream into ReadableStream<any>, which is incompatible
+ * with the NodeJS.ReadableStream global type.
+ */
+type ReadableStreamType = ReadableStream;
+/**
+ * @internal
+ */
+export declare const isReadableStream: (stream: unknown) => stream is ReadableStreamType;
+/**
+ * @internal
+ */
+export declare const isBlob: (blob: unknown) => blob is Blob;
+export {};

package/node_modules/@smithy/util-stream/dist-types/ts3.4/ByteArrayCollector.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Aggregates byteArrays on demand.
+ * @internal
+ */
+export declare class ByteArrayCollector {
+    readonly allocByteArray: (size: number) => Uint8Array;
+    byteLength: number;
+    private byteArrays;
+    constructor(allocByteArray: (size: number) => Uint8Array);
+    push(byteArray: Uint8Array): void;
+    flush(): Uint8Array;
+    private reset;
+}

package/node_modules/@smithy/util-stream/dist-types/ts3.4/checksum/ChecksumStream.browser.d.ts

@@ -0,0 +1,37 @@
+import { Checksum, Encoder } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface ChecksumStreamInit {
+    /**
+     * Base64 value of the expected checksum.
+     */
+    expectedChecksum: string;
+    /**
+     * For error messaging, the location from which the checksum value was read.
+     */
+    checksumSourceLocation: string;
+    /**
+     * The checksum calculator.
+     */
+    checksum: Checksum;
+    /**
+     * The stream to be checked.
+     */
+    source: ReadableStream;
+    /**
+     * Optional base 64 encoder if calling from a request context.
+     */
+    base64Encoder?: Encoder;
+}
+declare const ChecksumStream_base: any;
+/**
+ * This stub exists so that the readable returned by createChecksumStream
+ * identifies as "ChecksumStream" in alignment with the Node.js
+ * implementation.
+ *
+ * @extends ReadableStream
+ */
+export declare class ChecksumStream extends ChecksumStream_base {
+}
+export {};

package/node_modules/@smithy/util-stream/dist-types/ts3.4/checksum/ChecksumStream.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+import { Checksum, Encoder } from "@smithy/types";
+import { Duplex, Readable } from "stream";
+/**
+ * @internal
+ */
+export interface ChecksumStreamInit<T extends Readable | ReadableStream> {
+    /**
+     * Base64 value of the expected checksum.
+     */
+    expectedChecksum: string;
+    /**
+     * For error messaging, the location from which the checksum value was read.
+     */
+    checksumSourceLocation: string;
+    /**
+     * The checksum calculator.
+     */
+    checksum: Checksum;
+    /**
+     * The stream to be checked.
+     */
+    source: T;
+    /**
+     * Optional base 64 encoder if calling from a request context.
+     */
+    base64Encoder?: Encoder;
+}
+/**
+ * @internal
+ *
+ * Wrapper for throwing checksum errors for streams without
+ * buffering the stream.
+ *
+ */
+export declare class ChecksumStream extends Duplex {
+    private expectedChecksum;
+    private checksumSourceLocation;
+    private checksum;
+    private source?;
+    private base64Encoder;
+    constructor({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }: ChecksumStreamInit<Readable>);
+    /**
+     * @internal do not call this directly.
+     */
+    _read(size: number): void;
+    /**
+     * @internal do not call this directly.
+     *
+     * When the upstream source flows data to this stream,
+     * calculate a step update of the checksum.
+     */
+    _write(chunk: Buffer, encoding: string, callback: (err?: Error) => void): void;
+    /**
+     * @internal do not call this directly.
+     *
+     * When the upstream source finishes, perform the checksum comparison.
+     */
+    _final(callback: (err?: Error) => void): Promise<void>;
+}