@mshick/dyno 0.1.0

package/dist/streams/dyno-writable-stream.js

@@ -0,0 +1,29 @@
+import { reduceCapacity } from "../util.js";
+import { ParallelWritable } from "./parallel-writable.js";
+export class DynoWritableStream extends ParallelWritable {
+    Count = 0;
+    UnprocessedItems;
+    ConsumedCapacity;
+    TableName;
+    _consumedCapacity = [];
+    constructor(opts) {
+        super(opts);
+        this.TableName = opts.TableName;
+    }
+    update(response, items) {
+        const unprocessedItems = response?.UnprocessedItems?.[this.TableName];
+        const unprocessedItemsLength = unprocessedItems?.length ?? 0;
+        this.Count += items.length - unprocessedItemsLength;
+        this.UnprocessedItems = unprocessedItems
+            ? [...(this.UnprocessedItems ?? []), ...unprocessedItems]
+            : this.UnprocessedItems;
+        if (response?.ConsumedCapacity) {
+            this._consumedCapacity.push(...response.ConsumedCapacity);
+        }
+    }
+    done() {
+        if (this._consumedCapacity.length) {
+            this.ConsumedCapacity = reduceCapacity(this.ConsumedCapacity ?? {}, this._consumedCapacity);
+        }
+    }
+}

package/dist/streams/parallel-writable.d.ts

@@ -0,0 +1,8 @@
+import { Writable, type WritableOptions } from 'node:stream';
+export type ParallelWritableOptions = WritableOptions & {
+    concurrency?: number;
+};
+export declare class ParallelWritable extends Writable {
+    pending: number;
+    constructor({ concurrency, write, final, ...writableOptions }?: ParallelWritableOptions);
+}

package/dist/streams/parallel-writable.js

@@ -0,0 +1,52 @@
+import { Writable } from 'node:stream';
+export class ParallelWritable extends Writable {
+    pending;
+    constructor({ concurrency = 5, write, final, ...writableOptions } = {}) {
+        super(writableOptions);
+        this.setMaxListeners(Number.POSITIVE_INFINITY);
+        this.pending = 0;
+        if (write) {
+            this._write = (chunk, enc, callback) => {
+                if (this.pending >= concurrency) {
+                    this.once('free', () => {
+                        this._write(chunk, enc, callback);
+                    });
+                    return;
+                }
+                this.pending += 1;
+                write.call(this, chunk, enc, (err) => {
+                    this.pending -= 1;
+                    if (err) {
+                        this.destroy(err);
+                    }
+                    else {
+                        this.emit('free');
+                    }
+                });
+                callback();
+            };
+        }
+        if (final) {
+            this._final = (callback) => {
+                if (this.writableLength > 0) {
+                    // TODO Is this necessary, or does _final already wait for drain?
+                    // Wait for buffer to drain for calling final callback
+                    this.once('drain', () => {
+                        final.call(this, callback);
+                    });
+                    return;
+                }
+                if (this.pending) {
+                    // Wait for pending requests to drop below allowed concurrency
+                    this.on('free', () => {
+                        if (!this.pending) {
+                            final.call(this, callback);
+                        }
+                    });
+                    return;
+                }
+                final.call(this, callback);
+            };
+        }
+    }
+}

package/dist/table.d.ts

@@ -0,0 +1,28 @@
+import { type CreateTableCommandInput, type DeleteTableCommandInput, type DynamoDB, IndexStatus, type TableDescription, TableStatus, type UpdateTimeToLiveCommandOutput } from '@aws-sdk/client-dynamodb';
+import type { EnsureTableInput, RequiredTableName } from './types.ts';
+export type WaitForConnectionOptions = {
+    stabilizeDelay?: number;
+    maxDelay?: number;
+};
+export declare function waitForConnection(client: DynamoDB, options?: WaitForConnectionOptions): Promise<void>;
+export declare function killConnection(client: DynamoDB): void;
+export type WaitForIndexParams = {
+    TableName: string;
+    IndexName: string;
+};
+export type WaitForIndexOperation = typeof IndexStatus.DELETING | typeof IndexStatus.CREATING;
+export declare function waitForIndex(client: DynamoDB, { TableName, IndexName }: WaitForIndexParams, operation: WaitForIndexOperation): Promise<void>;
+export type WaitForTableParams = {
+    TableName: string;
+};
+export type WaitForTableOperation = typeof TableStatus.DELETING | typeof TableStatus.CREATING;
+export declare function waitForTable(client: DynamoDB, { TableName }: WaitForTableParams, operation: WaitForTableOperation): Promise<void>;
+export declare function createTable(client: DynamoDB, input: RequiredTableName<CreateTableCommandInput>): Promise<{
+    TableDescription: TableDescription;
+}>;
+export declare function deleteTable(client: DynamoDB, input: RequiredTableName<DeleteTableCommandInput>): Promise<void>;
+export type EnsureTableOutput = {
+    TableDescription: TableDescription;
+    TimeToLiveSpecification?: UpdateTimeToLiveCommandOutput['TimeToLiveSpecification'];
+};
+export declare function ensureTable(client: DynamoDB, params: EnsureTableInput): Promise<EnsureTableOutput>;

