effect-dynamodb 0.1.0

package/dist/DynamoClient.js

@@ -0,0 +1,653 @@
+/**
+ * DynamoClient — Effect service wrapping the AWS SDK DynamoDBClient.
+ *
+ * All DynamoDB operations are exposed as Effect-returning methods that fail
+ * with {@link DynamoError}. The underlying SDK client lifecycle is managed
+ * via `Layer.scoped` (acquire on layer build, destroy on scope close).
+ *
+ * @module
+ */
+import { BatchGetItemCommand, BatchWriteItemCommand, CreateBackupCommand, CreateTableCommand, DeleteBackupCommand, DeleteItemCommand, DeleteTableCommand, DescribeContinuousBackupsCommand, DescribeExportCommand, DescribeTableCommand, DescribeTimeToLiveCommand, DynamoDBClient, ExportTableToPointInTimeCommand, GetItemCommand, ListBackupsCommand, ListTablesCommand, ListTagsOfResourceCommand, PutItemCommand, QueryCommand, RestoreTableFromBackupCommand, RestoreTableToPointInTimeCommand, ScanCommand, TagResourceCommand, TransactGetItemsCommand, TransactWriteItemsCommand, UntagResourceCommand, UpdateContinuousBackupsCommand, UpdateItemCommand, UpdateTableCommand, UpdateTimeToLiveCommand, } from "@aws-sdk/client-dynamodb";
+import { Config, Context, Effect, Layer } from "effect";
+import { bind as aggregateBind } from "./Aggregate.js";
+import * as DynamoSchema from "./DynamoSchema.js";
+import { bind as entityBind } from "./Entity.js";
+import { DynamoError, DynamoValidationError, InternalServerError, isAwsInternalServerError, isAwsResourceNotFound, isAwsThrottling, isAwsValidationError, ResourceNotFoundError, ThrottlingError, ValidationError, } from "./Errors.js";
+import { BoundQueryImpl } from "./internal/BoundQuery.js";
+import { createConditionOps } from "./internal/Expr.js";
+import { createPathBuilder } from "./internal/PathBuilder.js";
+import * as KeyComposer from "./KeyComposer.js";
+import * as Query from "./Query.js";
+import { definition as tableDefinition } from "./Table.js";
+/**
+ * Effect Context.Service for the DynamoDB client service.
+ *
+ * Use `DynamoClient.layer(config)` to construct a live Layer that manages
+ * the underlying AWS SDK client lifecycle with `Effect.acquireRelease`.
+ *
+ * @example
+ * ```typescript
+ * const live = DynamoClient.layer({ region: "us-east-1" })
+ * pipe(program, Effect.provide(live), Effect.runPromise)
+ * ```
+ */
+export class DynamoClient extends Context.Service()("@effect-dynamodb/DynamoClient") {
+    /**
+     * Create a live Layer that manages an AWS DynamoDBClient.
+     *
+     * @param config.region - AWS region
+     * @param config.endpoint - Optional endpoint override (e.g., for DynamoDB Local)
+     * @param config.credentials - Optional static credentials
+     */
+    static layer = (config) => Layer.effect(DynamoClient, buildService(config.region, config.endpoint, config.credentials));
+    /**
+     * Create a live Layer that reads configuration from Effect Config providers
+     * (e.g., environment variables, config files).
+     *
+     * @param config.region - Config for AWS region
+     * @param config.endpoint - Optional Config for endpoint override
+     * @param config.credentials - Optional Config for static credentials
+     */
+    static layerConfig = (config) => Layer.effect(DynamoClient, Effect.gen(function* () {
+        const region = yield* config.region;
+        const endpoint = config.endpoint ? yield* Config.option(config.endpoint) : undefined;
+        const credentials = config.credentials
+            ? yield* Config.option(config.credentials)
+            : undefined;
+        return yield* buildService(region, endpoint && endpoint._tag === "Some" ? endpoint.value : undefined, credentials && credentials._tag === "Some" ? credentials.value : undefined);
+    }));
+    /**
+     * Create a typed client gateway from entities, aggregates, and (optionally) tables.
+     *
+     * Returns a namespaced client with `entities`, `aggregates`, `collections`, and
+     * `tables` properties. Collections are auto-discovered from entity index
+     * `collection` properties — no separate registration needed.
+     *
+     * @example
+     * ```typescript
+     * const db = yield* DynamoClient.make({
+     *   entities: { Users, Tasks },
+     *   aggregates: { OrderAggregate },
+     *   tables: { MainTable },
+     * })
+     *
+     * yield* db.entities.Users.get({ userId: "123" })
+     * yield* db.aggregates.OrderAggregate.get({ orderId: "o-1" })
+     * yield* db.collections.assignments({ userId: "123" }).collect()
+     * yield* db.tables.MainTable.create()
+     * ```
+     */
+    static make = (config) => makeFromConfig(config);
+}
+const makeFromConfig = (config) => Effect.gen(function* () {
+    // 1. Resolve the provide function from context
+    const ctx = yield* Effect.context();
+    const provide = (effect) => Effect.provide(effect, ctx);
+    // Helper: validate query composites at runtime
+    const validateQueryComposites = (indexName, indexDef, composites) => {
+        const pkAttrs = indexDef.pk.composite;
+        const skAttrs = indexDef.sk.composite;
+        // 1. All PK composites must be present
+        for (const attr of pkAttrs) {
+            if (composites[attr] === undefined) {
+                throw new Error(`[EDD-9002] Missing required partition key attribute "${attr}" for index "${indexName}"`);
+            }
+        }
+        // 2. SK composites must follow prefix ordering
+        let lastProvided = -1;
+        for (let i = 0; i < skAttrs.length; i++) {
+            if (composites[skAttrs[i]] !== undefined) {
+                if (i !== lastProvided + 1) {
+                    const missing = skAttrs.slice(lastProvided + 1, i).join(", ");
+                    throw new Error(`[EDD-9004] Sort key composite "${skAttrs[i]}" for index "${indexName}" requires prior composites: ${missing}. Sort key composites must follow prefix ordering.`);
+                }
+                lastProvided = i;
+            }
+        }
+        // 3. No excess properties
+        const validKeys = new Set([...pkAttrs, ...skAttrs]);
+        for (const key of Object.keys(composites)) {
+            if (!validKeys.has(key)) {
+                throw new Error(`[EDD-9006] Unknown composite attribute "${key}" for index "${indexName}". Valid attributes: ${[...validKeys].join(", ")}`);
+            }
+        }
+    };
+    // Helper: build a BoundQuery for a single-entity index query
+    const buildEntityQueryAccessor = (entityLike, _indexName, indexDef) => {
+        return (composites) => {
+            validateQueryComposites(_indexName, indexDef, composites);
+            const pkValue = KeyComposer.composePk(entityLike._schema, entityLike.entityType, indexDef, composites);
+            const query = Query.make({
+                tableName: "",
+                indexName: indexDef.index,
+                pkField: indexDef.pk.field,
+                pkValue,
+                skField: indexDef.sk.field,
+                entityTypes: [entityLike.entityType],
+                decoder: (raw) => entityLike._decodeRecord(raw),
+                resolveTableName: entityLike._tableTag.useSync((tc) => tc.name),
+            });
+            // Apply SK prefix from provided composites
+            const hasSkComposites = indexDef.sk.composite.some((attr) => composites[attr] !== undefined);
+            const finalQuery = hasSkComposites
+                ? Query.where(query, {
+                    beginsWith: KeyComposer.composeSortKeyPrefix(entityLike._schema, entityLike.entityType, 1, indexDef, composites),
+                })
+                : query;
+            const pathBuilder = createPathBuilder();
+            const conditionOps = createConditionOps();
+            // composeSkCondition: prepend the entity SK prefix to user's .where() condition
+            const composeSkCondition = (condition) => {
+                const skPrefix = KeyComposer.composeSortKeyPrefix(entityLike._schema, entityLike.entityType, 1, indexDef, composites);
+                const prepend = (value) => `${skPrefix}#${value}`;
+                if ("eq" in condition)
+                    return { eq: prepend(condition.eq) };
+                if ("lt" in condition)
+                    return { lt: prepend(condition.lt) };
+                if ("lte" in condition)
+                    return { lte: prepend(condition.lte) };
+                if ("gt" in condition)
+                    return { gt: prepend(condition.gt) };
+                if ("gte" in condition)
+                    return { gte: prepend(condition.gte) };
+                if ("between" in condition)
+                    return { between: [prepend(condition.between[0]), prepend(condition.between[1])] };
+                if ("beginsWith" in condition)
+                    return { beginsWith: prepend(condition.beginsWith) };
+                return condition;
+            };
+            const bqConfig = {
+                pathBuilder,
+                conditionOps,
+                provide,
+                composeSkCondition,
+                skFields: indexDef.sk.composite,
+            };
+            return new BoundQueryImpl(finalQuery, bqConfig);
+        };
+    };
+    // 2. Bind entities + build entity query accessors
+    const boundEntities = {};
+    // Track collection memberships for auto-discovery
+    // collectionName → { entityKey, entityLike, indexName, indexDef }[]
+    const collectionMembers = new Map();
+    for (const [key, entity] of Object.entries(config.entities)) {
+        const bound = yield* entityBind(entity);
+        const entityLike = entity;
+        const accessors = {};
+        // Add query accessor for each non-primary index
+        for (const [indexName, indexDef] of Object.entries(entityLike.indexes)) {
+            if (indexName === "primary")
+                continue;
+            if (!indexDef)
+                continue;
+            accessors[indexName] = buildEntityQueryAccessor(entityLike, indexName, indexDef);
+            // Track collection membership for auto-discovery
+            if (indexDef.collection) {
+                const collNames = Array.isArray(indexDef.collection)
+                    ? indexDef.collection
+                    : [indexDef.collection];
+                for (const collName of collNames) {
+                    if (!collectionMembers.has(collName)) {
+                        collectionMembers.set(collName, []);
+                    }
+                    collectionMembers.get(collName).push({ entityKey: key, entityLike, indexDef });
+                }
+            }
+        }
+        // Add scan accessor
+        accessors.scan = () => {
+            const scanQuery = Query.makeScan({
+                tableName: "",
+                indexName: undefined,
+                entityTypes: [entityLike.entityType],
+                decoder: (raw) => entityLike._decodeRecord(raw),
+                resolveTableName: entityLike._tableTag.useSync((tc) => tc.name),
+            });
+            const pathBuilder = createPathBuilder();
+            const conditionOps = createConditionOps();
+            const bqConfig = { pathBuilder, conditionOps, provide };
+            return new BoundQueryImpl(scanQuery, bqConfig);
+        };
+        boundEntities[key] = { ...bound, ...accessors };
+    }
+    // 3. Build auto-discovered collection accessors
+    const boundCollections = {};
+    for (const [collName, members] of collectionMembers) {
+        boundCollections[collName] = (composites) => {
+            // Use the first member for PK composition
+            const firstMember = members[0];
+            const indexDef = firstMember.indexDef;
+            // Build entity type → entity key lookup
+            const memberByType = new Map();
+            const entityTypes = [];
+            for (const member of members) {
+                memberByType.set(member.entityLike.entityType, member.entityKey);
+                entityTypes.push(member.entityLike.entityType);
+            }
+            // Collection decoder: decode and group by entity key
+            const collDecoder = (raw) => {
+                const entityType = raw.__edd_e__;
+                if (!entityType) {
+                    return Effect.fail(new ValidationError({
+                        entityType: "unknown",
+                        operation: "collection.decode",
+                        cause: "Item missing __edd_e__",
+                    }));
+                }
+                const entityKey = memberByType.get(entityType);
+                if (!entityKey) {
+                    return Effect.succeed({ _memberKey: "__unknown__", _decoded: raw });
+                }
+                const member = members.find((m) => m.entityLike.entityType === entityType);
+                if (!member) {
+                    return Effect.succeed({ _memberKey: "__unknown__", _decoded: raw });
+                }
+                return member.entityLike
+                    ._decodeRecord(raw)
+                    .pipe(Effect.map((decoded) => ({ _memberKey: entityKey, _decoded: decoded })));
+            };
+            const pkValue = KeyComposer.composePk(firstMember.entityLike._schema, firstMember.entityLike.entityType, indexDef, composites);
+            // Always isolated — begins_with on collection SK prefix
+            let query = Query.make({
+                tableName: "",
+                indexName: indexDef.index,
+                pkField: indexDef.pk.field,
+                pkValue,
+                skField: indexDef.sk.field,
+                entityTypes,
+                decoder: collDecoder,
+                resolveTableName: firstMember.entityLike._tableTag.useSync((tc) => tc.name),
+            });
+            // Add begins_with on collection SK prefix for clustered collections.
+            // For isolated collections (default), each entity has its own entity-type
+            // SK prefix, so a collection-name begins_with would filter them all out.
+            //
+            // For sub-collections (collection: ["parent", "child"]), the SK prefix
+            // includes the full hierarchy from root up to and including the queried
+            // collection name. A query at the parent level matches every descendant.
+            if (indexDef.sk.field && indexDef.type === "clustered") {
+                const coll = indexDef.collection;
+                const hierarchy = Array.isArray(coll)
+                    ? coll.slice(0, coll.indexOf(collName) + 1)
+                    : [collName];
+                const casing = indexDef.casing ?? firstMember.entityLike._schema.casing;
+                const pre = DynamoSchema.prefix(firstMember.entityLike._schema);
+                const casedNames = hierarchy.map((n) => DynamoSchema.applyCasing(n, casing));
+                const skPrefix = `${pre}#${casedNames.join("#")}`;
+                query = Query.where(query, { beginsWith: skPrefix });
+            }
+            // Wrap in BoundQuery that groups results by entity key
+            const pathBuilder = createPathBuilder();
+            const conditionOps = createConditionOps();
+            const collectionProvide = (eff) => Effect.provide(eff, ctx);
+            const bqConfig = {
+                pathBuilder,
+                conditionOps,
+                provide: collectionProvide,
+            };
+            const bq = new BoundQueryImpl(query, bqConfig);
+            // Override collect to group results
+            const originalCollect = bq.collect.bind(bq);
+            bq.collect = () => Effect.map(originalCollect(), (items) => {
+                const result = {};
+                for (const member of members) {
+                    result[member.entityKey] = [];
+                }
+                for (const item of items) {
+                    const memberKey = item._memberKey;
+                    if (memberKey && result[memberKey]) {
+                        result[memberKey].push(item._decoded);
+                    }
+                }
+                return result;
+            });
+            return bq;
+        };
+    }
+    // 4. Bind aggregates
+    const boundAggregates = {};
+    if (config.aggregates) {
+        for (const [key, aggregate] of Object.entries(config.aggregates)) {
+            boundAggregates[key] = yield* aggregateBind(aggregate);
+        }
+    }
+    // 5. Build table operations
+    const client = yield* DynamoClient;
+    const tables = {};
+    if (config.tables) {
+        for (const [tableKey, table] of Object.entries(config.tables)) {
+            const tableConfig = yield* table.Tag;
+            // Merge any runtime-registered aggregates from `config.aggregates` whose
+            // `_tableTag` matches this table's tag. Users may intentionally omit
+            // aggregates from `Table.make({ aggregates })` to sidestep the multi-file
+            // circular-import problem, registering them on `DynamoClient.make` instead.
+            // Without this merge, `tableDefinition()` would never see those aggregates
+            // and `db.tables.*.create()` would silently drop their (L|G)SIs.
+            let mergedTable = table;
+            if (config.aggregates) {
+                const tableTagKey = table.Tag.key;
+                const existingAggs = table.aggregates;
+                const existingAggSet = new Set(Object.values(existingAggs));
+                const extraAggregateEntries = [];
+                for (const [aggKey, agg] of Object.entries(config.aggregates)) {
+                    const aggTag = agg._tableTag;
+                    if (aggTag === undefined)
+                        continue;
+                    if (aggTag.key !== tableTagKey)
+                        continue;
+                    // Skip if this aggregate is already registered on the table object
+                    // (reference equality) so we don't emit duplicate LSI/GSI entries.
+                    if (existingAggSet.has(agg))
+                        continue;
+                    extraAggregateEntries.push([aggKey, agg]);
+                }
+                if (extraAggregateEntries.length > 0) {
+                    mergedTable = {
+                        ...table,
+                        aggregates: {
+                            ...existingAggs,
+                            ...Object.fromEntries(extraAggregateEntries),
+                        },
+                    };
+                }
+            }
+            tables[tableKey] = buildTableOperationsFromTable(tableConfig.name, mergedTable, client);
+        }
+    }
+    else {
+        // Group entities by table tag so we can derive full table schema for create().
+        // Aggregates are also assigned to a table tag via their underlying entities;
+        // we collect them here so create() includes their GSIs.
+        const entitiesByTag = new Map();
+        for (const [, entity] of Object.entries(config.entities)) {
+            const entityLike = entity;
+            const tagId = entityLike._tableTag.key;
+            if (!entitiesByTag.has(tagId)) {
+                entitiesByTag.set(tagId, { tag: entityLike._tableTag, entities: [], aggregates: [] });
+            }
+            entitiesByTag.get(tagId).entities.push(entityLike);
+        }
+        // Attach aggregates to whichever table tag matches their root entity tag.
+        // (Aggregates expose `_tableTag` from their root entity registration.)
+        if (config.aggregates) {
+            for (const [, agg] of Object.entries(config.aggregates)) {
+                const aggTag = agg._tableTag;
+                if (aggTag && entitiesByTag.has(aggTag.key)) {
+                    entitiesByTag.get(aggTag.key).aggregates.push(agg);
+                }
+            }
+        }
+        for (const [, { tag, entities: tableEntities, aggregates: tableAggregates },] of entitiesByTag) {
+            const tableConfig = yield* tag;
+            // Build a minimal Table-like object so tableDefinition() can derive GSIs
+            // (entities + aggregates).
+            const syntheticTable = {
+                entities: Object.fromEntries(tableEntities.map((e) => [e.entityType, e])),
+                aggregates: Object.fromEntries(tableAggregates.map((a, i) => [
+                    a.name ?? `__aggregate_${i}__`,
+                    a,
+                ])),
+            };
+            tables[tableConfig.name] = buildTableOperationsFromTable(tableConfig.name, syntheticTable, client);
+        }
+    }
+    return {
+        entities: boundEntities,
+        aggregates: boundAggregates,
+        collections: boundCollections,
+        tables,
+    };
+});
+// ---------------------------------------------------------------------------
+// buildTableOperations — pre-bound table management
+// ---------------------------------------------------------------------------
+/** Check if a DynamoError wraps a ResourceInUseException (table already exists). */
+const isResourceInUse = (err) => err._tag === "DynamoError" &&
+    err.cause != null &&
+    typeof err.cause === "object" &&
+    "name" in err.cause &&
+    err.cause.name === "ResourceInUseException";
+/** Make createTable idempotent — ignore if table already exists. */
+const idempotentCreate = (effect) => Effect.catchIf(effect, isResourceInUse, () => Effect.void);
+const buildTableOperationsFromTable = (tableName, table, client) => {
+    const def = tableDefinition(table);
+    return {
+        ...buildTableOperations(tableName, client),
+        create: (options) => idempotentCreate(client
+            .createTable({
+            TableName: tableName,
+            BillingMode: options?.billingMode ?? "PAY_PER_REQUEST",
+            ...def,
+        })
+            .pipe(Effect.asVoid)),
+    };
+};
+const buildTableOperations = (tableName, client) => ({
+    create: (options) => idempotentCreate(client
+        .createTable({
+        TableName: tableName,
+        BillingMode: options?.billingMode ?? "PAY_PER_REQUEST",
+        KeySchema: [
+            { AttributeName: "pk", KeyType: "HASH" },
+            { AttributeName: "sk", KeyType: "RANGE" },
+        ],
+        AttributeDefinitions: [
+            { AttributeName: "pk", AttributeType: "S" },
+            { AttributeName: "sk", AttributeType: "S" },
+        ],
+    })
+        .pipe(Effect.asVoid)),
+    delete: () => client.deleteTable({ TableName: tableName }).pipe(Effect.asVoid),
+    describe: () => client.describeTable({ TableName: tableName }),
+    update: (input) => client
+        .updateTable({ ...input, TableName: tableName })
+        .pipe(Effect.asVoid),
+    backup: (name) => client.createBackup({ TableName: tableName, BackupName: name }),
+    listBackups: () => client.listBackups({ TableName: tableName }),
+    restoreFromBackup: (backupArn) => client.restoreTableFromBackup({
+        TargetTableName: `${tableName}-restore`,
+        BackupArn: backupArn,
+    }),
+    enablePointInTimeRecovery: () => client
+        .updateContinuousBackups({
+        TableName: tableName,
+        PointInTimeRecoverySpecification: { PointInTimeRecoveryEnabled: true },
+    })
+        .pipe(Effect.asVoid),
+    disablePointInTimeRecovery: () => client
+        .updateContinuousBackups({
+        TableName: tableName,
+        PointInTimeRecoverySpecification: { PointInTimeRecoveryEnabled: false },
+    })
+        .pipe(Effect.asVoid),
+    restoreToPointInTime: (timestamp) => client.restoreTableToPointInTime({
+        SourceTableName: tableName,
+        TargetTableName: `${tableName}-pitr-restore`,
+        RestoreDateTime: timestamp,
+    }),
+    exportToS3: (s3Bucket, options) => client.exportTableToPointInTime({
+        TableArn: tableName, // Will need actual ARN — use describe first
+        S3Bucket: s3Bucket,
+        S3Prefix: options?.s3Prefix,
+        ExportFormat: options?.exportFormat,
+    }),
+    enableTTL: (attributeName) => client
+        .updateTimeToLive({
+        TableName: tableName,
+        TimeToLiveSpecification: {
+            Enabled: true,
+            AttributeName: attributeName,
+        },
+    })
+        .pipe(Effect.asVoid),
+    disableTTL: (attributeName) => client
+        .updateTimeToLive({
+        TableName: tableName,
+        TimeToLiveSpecification: {
+            Enabled: false,
+            AttributeName: attributeName,
+        },
+    })
+        .pipe(Effect.asVoid),
+    describeTTL: () => client.describeTimeToLive({ TableName: tableName }),
+    tag: (tags) => client
+        .tagResource({
+        ResourceArn: tableName, // Will need actual ARN
+        Tags: Object.entries(tags).map(([Key, Value]) => ({ Key, Value })),
+    })
+        .pipe(Effect.asVoid),
+    untag: (tagKeys) => client
+        .untagResource({
+        ResourceArn: tableName, // Will need actual ARN
+        TagKeys: [...tagKeys],
+    })
+        .pipe(Effect.asVoid),
+    tags: () => client.listTagsOfResource({ ResourceArn: tableName }),
+});
+/** @internal Classify an AWS SDK error into a specific tagged error type. */
+const classifyError = (operation) => (cause) => {
+    if (isAwsThrottling(cause))
+        return new ThrottlingError({ operation, cause });
+    if (isAwsValidationError(cause))
+        return new DynamoValidationError({ operation, cause });
+    if (isAwsInternalServerError(cause))
+        return new InternalServerError({ operation, cause });
+    if (isAwsResourceNotFound(cause))
+        return new ResourceNotFoundError({ operation, cause });
+    return new DynamoError({ operation, cause });
+};
+/** @internal Build the DynamoClient service implementation from resolved config values. */
+const buildService = (region, endpoint, credentials) => Effect.gen(function* () {
+    const clientConfig = { region };
+    if (endpoint !== undefined)
+        clientConfig.endpoint = endpoint;
+    if (credentials !== undefined)
+        clientConfig.credentials = credentials;
+    const client = yield* Effect.acquireRelease(Effect.sync(() => new DynamoDBClient(clientConfig)), (c) => Effect.sync(() => c.destroy()));
+    return {
+        createTable: (input) => Effect.tryPromise({
+            try: () => client.send(new CreateTableCommand(input)),
+            catch: classifyError("CreateTable"),
+        }),
+        deleteTable: (input) => Effect.tryPromise({
+            try: () => client.send(new DeleteTableCommand(input)),
+            catch: classifyError("DeleteTable"),
+        }),
+        describeTable: (input) => Effect.tryPromise({
+            try: () => client.send(new DescribeTableCommand(input)),
+            catch: classifyError("DescribeTable"),
+        }),
+        putItem: (input) => Effect.tryPromise({
+            try: () => client.send(new PutItemCommand(input)),
+            catch: classifyError("PutItem"),
+        }),
+        getItem: (input) => Effect.tryPromise({
+            try: () => client.send(new GetItemCommand(input)),
+            catch: classifyError("GetItem"),
+        }),
+        deleteItem: (input) => Effect.tryPromise({
+            try: () => client.send(new DeleteItemCommand(input)),
+            catch: classifyError("DeleteItem"),
+        }),
+        updateItem: (input) => Effect.tryPromise({
+            try: () => client.send(new UpdateItemCommand(input)),
+            catch: classifyError("UpdateItem"),
+        }),
+        query: (input) => Effect.tryPromise({
+            try: () => client.send(new QueryCommand(input)),
+            catch: classifyError("Query"),
+        }),
+        scan: (input) => Effect.tryPromise({
+            try: () => client.send(new ScanCommand(input)),
+            catch: classifyError("Scan"),
+        }),
+        batchGetItem: (input) => Effect.tryPromise({
+            try: () => client.send(new BatchGetItemCommand(input)),
+            catch: classifyError("BatchGetItem"),
+        }),
+        batchWriteItem: (input) => Effect.tryPromise({
+            try: () => client.send(new BatchWriteItemCommand(input)),
+            catch: classifyError("BatchWriteItem"),
+        }),
+        transactGetItems: (input) => Effect.tryPromise({
+            try: () => client.send(new TransactGetItemsCommand(input)),
+            catch: classifyError("TransactGetItems"),
+        }),
+        transactWriteItems: (input) => Effect.tryPromise({
+            try: () => client.send(new TransactWriteItemsCommand(input)),
+            catch: classifyError("TransactWriteItems"),
+        }),
+        // --- Table management ---
+        updateTable: (input) => Effect.tryPromise({
+            try: () => client.send(new UpdateTableCommand(input)),
+            catch: classifyError("UpdateTable"),
+        }),
+        listTables: (input) => Effect.tryPromise({
+            try: () => client.send(new ListTablesCommand(input)),
+            catch: classifyError("ListTables"),
+        }),
+        // --- Backup ---
+        createBackup: (input) => Effect.tryPromise({
+            try: () => client.send(new CreateBackupCommand(input)),
+            catch: classifyError("CreateBackup"),
+        }),
+        deleteBackup: (input) => Effect.tryPromise({
+            try: () => client.send(new DeleteBackupCommand(input)),
+            catch: classifyError("DeleteBackup"),
+        }),
+        listBackups: (input) => Effect.tryPromise({
+            try: () => client.send(new ListBackupsCommand(input)),
+            catch: classifyError("ListBackups"),
+        }),
+        restoreTableFromBackup: (input) => Effect.tryPromise({
+            try: () => client.send(new RestoreTableFromBackupCommand(input)),
+            catch: classifyError("RestoreTableFromBackup"),
+        }),
+        // --- PITR ---
+        describeContinuousBackups: (input) => Effect.tryPromise({
+            try: () => client.send(new DescribeContinuousBackupsCommand(input)),
+            catch: classifyError("DescribeContinuousBackups"),
+        }),
+        updateContinuousBackups: (input) => Effect.tryPromise({
+            try: () => client.send(new UpdateContinuousBackupsCommand(input)),
+            catch: classifyError("UpdateContinuousBackups"),
+        }),
+        restoreTableToPointInTime: (input) => Effect.tryPromise({
+            try: () => client.send(new RestoreTableToPointInTimeCommand(input)),
+            catch: classifyError("RestoreTableToPointInTime"),
+        }),
+        // --- Export ---
+        exportTableToPointInTime: (input) => Effect.tryPromise({
+            try: () => client.send(new ExportTableToPointInTimeCommand(input)),
+            catch: classifyError("ExportTableToPointInTime"),
+        }),
+        describeExport: (input) => Effect.tryPromise({
+            try: () => client.send(new DescribeExportCommand(input)),
+            catch: classifyError("DescribeExport"),
+        }),
+        // --- TTL ---
+        updateTimeToLive: (input) => Effect.tryPromise({
+            try: () => client.send(new UpdateTimeToLiveCommand(input)),
+            catch: classifyError("UpdateTimeToLive"),
+        }),
+        describeTimeToLive: (input) => Effect.tryPromise({
+            try: () => client.send(new DescribeTimeToLiveCommand(input)),
+            catch: classifyError("DescribeTimeToLive"),
+        }),
+        // --- Tags ---
+        tagResource: (input) => Effect.tryPromise({
+            try: () => client.send(new TagResourceCommand(input)),
+            catch: classifyError("TagResource"),
+        }),
+        untagResource: (input) => Effect.tryPromise({
+            try: () => client.send(new UntagResourceCommand(input)),
+            catch: classifyError("UntagResource"),
+        }),
+        listTagsOfResource: (input) => Effect.tryPromise({
+            try: () => client.send(new ListTagsOfResourceCommand(input)),
+            catch: classifyError("ListTagsOfResource"),
+        }),
+    };
+});
+//# sourceMappingURL=DynamoClient.js.map