alchemy 2.0.0-beta.25 → 2.0.0-beta.26

package/lib/AWS/DynamoDB/Table.js

@@ -1,727 +0,0 @@
-import * as dynamodb from "@distilled.cloud/aws/dynamodb";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Schedule from "effect/Schedule";
-import { havePropsChanged, isResolved } from "../../Diff.js";
-import { createPhysicalName } from "../../PhysicalName.js";
-import * as Provider from "../../Provider.js";
-import { Resource } from "../../Resource.js";
-import { createInternalTags, createTagsList, diffTags, hasTags, } from "../../Tags.js";
-/**
- * An Amazon DynamoDB table with optional indexes, PITR, TTL, and stream-aware
- * binding support.
- *
- * `Table` owns the lifecycle of the physical table while the binding contract
- * allows runtime-specific integrations such as Lambda table event sources to
- * request stream configuration without forcing a circular input prop.
- *
- * @section Creating Tables
- * @example Basic Table
- * ```typescript
- * import * as DynamoDB from "alchemy/AWS/DynamoDB";
- *
- * const table = yield* DynamoDB.Table("UsersTable", {
- *   partitionKey: "pk",
- *   attributes: {
- *     pk: "S",
- *   },
- * });
- * ```
- *
- * @example Table with Sort Key and TTL
- * ```typescript
- * const table = yield* DynamoDB.Table("SessionsTable", {
- *   partitionKey: "userId",
- *   sortKey: "sessionId",
- *   attributes: {
- *     userId: "S",
- *     sessionId: "S",
- *     expiresAt: "N",
- *   },
- *   timeToLiveSpecification: {
- *     Enabled: true,
- *     AttributeName: "expiresAt",
- *   },
- * });
- * ```
- *
- * @example Table with Global Secondary Index
- * ```typescript
- * const table = yield* DynamoDB.Table("OrdersTable", {
- *   partitionKey: "pk",
- *   sortKey: "sk",
- *   attributes: {
- *     pk: "S",
- *     sk: "S",
- *     gsi1pk: "S",
- *     gsi1sk: "S",
- *   },
- *   globalSecondaryIndexes: [{
- *     IndexName: "GSI1",
- *     KeySchema: [
- *       { AttributeName: "gsi1pk", KeyType: "HASH" },
- *       { AttributeName: "gsi1sk", KeyType: "RANGE" },
- *     ],
- *     Projection: { ProjectionType: "ALL" },
- *   }],
- * });
- * ```
- *
- * @section Runtime Operations
- * Bind DynamoDB operations in the init phase and use them in runtime
- * handlers. Bindings inject the table name and grant scoped IAM
- * permissions automatically.
- *
- * @example Read and write items
- * ```typescript
- * // init
- * const getItem = yield* DynamoDB.GetItem.bind(table);
- * const putItem = yield* DynamoDB.PutItem.bind(table);
- *
- * return {
- *   fetch: Effect.gen(function* () {
- *     // runtime
- *     yield* putItem({
- *       Item: { pk: { S: "user#123" }, name: { S: "Alice" } },
- *     });
- *     const result = yield* getItem({
- *       Key: { pk: { S: "user#123" } },
- *     });
- *     return yield* HttpServerResponse.json(result.Item);
- *   }),
- * };
- * ```
- *
- * @section DynamoDB Streams
- * Process change data capture events from a DynamoDB table using a
- * Lambda event source mapping. The stream is enabled automatically
- * through the binding contract.
- *
- * @example Process table changes
- * ```typescript
- * // init
- * yield* DynamoDB.streams(table, {
- *   StreamViewType: "NEW_AND_OLD_IMAGES",
- * }).process(
- *   Effect.fn(function* (record) {
- *     yield* Effect.log(`${record.eventName}: ${JSON.stringify(record.dynamodb)}`);
- *   }),
- * );
- * ```
- */
-export const Table = Resource("AWS.DynamoDB.Table");
-export const TableProvider = () => Provider.effect(Table, Effect.gen(function* () {
-    const createTableName = (id, props) => Effect.gen(function* () {
-        return (props.tableName ??
-            (yield* createPhysicalName({
-                id,
-                // see: https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TableDescription.html#DDB-Type-TableDescription-TableName
-                maxLength: 255,
-            })));
-    });
-    const toKeySchema = (props) => [
-        {
-            AttributeName: props.partitionKey,
-            KeyType: "HASH",
-        },
-        ...(props.sortKey
-            ? [
-                {
-                    AttributeName: props.sortKey,
-                    KeyType: "RANGE",
-                },
-            ]
-            : []),
-    ];
-    const toAttributeDefinitions = (attrs) => Object.entries(attrs)
-        .map(([name, type]) => ({
-        AttributeName: name,
-        AttributeType: type,
-    }))
-        .sort((a, b) => a.AttributeName.localeCompare(b.AttributeName));
-    const resolveTableIfOwned = (id, tableName) => 
-    // if it already exists, let's see if it contains tags indicating we (this app+stage) owns it
-    // that would indicate we are in a partial state and can safely take control
-    dynamodb.describeTable({ TableName: tableName }).pipe(Effect.flatMap((r) => dynamodb
-        .listTagsOfResource({
-        // oxlint-disable-next-line no-non-null-asserted-optional-chain
-        ResourceArn: r.Table?.TableArn,
-    })
-        .pipe(Effect.map((tags) => [r, tags.Tags]), Effect.flatMap(Effect.fn(function* ([r, tags]) {
-        if (hasTags(yield* createInternalTags(id), tags)) {
-            return r.Table;
-        }
-        return yield* Effect.fail(new Error("Table tags do not match expected values"));
-    })))));
-    const createTags = Effect.fn(function* (id, tags) {
-        return {
-            ...(yield* createInternalTags(id)),
-            ...tags,
-        };
-    });
-    const normalizeStreamSpecification = (streamSpecification) => streamSpecification?.StreamEnabled === true
-        ? {
-            StreamEnabled: true,
-            StreamViewType: streamSpecification.StreamViewType,
-        }
-        : undefined;
-    const resolveStreamSpecification = (bindings) => Effect.gen(function* () {
-        const requested = bindings
-            .flatMap((binding) => binding.data?.streamSpecification
-            ?.StreamEnabled === true
-            ? [
-                normalizeStreamSpecification(binding.data
-                    ?.streamSpecification),
-            ]
-            : binding.streamSpecification
-                ?.StreamEnabled === true
-                ? [
-                    normalizeStreamSpecification(binding.streamSpecification),
-                ]
-                : [])
-            .filter((spec) => spec !== undefined);
-        if (requested.length === 0) {
-            return undefined;
-        }
-        const [first, ...rest] = requested;
-        if (!first?.StreamViewType) {
-            return yield* Effect.fail(new MissingStreamViewType());
-        }
-        for (const spec of rest) {
-            if (spec.StreamViewType !== first.StreamViewType) {
-                return yield* Effect.fail(new ConflictingStreamViewTypes({
-                    requested: requested.map((item) => item.StreamViewType),
-                }));
-            }
-        }
-        return first;
-    });
-    const isRetryableControlPlaneError = (error) => error._tag === "InternalServerError" ||
-        error._tag === "LimitExceededException" ||
-        error._tag === "ResourceInUseException" ||
-        error._tag === "ResourceNotFoundException";
-    const waitForControlPlaneConvergence = Schedule.fixed("1 second").pipe(Schedule.both(Schedule.recurs(120)));
-    const waitForTableActivationConvergence = Schedule.fixed("10 seconds").pipe(Schedule.both(Schedule.recurs(180)));
-    const waitForGlobalSecondaryIndexesConvergence = Schedule.fixed("10 seconds").pipe(Schedule.both(Schedule.recurs(180)));
-    const waitForDeletionConvergence = Schedule.fixed("1 second").pipe(Schedule.both(Schedule.recurs(90)));
-    const formatPollingElapsed = (elapsedSeconds) => `${elapsedSeconds}s elapsed`;
-    const formatGlobalSecondaryIndexStatuses = (indexes) => JSON.stringify((indexes ?? []).map((index) => ({
-        name: index.IndexName,
-        status: index.IndexStatus,
-        backfilling: index.Backfilling,
-    })));
-    const updateTimeToLive = (tableName, timeToLiveSpecification) => dynamodb
-        .updateTimeToLive({
-        TableName: tableName,
-        TimeToLiveSpecification: timeToLiveSpecification,
-    })
-        .pipe(Effect.retry({
-        while: isRetryableControlPlaneError,
-        schedule: Schedule.exponential(100).pipe(Schedule.both(Schedule.recurs(30))),
-    }));
-    const updateContinuousBackups = (tableName, pointInTimeRecoverySpecification) => dynamodb
-        .updateContinuousBackups({
-        TableName: tableName,
-        PointInTimeRecoverySpecification: pointInTimeRecoverySpecification,
-    })
-        .pipe(Effect.retry({
-        while: (e) => e._tag === "ContinuousBackupsUnavailableException" ||
-            isRetryableControlPlaneError(e),
-        schedule: Schedule.exponential(250).pipe(Schedule.both(Schedule.recurs(30))),
-    }));
-    const waitForTableActive = (session, tableName) => {
-        let elapsedSeconds = 0;
-        let progressMessage = `DynamoDB Table provider: waiting for table ${tableName} to become ACTIVE`;
-        return Effect.gen(function* () {
-            const response = yield* dynamodb.describeTable({
-                TableName: tableName,
-            });
-            if (response.Table?.TableStatus !== "ACTIVE") {
-                progressMessage = `DynamoDB Table provider: table ${tableName} not active yet (status=${response.Table?.TableStatus ?? "undefined"} gsiStatuses=${formatGlobalSecondaryIndexStatuses(response.Table?.GlobalSecondaryIndexes)})`;
-                return yield* Effect.fail(new TableNotActive());
-            }
-            yield* session.note(`DynamoDB Table provider: table ${tableName} is ACTIVE (${formatPollingElapsed(elapsedSeconds)})`);
-            return response.Table;
-        }).pipe(Effect.retry({
-            while: (error) => error._tag === "TableNotActive" ||
-                isRetryableControlPlaneError(error),
-            schedule: waitForTableActivationConvergence.pipe(Schedule.tapOutput(([, attempt]) => {
-                elapsedSeconds = (attempt + 1) * 10;
-                return session.note(`${progressMessage} (${formatPollingElapsed(elapsedSeconds)})`);
-            })),
-        }));
-    };
-    const waitForGlobalSecondaryIndexesStable = (session, tableName, expectedIndexNames) => {
-        let elapsedSeconds = 0;
-        let progressMessage = `DynamoDB Table provider: waiting for GSIs on ${tableName} to stabilize`;
-        return Effect.gen(function* () {
-            const response = yield* dynamodb.describeTable({
-                TableName: tableName,
-            });
-            const table = response.Table;
-            const actualIndexNames = [...(table?.GlobalSecondaryIndexes ?? [])]
-                .map((index) => index.IndexName)
-                .sort();
-            const expected = [...expectedIndexNames].sort();
-            const allActive = (table?.GlobalSecondaryIndexes ?? []).every((index) => index.IndexStatus === "ACTIVE");
-            if (JSON.stringify(actualIndexNames) !== JSON.stringify(expected) ||
-                !allActive) {
-                progressMessage = `DynamoDB Table provider: GSIs for ${tableName} not stable yet (expected=${JSON.stringify(expected)} actual=${JSON.stringify(actualIndexNames)} statuses=${JSON.stringify((table?.GlobalSecondaryIndexes ?? []).map((index) => ({ name: index.IndexName, status: index.IndexStatus })))} tableStatus=${table?.TableStatus ?? "undefined"})`;
-                return yield* Effect.fail(new TableIndexesNotStable());
-            }
-            yield* session.note(`DynamoDB Table provider: GSIs for ${tableName} stabilized (${JSON.stringify(actualIndexNames)}) (${formatPollingElapsed(elapsedSeconds)})`);
-            return table;
-        }).pipe(Effect.retry({
-            while: (error) => error._tag === "TableIndexesNotStable" ||
-                isRetryableControlPlaneError(error),
-            schedule: waitForGlobalSecondaryIndexesConvergence.pipe(Schedule.tapOutput(([, attempt]) => {
-                elapsedSeconds = (attempt + 1) * 10;
-                return session.note(`${progressMessage} (${formatPollingElapsed(elapsedSeconds)})`);
-            })),
-        }));
-    };
-    const waitForTableDeleted = (session, tableName) => {
-        let elapsedSeconds = 0;
-        let progressMessage = `DynamoDB Table provider: waiting for deletion of ${tableName}`;
-        return Effect.gen(function* () {
-            const response = yield* dynamodb.describeTable({
-                TableName: tableName,
-            });
-            progressMessage = `DynamoDB Table provider: table ${tableName} still deleting (status=${response.Table?.TableStatus ?? "undefined"})`;
-            return yield* Effect.fail(new TableStillDeleting());
-        }).pipe(Effect.catchTag("ResourceNotFoundException", () => {
-            return session.note(`DynamoDB Table provider: table ${tableName} deletion confirmed (${formatPollingElapsed(elapsedSeconds)})`);
-        }), Effect.retry({
-            while: (error) => error._tag === "TableStillDeleting" ||
-                isRetryableControlPlaneError(error),
-            schedule: waitForDeletionConvergence.pipe(Schedule.tapOutput(([, attempt]) => {
-                elapsedSeconds = attempt + 1;
-                return session.note(`${progressMessage} (${formatPollingElapsed(elapsedSeconds)})`);
-            })),
-        }));
-    };
-    const deleteGlobalSecondaryIndexes = (session, tableName) => Effect.gen(function* () {
-        const response = yield* dynamodb
-            .describeTable({
-            TableName: tableName,
-        })
-            .pipe(Effect.retry({
-            while: isRetryableControlPlaneError,
-            schedule: waitForControlPlaneConvergence,
-        }), Effect.catchTag("ResourceNotFoundException", () => Effect.succeed({ Table: undefined })));
-        const indexNames = [...(response.Table?.GlobalSecondaryIndexes ?? [])]
-            .map((index) => index.IndexName)
-            .sort();
-        if (indexNames.length === 0) {
-            yield* session.note(`DynamoDB Table provider: no GSIs remain on ${tableName}; retrying table deletion`);
-            return;
-        }
-        yield* session.note(`DynamoDB Table provider: deleting GSIs before deleting table ${tableName} (${indexNames.join(", ")})`);
-        yield* waitForGlobalSecondaryIndexesStable(session, tableName, indexNames);
-        const remainingIndexNames = [...indexNames];
-        for (const indexName of indexNames) {
-            let elapsedSeconds = 0;
-            let progressMessage = `DynamoDB Table provider: waiting to delete GSI ${indexName} from ${tableName}`;
-            yield* session.note(`DynamoDB Table provider: deleting GSI ${indexName} from ${tableName}`);
-            yield* dynamodb
-                .updateTable({
-                TableName: tableName,
-                GlobalSecondaryIndexUpdates: [
-                    {
-                        Delete: {
-                            IndexName: indexName,
-                        },
-                    },
-                ],
-            })
-                .pipe(Effect.timeout(1000), Effect.tap(() => session.note(`DynamoDB Table provider: delete accepted for GSI ${indexName} on ${tableName} (${formatPollingElapsed(elapsedSeconds)})`)), Effect.retry({
-                while: (error) => {
-                    if (error._tag === "ResourceInUseException") {
-                        progressMessage = `DynamoDB Table provider: delete for GSI ${indexName} on ${tableName} is blocked while the table or indexes are still transitioning`;
-                        return true;
-                    }
-                    if (error._tag === "TimeoutError") {
-                        progressMessage = `DynamoDB Table provider: delete for GSI ${indexName} on ${tableName} timed out`;
-                        return true;
-                    }
-                    if (error._tag === "InternalServerError" ||
-                        error._tag === "LimitExceededException") {
-                        progressMessage = `DynamoDB Table provider: delete for GSI ${indexName} on ${tableName} hit ${error._tag}`;
-                        return true;
-                    }
-                    return false;
-                },
-                schedule: waitForGlobalSecondaryIndexesConvergence.pipe(Schedule.tapOutput(([, attempt]) => {
-                    elapsedSeconds = (attempt + 1) * 10;
-                    return session.note(`${progressMessage} (${formatPollingElapsed(elapsedSeconds)})`);
-                })),
-            }));
-            remainingIndexNames.splice(remainingIndexNames.indexOf(indexName), 1);
-            yield* waitForGlobalSecondaryIndexesStable(session, tableName, remainingIndexNames);
-        }
-    });
-    const readTableState = (tableName) => Effect.gen(function* () {
-        const response = yield* dynamodb
-            .describeTable({
-            TableName: tableName,
-        })
-            .pipe(Effect.retry({
-            while: isRetryableControlPlaneError,
-            schedule: Schedule.exponential(250).pipe(Schedule.both(Schedule.recurs(30))),
-        }));
-        const table = response.Table;
-        if (!table?.TableArn) {
-            return yield* Effect.fail(new Error(`Table ${tableName} not found`));
-        }
-        const [tagsResult, continuousBackupsResult] = yield* Effect.all([
-            dynamodb
-                .listTagsOfResource({
-                ResourceArn: table.TableArn,
-            })
-                .pipe(Effect.retry({
-                while: isRetryableControlPlaneError,
-                schedule: Schedule.exponential(250).pipe(Schedule.both(Schedule.recurs(30))),
-            })),
-            dynamodb
-                .describeContinuousBackups({
-                TableName: tableName,
-            })
-                .pipe(Effect.retry({
-                while: (e) => e._tag === "InternalServerError",
-                schedule: Schedule.exponential(250).pipe(Schedule.both(Schedule.recurs(30))),
-            }), Effect.catchTag("TableNotFoundException", () => Effect.succeed({ ContinuousBackupsDescription: undefined }))),
-        ]);
-        return {
-            table,
-            tags: Object.fromEntries((tagsResult.Tags ?? []).map((tag) => [tag.Key, tag.Value])),
-            pointInTimeRecoveryDescription: continuousBackupsResult.ContinuousBackupsDescription
-                ?.PointInTimeRecoveryDescription,
-        };
-    }).pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.succeed(undefined)));
-    const toAttrs = (state) => ({
-        tableId: state.table.TableId,
-        tableName: state.table.TableName,
-        tableArn: state.table.TableArn,
-        partitionKey: state.table.KeySchema?.find((key) => key.KeyType === "HASH")
-            ?.AttributeName ?? "",
-        sortKey: state.table.KeySchema?.find((key) => key.KeyType === "RANGE")
-            ?.AttributeName,
-        latestStreamArn: state.table.LatestStreamArn,
-        streamSpecification: state.table.StreamSpecification,
-        localSecondaryIndexes: state.table.LocalSecondaryIndexes,
-        globalSecondaryIndexes: state.table.GlobalSecondaryIndexes,
-        pointInTimeRecoveryDescription: state.pointInTimeRecoveryDescription,
-        tags: state.tags,
-    });
-    const indexesByName = (indexes) => Object.fromEntries((indexes ?? []).map((index) => [index.IndexName, index]));
-    const sortKeySchema = (keySchema) => [...(keySchema ?? [])].sort((a, b) => `${a.KeyType}:${a.AttributeName}`.localeCompare(`${b.KeyType}:${b.AttributeName}`));
-    const normalizeProjection = (projection) => ({
-        ...projection,
-        NonKeyAttributes: [...(projection?.NonKeyAttributes ?? [])].sort(),
-    });
-    const isSameGsiDefinition = (left, right) => JSON.stringify(sortKeySchema(left.KeySchema)) ===
-        JSON.stringify(sortKeySchema(right.KeySchema)) &&
-        JSON.stringify(normalizeProjection(left.Projection)) ===
-            JSON.stringify(normalizeProjection(right.Projection));
-    const diffGlobalSecondaryIndexes = (olds, news) => {
-        const oldByName = indexesByName(olds);
-        const newByName = indexesByName(news);
-        const updates = [];
-        let requiresReplacement = false;
-        for (const [indexName, oldIndex] of Object.entries(oldByName)) {
-            const newIndex = newByName[indexName];
-            if (!newIndex) {
-                updates.push({
-                    Delete: {
-                        IndexName: indexName,
-                    },
-                });
-                continue;
-            }
-            if (!isSameGsiDefinition(oldIndex, newIndex)) {
-                requiresReplacement = true;
-                continue;
-            }
-            if (JSON.stringify(oldIndex.ProvisionedThroughput) !==
-                JSON.stringify(newIndex.ProvisionedThroughput) ||
-                JSON.stringify(oldIndex.OnDemandThroughput) !==
-                    JSON.stringify(newIndex.OnDemandThroughput) ||
-                JSON.stringify(oldIndex.WarmThroughput) !==
-                    JSON.stringify(newIndex.WarmThroughput)) {
-                updates.push({
-                    Update: {
-                        IndexName: indexName,
-                        ProvisionedThroughput: newIndex.ProvisionedThroughput,
-                        OnDemandThroughput: newIndex.OnDemandThroughput,
-                        WarmThroughput: newIndex.WarmThroughput,
-                    },
-                });
-            }
-        }
-        for (const [indexName, newIndex] of Object.entries(newByName)) {
-            if (!oldByName[indexName]) {
-                updates.push({
-                    Create: {
-                        IndexName: indexName,
-                        KeySchema: newIndex.KeySchema,
-                        Projection: newIndex.Projection,
-                        ProvisionedThroughput: newIndex.ProvisionedThroughput,
-                        OnDemandThroughput: newIndex.OnDemandThroughput,
-                        WarmThroughput: newIndex.WarmThroughput,
-                    },
-                });
-            }
-        }
-        return {
-            updates,
-            requiresReplacement,
-        };
-    };
-    return Table.Provider.of({
-        stables: ["tableName", "tableId", "tableArn"],
-        read: Effect.fn(function* ({ output }) {
-            if (!output)
-                return undefined;
-            const state = yield* readTableState(output.tableName);
-            if (!state)
-                return undefined;
-            return toAttrs(state);
-        }),
-        diff: Effect.fn(function* ({ news, olds }) {
-            if (!isResolved(news))
-                return undefined;
-            if (
-            // TODO(sam): if the name is hard-coded, REPLACE is impossible - we need a suffix
-            news.tableName !== olds.tableName ||
-                olds.partitionKey !== news.partitionKey ||
-                olds.sortKey !== news.sortKey) {
-                return { action: "replace" };
-            }
-            for (const [name, type] of Object.entries(olds.attributes)) {
-                if (news.attributes[name] !== type) {
-                    return { action: "replace" };
-                }
-            }
-            if (havePropsChanged({ localSecondaryIndexes: olds.localSecondaryIndexes ?? [] }, { localSecondaryIndexes: news.localSecondaryIndexes ?? [] })) {
-                return { action: "replace" };
-            }
-            const { requiresReplacement } = diffGlobalSecondaryIndexes(olds.globalSecondaryIndexes, news.globalSecondaryIndexes);
-            if (requiresReplacement) {
-                return { action: "replace" };
-            }
-            // TODO(sam):
-            // Replacements:
-            // 1. if you change ImportSourceSpecification
-        }),
-        create: Effect.fn(function* ({ id, news, session, bindings }) {
-            const tableName = yield* createTableName(id, news);
-            const allTags = yield* createTags(id, news.tags);
-            const streamSpecification = yield* resolveStreamSpecification(bindings);
-            yield* session.note(`Table ${tableName}: resolved stream specification ${JSON.stringify(streamSpecification)}`);
-            yield* dynamodb
-                .createTable({
-                TableName: tableName,
-                TableClass: news.tableClass,
-                KeySchema: toKeySchema(news),
-                AttributeDefinitions: toAttributeDefinitions(news.attributes),
-                LocalSecondaryIndexes: news.localSecondaryIndexes,
-                GlobalSecondaryIndexes: news.globalSecondaryIndexes,
-                BillingMode: news.billingMode ?? "PAY_PER_REQUEST",
-                SSESpecification: news.sseSpecification,
-                StreamSpecification: streamSpecification,
-                WarmThroughput: news.warmThroughput,
-                DeletionProtectionEnabled: news.deletionProtectionEnabled,
-                OnDemandThroughput: news.onDemandThroughput,
-                ProvisionedThroughput: news.provisionedThroughput,
-                Tags: createTagsList(allTags),
-            })
-                .pipe(Effect.retry({
-                while: (e) => e._tag === "LimitExceededException" ||
-                    e._tag === "InternalServerError",
-                schedule: Schedule.exponential(100),
-            }), Effect.catchTag("ResourceInUseException", () => resolveTableIfOwned(id, tableName)));
-            yield* waitForTableActive(session, tableName);
-            if (news.pointInTimeRecoverySpecification) {
-                yield* updateContinuousBackups(tableName, news.pointInTimeRecoverySpecification);
-            }
-            if (news.timeToLiveSpecification) {
-                yield* updateTimeToLive(tableName, news.timeToLiveSpecification);
-            }
-            if ((news.globalSecondaryIndexes?.length ?? 0) > 0) {
-                yield* waitForGlobalSecondaryIndexesStable(session, tableName, news.globalSecondaryIndexes?.map((index) => index.IndexName) ??
-                    []);
-            }
-            const state = yield* readTableState(tableName);
-            if (!state) {
-                return yield* Effect.fail(new Error(`Failed to read created table ${tableName}`));
-            }
-            yield* session.note(state.table.TableArn);
-            return {
-                ...toAttrs(state),
-                tags: allTags,
-            };
-        }),
-        update: Effect.fn(function* ({ id, output, news, olds, session, bindings, }) {
-            const desiredStreamSpecification = yield* resolveStreamSpecification(bindings);
-            const currentStreamSpecification = normalizeStreamSpecification(output.streamSpecification);
-            yield* session.note(`Table ${output.tableName}: current stream=${JSON.stringify(currentStreamSpecification)} desired stream=${JSON.stringify(desiredStreamSpecification)}`);
-            const streamViewTypeChanged = currentStreamSpecification?.StreamEnabled === true &&
-                desiredStreamSpecification?.StreamEnabled === true &&
-                currentStreamSpecification.StreamViewType !==
-                    desiredStreamSpecification.StreamViewType;
-            if (streamViewTypeChanged) {
-                yield* dynamodb.updateTable({
-                    TableName: output.tableName,
-                    StreamSpecification: {
-                        StreamEnabled: false,
-                    },
-                });
-                yield* waitForTableActive(session, output.tableName);
-            }
-            const { updates: globalSecondaryIndexUpdates } = diffGlobalSecondaryIndexes(olds.globalSecondaryIndexes, news.globalSecondaryIndexes);
-            const hasBaseUpdate = havePropsChanged({
-                tableClass: olds.tableClass,
-                attributes: olds.attributes,
-                billingMode: olds.billingMode ?? "PAY_PER_REQUEST",
-                sseSpecification: olds.sseSpecification,
-                warmThroughput: olds.warmThroughput,
-                deletionProtectionEnabled: olds.deletionProtectionEnabled,
-                onDemandThroughput: olds.onDemandThroughput,
-                provisionedThroughput: olds.provisionedThroughput,
-            }, {
-                tableClass: news.tableClass,
-                attributes: news.attributes,
-                billingMode: news.billingMode ?? "PAY_PER_REQUEST",
-                sseSpecification: news.sseSpecification,
-                warmThroughput: news.warmThroughput,
-                deletionProtectionEnabled: news.deletionProtectionEnabled,
-                onDemandThroughput: news.onDemandThroughput,
-                provisionedThroughput: news.provisionedThroughput,
-            });
-            if (hasBaseUpdate) {
-                yield* dynamodb.updateTable({
-                    TableName: output.tableName,
-                    TableClass: news.tableClass,
-                    AttributeDefinitions: toAttributeDefinitions(news.attributes),
-                    BillingMode: news.billingMode ?? "PAY_PER_REQUEST",
-                    SSESpecification: news.sseSpecification,
-                    WarmThroughput: news.warmThroughput,
-                    DeletionProtectionEnabled: news.deletionProtectionEnabled,
-                    OnDemandThroughput: news.onDemandThroughput,
-                    ProvisionedThroughput: news.provisionedThroughput,
-                });
-                yield* waitForTableActive(session, output.tableName);
-            }
-            if (havePropsChanged({ streamSpecification: currentStreamSpecification }, { streamSpecification: desiredStreamSpecification })) {
-                yield* session.note(`Table ${output.tableName}: updating stream configuration`);
-                yield* dynamodb.updateTable({
-                    TableName: output.tableName,
-                    StreamSpecification: desiredStreamSpecification ?? {
-                        StreamEnabled: false,
-                    },
-                });
-                yield* waitForTableActive(session, output.tableName);
-            }
-            for (const globalSecondaryIndexUpdate of globalSecondaryIndexUpdates) {
-                const action = globalSecondaryIndexUpdate.Create
-                    ? `create ${globalSecondaryIndexUpdate.Create.IndexName}`
-                    : globalSecondaryIndexUpdate.Update
-                        ? `update ${globalSecondaryIndexUpdate.Update.IndexName}`
-                        : `delete ${globalSecondaryIndexUpdate.Delete.IndexName}`;
-                yield* session.note(`Table ${output.tableName}: applying GSI update (${action})`);
-                yield* dynamodb.updateTable({
-                    TableName: output.tableName,
-                    AttributeDefinitions: toAttributeDefinitions(news.attributes),
-                    GlobalSecondaryIndexUpdates: [globalSecondaryIndexUpdate],
-                });
-                yield* waitForTableActive(session, output.tableName);
-            }
-            if (globalSecondaryIndexUpdates.length > 0) {
-                yield* session.note(`Table ${output.tableName}: waiting for GSIs to stabilize (${(news.globalSecondaryIndexes?.map((index) => index.IndexName) ?? []).join(", ") || "none"})`);
-                yield* waitForGlobalSecondaryIndexesStable(session, output.tableName, news.globalSecondaryIndexes?.map((index) => index.IndexName) ??
-                    []);
-                yield* session.note(`Table ${output.tableName}: GSIs stabilized`);
-            }
-            if (news.timeToLiveSpecification &&
-                (news.timeToLiveSpecification.AttributeName !==
-                    olds.timeToLiveSpecification?.AttributeName ||
-                    news.timeToLiveSpecification?.Enabled !==
-                        olds.timeToLiveSpecification?.Enabled)) {
-                // TODO(sam): can this run in parallel?
-                yield* updateTimeToLive(output.tableName, news.timeToLiveSpecification);
-            }
-            if (JSON.stringify(news.pointInTimeRecoverySpecification) !==
-                JSON.stringify(olds.pointInTimeRecoverySpecification)) {
-                yield* updateContinuousBackups(output.tableName, {
-                    PointInTimeRecoveryEnabled: news.pointInTimeRecoverySpecification
-                        ?.PointInTimeRecoveryEnabled ?? false,
-                    RecoveryPeriodInDays: news.pointInTimeRecoverySpecification?.RecoveryPeriodInDays,
-                });
-            }
-            const oldTags = yield* createTags(id, olds.tags);
-            const newTags = yield* createTags(id, news.tags);
-            const { removed, upsert } = diffTags(oldTags, newTags);
-            if (removed.length > 0) {
-                yield* dynamodb.untagResource({
-                    ResourceArn: output.tableArn,
-                    TagKeys: removed,
-                });
-            }
-            if (upsert.length > 0) {
-                yield* dynamodb.tagResource({
-                    ResourceArn: output.tableArn,
-                    Tags: upsert,
-                });
-            }
-            const state = yield* readTableState(output.tableName);
-            if (!state) {
-                return yield* Effect.fail(new Error(`Failed to read updated table ${output.tableName}`));
-            }
-            return {
-                ...toAttrs(state),
-                tags: newTags,
-            };
-        }),
-        delete: Effect.fn(function* ({ output, session }) {
-            let deleteAttempt = 0;
-            while (true) {
-                deleteAttempt += 1;
-                yield* session.note(`Table ${output.tableName}: deleting (attempt ${deleteAttempt})`);
-                const deleteResult = yield* dynamodb
-                    .deleteTable({
-                    TableName: output.tableName,
-                })
-                    .pipe(Effect.timeout(1000), Effect.as("accepted"), Effect.catchTag("ResourceNotFoundException", () => Effect.succeed("already-deleted")), Effect.catchTag("ResourceInUseException", () => Effect.succeed("delete-gsis-first")), Effect.retry({
-                    while: (error) => error._tag === "InternalServerError" ||
-                        error._tag === "TimeoutError",
-                    schedule: waitForDeletionConvergence.pipe(Schedule.tapOutput(([, attempt]) => session.note(`DynamoDB Table provider: deleteTable transient failure for ${output.tableName} on attempt ${deleteAttempt} (${formatPollingElapsed(attempt + 1)})`))),
-                }));
-                if (deleteResult === "accepted") {
-                    yield* session.note(`DynamoDB Table provider: deleteTable accepted for ${output.tableName}`);
-                    break;
-                }
-                if (deleteResult === "already-deleted") {
-                    yield* session.note(`DynamoDB Table provider: table ${output.tableName} already deleted`);
-                    return;
-                }
-                yield* session.note(`DynamoDB Table provider: deleteTable blocked for ${output.tableName}; deleting GSIs first`);
-                yield* deleteGlobalSecondaryIndexes(session, output.tableName);
-                yield* waitForGlobalSecondaryIndexesStable(session, output.tableName, []);
-                yield* waitForTableActive(session, output.tableName);
-            }
-            yield* session.note(`Table ${output.tableName}: waiting for deletion`);
-            yield* waitForTableDeleted(session, output.tableName);
-        }),
-    });
-}));
-class TableNotActive extends Data.TaggedError("TableNotActive") {
-}
-class TableIndexesNotStable extends Data.TaggedError("TableIndexesNotStable") {
-}
-class TableStillDeleting extends Data.TaggedError("TableStillDeleting") {
-}
-class MissingStreamViewType extends Data.TaggedError("MissingStreamViewType") {
-}
-class ConflictingStreamViewTypes extends Data.TaggedError("ConflictingStreamViewTypes") {
-}
-//# sourceMappingURL=Table.js.map