package/dist/table.js

@@ -0,0 +1,161 @@
+import { IndexStatus, ResourceInUseException, ResourceNotFoundException, TableStatus, TimeToLiveStatus, } from '@aws-sdk/client-dynamodb';
+import isEqual from 'lodash/isEqual.js';
+import { delay, getIndexUpdates, isEqualGSI } from "./util.js";
+export async function waitForConnection(client, options = {}) {
+    const attemptDelay = 100;
+    const stabilizeDelay = options.stabilizeDelay ?? 500;
+    const maxDelay = options.maxDelay ?? 5000;
+    const maxAttempts = Math.floor(maxDelay / attemptDelay);
+    let attempts = 0;
+    while (true) {
+        if (maxAttempts > 0 && attempts >= maxAttempts) {
+            throw new Error('Max connection attempts reached');
+        }
+        const tables = await client.listTables().catch(() => undefined);
+        if (tables) {
+            await delay(stabilizeDelay);
+            break;
+        }
+        attempts += 1;
+        await delay(attemptDelay);
+    }
+}
+export function killConnection(client) {
+    client.destroy();
+}
+export async function waitForIndex(client, { TableName, IndexName }, operation) {
+    let creatingOrDeleting = true;
+    while (creatingOrDeleting) {
+        await delay(1000);
+        const tableDescription = await client.describeTable({ TableName });
+        const index = tableDescription.Table?.GlobalSecondaryIndexes?.find((index) => index.IndexName === IndexName);
+        if (operation === IndexStatus.DELETING) {
+            creatingOrDeleting = index?.IndexStatus === IndexStatus.DELETING;
+        }
+        else {
+            creatingOrDeleting = !index || index.IndexStatus === IndexStatus.CREATING;
+        }
+    }
+}
+export async function waitForTable(client, { TableName }, operation) {
+    let creatingOrDeleting = true;
+    while (creatingOrDeleting) {
+        await delay(1000);
+        const tableDescription = await client.describeTable({ TableName });
+        if (operation === TableStatus.DELETING) {
+            creatingOrDeleting = tableDescription?.Table?.TableStatus === TableStatus.DELETING;
+        }
+        else {
+            creatingOrDeleting =
+                !tableDescription?.Table || tableDescription?.Table?.TableStatus === TableStatus.CREATING;
+        }
+    }
+}
+async function updateTableIndexes(client, tableName, tableConfig, indexUpdates) {
+    let result;
+    // Updating the indexes must happen sequentially
+    for (const update of indexUpdates) {
+        // Cannot run simultaneous ops on the same GSI
+        const indexName = update.Delete?.IndexName ?? update.Create?.IndexName;
+        const operation = update.Delete ? IndexStatus.DELETING : IndexStatus.CREATING;
+        if (!indexName) {
+            continue;
+        }
+        result = await client.updateTable({
+            TableName: tableName,
+            AttributeDefinitions: tableConfig.AttributeDefinitions,
+            GlobalSecondaryIndexUpdates: [update],
+        });
+        await waitForIndex(client, { TableName: tableName, IndexName: indexName }, operation);
+    }
+    return result;
+}
+export async function createTable(client, input) {
+    const { TableName } = input;
+    try {
+        const table = await client.describeTable({ TableName });
+        if (!table.Table) {
+            throw new Error(`describeTable returned no Table for ${TableName}`);
+        }
+        return { TableDescription: table.Table };
+    }
+    catch (err) {
+        if (err instanceof ResourceNotFoundException) {
+            try {
+                const table = await client.createTable(input);
+                if (!table.TableDescription) {
+                    throw new Error(`createTable returned no TableDescription for ${TableName}`);
+                }
+                return { TableDescription: table.TableDescription };
+            }
+            catch (err) {
+                if (err instanceof ResourceInUseException) {
+                    await waitForTable(client, { TableName }, TableStatus.CREATING);
+                    const table = await client.describeTable({ TableName });
+                    if (!table.Table) {
+                        throw new Error(`describeTable returned no Table for ${TableName}`);
+                    }
+                    return { TableDescription: table.Table };
+                }
+                throw new Error(`Failed to create ${TableName}`, { cause: err });
+            }
+        }
+        throw new Error(`Failed to create ${TableName}`, { cause: err });
+    }
+}
+export async function deleteTable(client, input) {
+    const { TableName } = input;
+    try {
+        const table = await client.describeTable({ TableName });
+        if (table?.Table?.TableStatus === TableStatus.ACTIVE) {
+            await client.deleteTable(input);
+            await waitForTable(client, { TableName }, TableStatus.DELETING);
+        }
+    }
+    catch (err) {
+        if (err instanceof ResourceNotFoundException) {
+            return;
+        }
+        throw new Error(`Failed to delete ${TableName}`, { cause: err });
+    }
+}
+export async function ensureTable(client, params) {
+    const { TimeToLiveSpecification, ...tableConfig } = params;
+    const { TableName } = tableConfig;
+    let { TableDescription } = await createTable(client, tableConfig);
+    if (tableConfig.StreamSpecification?.StreamEnabled &&
+        !isEqual(TableDescription.StreamSpecification, tableConfig.StreamSpecification)) {
+        TableDescription =
+            (await client.updateTable({
+                TableName,
+                StreamSpecification: tableConfig.StreamSpecification,
+            })).TableDescription ?? TableDescription;
+    }
+    if (tableConfig.GlobalSecondaryIndexes &&
+        !isEqualGSI(TableDescription.GlobalSecondaryIndexes, tableConfig.GlobalSecondaryIndexes)) {
+        const indexUpdates = getIndexUpdates(TableDescription, tableConfig);
+        if (indexUpdates) {
+            TableDescription =
+                (await updateTableIndexes(client, TableName, tableConfig, indexUpdates))
+                    ?.TableDescription ?? TableDescription;
+        }
+    }
+    let updateTimeToLive;
+    if (TimeToLiveSpecification) {
+        const { TimeToLiveDescription } = await client.describeTimeToLive({
+            TableName,
+        });
+        if (TimeToLiveDescription &&
+            (TimeToLiveDescription.TimeToLiveStatus === TimeToLiveStatus.DISABLED ||
+                TimeToLiveDescription.TimeToLiveStatus === TimeToLiveStatus.DISABLING)) {
+            updateTimeToLive = await client.updateTimeToLive({
+                TableName,
+                TimeToLiveSpecification,
+            });
+        }
+    }
+    return {
+        TableDescription,
+        TimeToLiveSpecification: updateTimeToLive?.TimeToLiveSpecification,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,42 @@
+import type { CreateTableCommandInput, GlobalSecondaryIndex, KeySchemaElement, KeyType, LocalSecondaryIndex, UpdateTimeToLiveCommandInput } from '@aws-sdk/client-dynamodb';
+import type { NativeAttributeValue } from '@aws-sdk/util-dynamodb';
+/**
+ * Can represent either a marshalled or unmarshalled document.
+ */
+export type NativeAttributeMap = Record<string, NativeAttributeValue>;
+export type MaybeTableName = {
+    TableName?: string | undefined;
+};
+/**
+ * AWS types make most tables `string | undefined` which is problematic
+ */
+export type RequiredTableName<T extends MaybeTableName> = Omit<T, 'TableName'> & {
+    TableName: string;
+};
+/**
+ * Enforces that a TableName not be present, to avoid confusion in some inputs
+ */
+export type OptionalTableName<T extends MaybeTableName, U extends string | undefined> = U extends string ? Omit<T, 'TableName'> : Omit<T, 'TableName'> & {
+    TableName: string;
+};
+type MaybeCompleteIndex = {
+    IndexName: string | undefined;
+    KeySchema: KeySchemaElement[] | undefined;
+};
+type RequiredCompleteIndex<T extends MaybeCompleteIndex> = Omit<T, 'IndexName' | 'KeySchmaElement'> & {
+    IndexName: string;
+    KeySchema: DynoKeySchemaElement[];
+};
+export type DynoKeySchemaElement = Omit<KeySchemaElement, 'AttributeName' | 'KeyType'> & {
+    AttributeName: string;
+    KeyType: KeyType;
+};
+export type DynoLocalSecondaryIndex = RequiredCompleteIndex<LocalSecondaryIndex>;
+export type DynoGlobalSecondaryIndex = RequiredCompleteIndex<GlobalSecondaryIndex>;
+export type EnsureTableInput = Omit<CreateTableCommandInput, 'TableName' | 'KeySchema' | 'LocalSecondaryIndexes' | 'GlobalSecondaryIndexes'> & {
+    TableName: string;
+    KeySchema: DynoKeySchemaElement[];
+    LocalSecondaryIndexes?: DynoLocalSecondaryIndex[];
+    GlobalSecondaryIndexes?: DynoGlobalSecondaryIndex[];
+} & Partial<UpdateTimeToLiveCommandInput>;
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/util.d.ts

@@ -0,0 +1,32 @@
+import { type AttributeValue, type ConsumedCapacity, type CreateTableCommandInput, type GlobalSecondaryIndexDescription, type GlobalSecondaryIndexUpdate, type TableDescription } from '@aws-sdk/client-dynamodb';
+import type { NativeAttributeMap } from './types.ts';
+export declare function calculateDelay(retryCount: number, retryBase?: number, jitterBase?: number, maxDelay?: number): number;
+/**
+ * Calculate the size in bytes of a DynamoDB record.
+ */
+export declare function itemSize(item: Record<string, AttributeValue>): number;
+export declare function getItemSize(item: NativeAttributeMap): number;
+export declare function readCost(item: NativeAttributeMap): number;
+export declare function writeCost(item: NativeAttributeMap): number;
+export declare function storageCost(item: NativeAttributeMap): number;
+export declare const delay: <T>(timeout: number, value?: T) => Promise<T>;
+/**
+ * Reduce two sets of consumed capacity metrics into a single object
+ * This should be in sync with Callback Parameters section of
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#query-property
+ */
+export declare function reduceCapacity(existing: ConsumedCapacity, incoming: ConsumedCapacity[] | ConsumedCapacity): ConsumedCapacity;
+/**
+ * Get the partition key from a table description
+ */
+export declare function getPartitionKey(tableDescription: TableDescription): {
+    hashKey: string | undefined;
+    rangeKey: string | undefined;
+    keyName: string;
+} | undefined;
+/**
+ * Turn unknown objects into Errors
+ */
+export declare function ensureError(err: unknown, msg?: string): Error;
+export declare function isEqualGSI(a?: GlobalSecondaryIndexDescription[], b?: GlobalSecondaryIndexDescription[]): boolean;
+export declare function getIndexUpdates(oldTable: TableDescription, newTable: CreateTableCommandInput): GlobalSecondaryIndexUpdate[] | undefined;

package/dist/util.js

@@ -0,0 +1,272 @@
+import { TextEncoder } from 'node:util';
+import { KeyType, } from '@aws-sdk/client-dynamodb';
+import { marshall } from '@aws-sdk/util-dynamodb';
+import Big from 'big.js';
+import cloneDeep from 'lodash/cloneDeep.js';
+import difference from 'lodash/difference.js';
+import intersection from 'lodash/intersection.js';
+import isEqual from 'lodash/isEqual.js';
+import isEqualWith from 'lodash/isEqualWith.js';
+import isPlainObject from 'lodash/isPlainObject.js';
+import pick from 'lodash/pick.js';
+export function calculateDelay(retryCount, retryBase = 250, jitterBase = 1000, maxDelay = 20000) {
+    const backoff = retryBase * 2 ** Math.max(0, retryCount);
+    const jitter = Math.random() * jitterBase;
+    return Math.round(Math.min(maxDelay, backoff + jitter));
+}
+const stringSize = (val) => {
+    // Account for size of utf-8 encoded chars in strings, emoji, etc
+    return new TextEncoder().encode(val).length;
+};
+const bufferSize = (val) => {
+    return Buffer.from(val).toString('base64').length;
+};
+const bigNumberSize = (val) => {
+    const v = new Big(val);
+    return Math.ceil(v.c.length / 2) + (v.e % 2 ? 1 : 2);
+};
+/**
+ * Calculate the size in bytes of a DynamoDB record.
+ */
+export function itemSize(item) {
+    let size = 0;
+    const valueSize = (attrVal) => {
+        const type = Object.keys(attrVal)[0];
+        const val = attrVal[type];
+        let vSize = 0;
+        switch (type) {
+            case 'S':
+                vSize += stringSize(val);
+                break;
+            case 'B':
+                vSize += bufferSize(val);
+                break;
+            case 'N':
+                vSize += bigNumberSize(val);
+                break;
+            case 'SS':
+                vSize += val.reduce((sum, v) => sum + stringSize(v), 0);
+                break;
+            case 'BS':
+                vSize += val.reduce((sum, v) => sum + bufferSize(v), 0);
+                break;
+            case 'NS':
+                vSize += val.reduce((sum, v) => sum + bigNumberSize(v), 0);
+                break;
+            case 'M':
+                vSize += itemSize(val);
+                break;
+            case 'L':
+                vSize += val.reduce((sum, v) => sum + valueSize(v), 0);
+                break;
+            case 'BOOL':
+                // Best guess, this is the string length of the boolean
+                vSize += val ? 4 : 5;
+                break;
+            case 'NULL':
+                // String length of null?
+                vSize += 4;
+                break;
+            default:
+                break;
+        }
+        return vSize;
+    };
+    for (const [attributeName, attributeValue] of Object.entries(item)) {
+        size += attributeName.length;
+        size += valueSize(attributeValue);
+    }
+    return size;
+}
+export function getItemSize(item) {
+    return itemSize(marshall(item, { removeUndefinedValues: true }));
+}
+export function readCost(item) {
+    const size = getItemSize(item);
+    return Math.ceil(size / 1024 / 4);
+}
+export function writeCost(item) {
+    const size = getItemSize(item);
+    return Math.ceil(size / 1024);
+}
+export function storageCost(item) {
+    const size = getItemSize(item);
+    return size + 100;
+}
+export const delay = async (timeout, value) => new Promise((resolve) => {
+    setTimeout(resolve, timeout, value);
+});
+/**
+ * Reduce two sets of consumed capacity metrics into a single object
+ * This should be in sync with Callback Parameters section of
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#query-property
+ */
+export function reduceCapacity(existing, incoming) {
+    let target = cloneDeep(existing);
+    if (Array.isArray(incoming)) {
+        for (const item of incoming) {
+            target = reduceCapacity(target, item);
+        }
+        return target;
+    }
+    const mergeCapacityUnits = (dst, src) => {
+        if (src.CapacityUnits) {
+            dst.CapacityUnits = (dst.CapacityUnits ?? 0) + src.CapacityUnits;
+        }
+        if (src.ReadCapacityUnits) {
+            dst.ReadCapacityUnits = (dst.ReadCapacityUnits ?? 0) + src.ReadCapacityUnits;
+        }
+        if (src.WriteCapacityUnits) {
+            dst.WriteCapacityUnits = (dst.WriteCapacityUnits ?? 0) + src.WriteCapacityUnits;
+        }
+    };
+    const mergeCapacityParents = (dst, src, k) => {
+        const s = src[k];
+        const d = dst[k] ?? {};
+        if (!s) {
+            return;
+        }
+        dst[k] = d;
+        mergeCapacityUnits(d, s);
+    };
+    target.Table ??= target.Table ?? {};
+    target.TableName ??= incoming.TableName;
+    mergeCapacityUnits(target, incoming);
+    mergeCapacityUnits(target.Table, incoming.Table ?? {});
+    for (const indexGroup of ['LocalSecondaryIndexes', 'GlobalSecondaryIndexes']) {
+        const dst = target[indexGroup] ?? {};
+        const src = incoming[indexGroup] ?? {};
+        for (const index of Object.keys(src)) {
+            mergeCapacityParents(dst, src, index);
+        }
+        target[indexGroup] = dst;
+    }
+    return target;
+}
+/**
+ * Get the partition key from a table description
+ */
+export function getPartitionKey(tableDescription) {
+    const hashKey = tableDescription.KeySchema?.find((el) => el.KeyType === KeyType.HASH)?.AttributeName;
+    const rangeKey = tableDescription.KeySchema?.find((el) => el.KeyType === KeyType.RANGE)?.AttributeName;
+    if (!hashKey && !rangeKey) {
+        return;
+    }
+    return {
+        hashKey,
+        rangeKey,
+        keyName: [hashKey, rangeKey].filter((x) => x).join('_'),
+    };
+}
+/**
+ * Turn unknown objects into Errors
+ */
+export function ensureError(err, msg = 'Unknown error') {
+    if (err instanceof Error) {
+        return err;
+    }
+    let message = msg;
+    if (err && typeof err === 'object') {
+        message = typeof err.message === 'string' ? err.message : message;
+    }
+    return new Error(message, { cause: err });
+}
+function isRecord(value) {
+    return isPlainObject(value);
+}
+const pickGSIKeys = (gsi) => pick(gsi, ['IndexName', 'KeySchema', 'Projection']);
+const pickGSIList = (gsiList) => gsiList?.map(pickGSIKeys) ?? null;
+const arrayObjectSortKeys = ['AttributeName', 'IndexName'];
+const arraySorter = (a, b) => {
+    if (typeof a === 'string' && typeof b === 'string') {
+        return a.localeCompare(b);
+    }
+    if (isRecord(a) && isRecord(b)) {
+        for (const key of arrayObjectSortKeys) {
+            const aa = a[key];
+            const bb = b[key];
+            if (aa && bb) {
+                return aa.localeCompare(bb);
+            }
+        }
+    }
+    throw new Error('Unexpected config, could not determine if index migration is needed');
+};
+const equalWith = (a, b) => {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        const aSorted = a.sort(arraySorter);
+        const bSorted = b.sort(arraySorter);
+        for (let i = 0; i < aSorted.length; i++) {
+            if (!isEqualWith(aSorted[i], bSorted[i], equalWith)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return undefined;
+};
+export function isEqualGSI(a, b) {
+    return isEqualWith(pickGSIList(a), pickGSIList(b), equalWith);
+}
+function isDefined(x) {
+    return x !== null && x !== undefined;
+}
+function getChangedIndexes(oldIndexList, newIndexList) {
+    const oldIndexes = oldIndexList.map(({ IndexName }) => IndexName) ?? [];
+    const newIndexes = newIndexList.map(({ IndexName }) => IndexName);
+    const added = difference(newIndexes, oldIndexes).filter(isDefined);
+    const removed = difference(oldIndexes, newIndexes).filter(isDefined);
+    let updated = intersection(oldIndexes, newIndexes).filter(isDefined);
+    if (updated.length) {
+        updated = updated.filter((indexName) => {
+            const oldIndex = oldIndexList.find(({ IndexName }) => IndexName === indexName);
+            const newIndex = newIndexList.find(({ IndexName }) => IndexName === indexName);
+            if (!oldIndex && !newIndex) {
+                return false;
+            }
+            return !isEqual(oldIndex ? pickGSIKeys(oldIndex) : undefined, newIndex ? pickGSIKeys(newIndex) : undefined);
+        });
+    }
+    return {
+        added,
+        removed,
+        updated,
+    };
+}
+export function getIndexUpdates(oldTable, newTable) {
+    const oldIndexList = oldTable.GlobalSecondaryIndexes ?? [];
+    const newIndexList = newTable.GlobalSecondaryIndexes ?? [];
+    const { added, removed, updated } = getChangedIndexes(oldIndexList, newIndexList);
+    let indexUpdates = [];
+    if (updated.length) {
+        const updates = updated.flatMap((indexName) => [
+            {
+                Delete: {
+                    IndexName: indexName,
+                },
+            },
+            {
+                Create: newTable.GlobalSecondaryIndexes?.find(({ IndexName }) => IndexName === indexName),
+            },
+        ]);
+        indexUpdates = [...indexUpdates, ...updates];
+    }
+    if (removed.length) {
+        const updates = removed.map((indexName) => ({
+            Delete: {
+                IndexName: indexName,
+            },
+        }));
+        indexUpdates = [...indexUpdates, ...updates];
+    }
+    if (added.length) {
+        const updates = added.map((indexName) => ({
+            Create: newTable.GlobalSecondaryIndexes?.find(({ IndexName }) => IndexName === indexName),
+        }));
+        indexUpdates = [...indexUpdates, ...updates];
+    }
+    return indexUpdates.length ? indexUpdates : undefined;
+}