@ductape/sdk 0.0.4-v51 → 0.0.4-v52

package/dist/database/adapters/dynamodb.adapter.js

@@ -1,7 +1,16 @@
 "use strict";
 /**
- * DynamoDB Database Adapter
- * Implements database operations for Amazon DynamoDB
+ * DynamoDB Adapter
+ *
+ * Database adapter for AWS DynamoDB using the '@aws-sdk/client-dynamodb' and
+ * '@aws-sdk/lib-dynamodb' libraries.
+ * Implements all methods from BaseAdapter with DynamoDB-specific operations.
+ *
+ * Note: DynamoDB is a NoSQL key-value store with different concepts:
+ * - Tables have a partition key (and optional sort key)
+ * - No traditional transactions (uses TransactWriteItems/TransactGetItems)
+ * - No savepoints
+ * - Different query patterns than SQL databases
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -39,750 +48,793 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamoDBAdapter = void 0;
 const base_adapter_1 = require("./base.adapter");
-const database_types_1 = require("../types/database.types");
-const uuid_1 = require("uuid");
-const schema_types_1 = require("../types/schema.types");
-const migration_types_1 = require("../types/migration.types");
+const enums_1 = require("../types/enums");
+const database_error_1 = require("../utils/database-error");
 /**
- * DynamoDB Connection wrapper
+ * DynamoDB database adapter
+ * Provides DynamoDB-specific implementations for all database operations
  */
-class DynamoDBConnection {
-    constructor(id, client, docClient) {
-        this.id = id;
-        this.type = database_types_1.DatabaseType.DYNAMODB;
-        this.status = database_types_1.ConnectionStatus.CONNECTED;
-        this.client = client;
-        this.docClient = docClient;
-    }
-    async connect() {
-        this.status = database_types_1.ConnectionStatus.CONNECTED;
-    }
-    async disconnect() {
-        this.client.destroy();
-        this.status = database_types_1.ConnectionStatus.DISCONNECTED;
-    }
-    isConnected() {
-        return this.status === database_types_1.ConnectionStatus.CONNECTED;
-    }
-    getClient() {
-        return this.docClient;
-    }
-    getRawClient() {
-        return this.client;
-    }
-    getType() {
-        return this.type;
-    }
-    getConfig() {
-        throw new Error('Config not stored in connection');
-    }
-}
-/**
- * DynamoDB Transaction implementation
- * Note: DynamoDB transactions work differently from SQL - they collect items
- * and execute them atomically on commit using TransactWriteItems.
- * Maximum 100 items per transaction.
- * Does NOT support savepoints.
- */
-class DynamoDBTransaction {
-    constructor(connection, _options) {
-        this.transactItems = [];
-        this.id = (0, uuid_1.v4)();
-        this.connection = connection;
-        this.status = database_types_1.TransactionStatus.ACTIVE;
-        this.createdAt = new Date();
-        this.native = { items: this.transactItems };
-    }
-    async commit() {
-        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot commit transaction: status is ${this.status}`);
-        }
-        if (this.transactItems.length === 0) {
-            this.status = database_types_1.TransactionStatus.COMMITTED;
-            return;
-        }
-        if (this.transactItems.length > 100) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `DynamoDB transactions are limited to 100 items. Current: ${this.transactItems.length}`);
-        }
-        try {
-            const { TransactWriteCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
-            const docClient = this.connection.getClient();
-            await docClient.send(new TransactWriteCommand({
-                TransactItems: this.transactItems,
-            }));
-            this.status = database_types_1.TransactionStatus.COMMITTED;
-        }
-        catch (error) {
-            this.status = database_types_1.TransactionStatus.ROLLED_BACK;
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `DynamoDB transaction commit failed: ${error.message}`, error);
-        }
-    }
-    async rollback() {
-        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot rollback transaction: status is ${this.status}`);
-        }
-        // DynamoDB transactions are atomic - just clear items and mark as rolled back
-        this.transactItems = [];
-        this.status = database_types_1.TransactionStatus.ROLLED_BACK;
-    }
-    async savepoint(_name) {
-        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.NOT_SUPPORTED, 'DynamoDB does not support savepoints. Transactions are atomic batch operations.');
-    }
-    isActive() {
-        return this.status === database_types_1.TransactionStatus.ACTIVE;
-    }
-    /**
-     * Add an item to the transaction batch
-     * Used internally by the adapter for transactional operations
-     */
-    addItem(item) {
-        if (this.transactItems.length >= 100) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, 'DynamoDB transactions are limited to 100 items');
-        }
-        this.transactItems.push(item);
-    }
-    getItems() {
-        return this.transactItems;
-    }
-}
-/**
- * DynamoDB Database Adapter
- */
-class DynamoDBAdapter extends base_adapter_1.BaseDatabaseAdapter {
+class DynamoDBAdapter extends base_adapter_1.BaseAdapter {
     constructor() {
         super(...arguments);
-        this.type = database_types_1.DatabaseType.DYNAMODB;
+        this.databaseType = enums_1.DatabaseType.DYNAMODB;
+        this.dynamoClient = null;
+        this.docClient = null;
+        this.region = '';
     }
-    // ==================== Connection Methods ====================
-    async connect(config) {
-        var _a, _b, _c, _d;
+    // ==================== CONNECTION METHODS ====================
+    async connect(options) {
         try {
-            // Dynamic import of AWS SDK v3
+            // Dynamic import of AWS SDK
             const { DynamoDBClient } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
             const { DynamoDBDocumentClient } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            this.connectionUrl = options.connectionUrl;
+            // Parse connection URL: dynamodb://region/access-key/secret-key
+            // Or: dynamodb://region (uses default credentials)
+            const url = new URL(options.connectionUrl);
+            this.region = url.hostname || 'us-east-1';
             const clientConfig = {
-                region: ((_a = config.options) === null || _a === void 0 ? void 0 : _a.region) || 'us-east-1',
+                region: this.region,
             };
-            // Add credentials if provided
-            if (((_b = config.options) === null || _b === void 0 ? void 0 : _b.accessKeyId) && ((_c = config.options) === null || _c === void 0 ? void 0 : _c.secretAccessKey)) {
-                clientConfig.credentials = {
-                    accessKeyId: config.options.accessKeyId,
-                    secretAccessKey: config.options.secretAccessKey,
-                    sessionToken: config.options.sessionToken,
-                };
+            // If credentials are provided in the URL
+            if (url.pathname && url.pathname !== '/') {
+                const parts = url.pathname.slice(1).split('/');
+                if (parts.length >= 2) {
+                    clientConfig.credentials = {
+                        accessKeyId: parts[0],
+                        secretAccessKey: parts[1],
+                    };
+                }
             }
-            // Add endpoint for local development
-            if ((_d = config.options) === null || _d === void 0 ? void 0 : _d.endpoint) {
-                clientConfig.endpoint = config.options.endpoint;
+            // Custom endpoint for local DynamoDB
+            if (url.port) {
+                clientConfig.endpoint = `http://${url.hostname}:${url.port}`;
             }
-            const client = new DynamoDBClient(clientConfig);
-            const docClient = DynamoDBDocumentClient.from(client);
-            return new DynamoDBConnection(`dynamodb-${Date.now()}`, client, docClient);
+            this.dynamoClient = new DynamoDBClient(clientConfig);
+            this.docClient = DynamoDBDocumentClient.from(this.dynamoClient, {
+                marshallOptions: {
+                    removeUndefinedValues: true,
+                    convertEmptyValues: true,
+                },
+            });
+            // Test connection by listing tables
+            const { ListTablesCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+            await this.dynamoClient.send(new ListTablesCommand({ Limit: 1 }));
+            this.client = this.docClient;
+            this.connected = true;
+            return {
+                connected: true,
+                version: `DynamoDB (${this.region})`,
+            };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, `Failed to connect to DynamoDB: ${error.message}`, error);
+            throw database_error_1.DatabaseError.connectionError(`Failed to connect to DynamoDB: ${error.message}`, error);
         }
     }
-    async disconnect(connection) {
-        await connection.disconnect();
-    }
-    async testConnection(connection) {
-        const startTime = Date.now();
+    async testConnection(options) {
         try {
-            const { ListTablesCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const client = connection.getRawClient();
+            const { DynamoDBClient, ListTablesCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+            const url = new URL(options.connectionUrl);
+            const region = url.hostname || 'us-east-1';
+            const clientConfig = { region };
+            if (url.pathname && url.pathname !== '/') {
+                const parts = url.pathname.slice(1).split('/');
+                if (parts.length >= 2) {
+                    clientConfig.credentials = {
+                        accessKeyId: parts[0],
+                        secretAccessKey: parts[1],
+                    };
+                }
+            }
+            if (url.port) {
+                clientConfig.endpoint = `http://${url.hostname}:${url.port}`;
+            }
+            const client = new DynamoDBClient(clientConfig);
             await client.send(new ListTablesCommand({ Limit: 1 }));
+            client.destroy();
             return {
                 connected: true,
-                message: 'DynamoDB connection successful',
-                databaseType: 'DynamoDB',
-                responseTime: Date.now() - startTime,
+                version: `DynamoDB (${region})`,
             };
         }
         catch (error) {
             return {
                 connected: false,
-                message: `DynamoDB connection failed: ${error.message}`,
-                databaseType: 'DynamoDB',
-                responseTime: Date.now() - startTime,
                 error: error.message,
             };
         }
     }
-    // ==================== Transaction Methods ====================
-    async beginTransaction(connection, options) {
-        // DynamoDB transactions collect items and execute them atomically on commit
-        return new DynamoDBTransaction(connection, options);
-    }
-    async commitTransaction(_connection, transaction) {
-        await transaction.commit();
-    }
-    async rollbackTransaction(_connection, transaction) {
-        await transaction.rollback();
-    }
-    async createSavepoint(_connection, _transaction, _savepointName) {
-        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.NOT_SUPPORTED, 'DynamoDB does not support savepoints. Transactions are atomic batch operations.');
-    }
-    async rollbackToSavepoint(_connection, _transaction, _savepoint) {
-        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.NOT_SUPPORTED, 'DynamoDB does not support savepoints.');
-    }
-    async releaseSavepoint(_connection, _transaction, _savepoint) {
-        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.NOT_SUPPORTED, 'DynamoDB does not support savepoints.');
+    async disconnect() {
+        if (this.dynamoClient) {
+            this.dynamoClient.destroy();
+            this.dynamoClient = null;
+            this.docClient = null;
+            this.client = null;
+            this.connected = false;
+        }
     }
-    // ==================== Query Methods ====================
-    async query(connection, options) {
-        const startTime = Date.now();
+    // ==================== QUERY METHODS ====================
+    async query(query) {
+        var _a;
+        this.ensureConnected();
         try {
             const { ScanCommand, QueryCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
-            const docClient = connection.getClient();
-            let result;
-            // If there's a partition key in where clause, use Query, otherwise use Scan
-            const hasPartitionKey = options.where && this.hasPartitionKeyInWhere(options.where);
-            if (hasPartitionKey) {
-                const params = this.buildQueryParams(options);
-                result = await docClient.send(new QueryCommand(params));
+            const tableName = query.options.table;
+            const filter = query.options.where || {};
+            // Determine if we can use Query (needs key conditions) or must use Scan
+            const { keyCondition, filterCondition } = await this.extractKeyCondition(filter, tableName);
+            let items = [];
+            let count = 0;
+            if (keyCondition) {
+                // Use Query command for key-based lookups (much faster than Scan)
+                const params = {
+                    TableName: tableName,
+                    KeyConditionExpression: keyCondition.expression,
+                    ExpressionAttributeNames: Object.assign({}, keyCondition.names),
+                    ExpressionAttributeValues: Object.assign({}, keyCondition.values),
+                };
+                // Add filter for non-key conditions
+                if (filterCondition && filterCondition.expression) {
+                    params.FilterExpression = filterCondition.expression;
+                    Object.assign(params.ExpressionAttributeNames, filterCondition.names);
+                    Object.assign(params.ExpressionAttributeValues, filterCondition.values);
+                }
+                // Projection
+                if (query.options.select) {
+                    params.ProjectionExpression = query.options.select
+                        .map((col, i) => {
+                        params.ExpressionAttributeNames[`#proj${i}`] = col;
+                        return `#proj${i}`;
+                    })
+                        .join(', ');
+                }
+                // Limit
+                if (query.options.limit) {
+                    params.Limit = query.options.limit;
+                }
+                // Sort order (only works if there's a sort key)
+                if (query.options.orderBy) {
+                    const orderByArray = Array.isArray(query.options.orderBy)
+                        ? query.options.orderBy
+                        : [query.options.orderBy];
+                    // DynamoDB only supports ASC/DESC on sort key
+                    if (((_a = orderByArray[0]) === null || _a === void 0 ? void 0 : _a.order) === 'DESC') {
+                        params.ScanIndexForward = false;
+                    }
+                }
+                const response = await this.docClient.send(new QueryCommand(params));
+                items = response.Items || [];
+                count = response.Count || 0;
             }
             else {
-                const params = this.buildScanParams(options);
-                result = await docClient.send(new ScanCommand(params));
+                // Use Scan command (less efficient but necessary for non-key queries)
+                const params = {
+                    TableName: tableName,
+                };
+                // Build filter expression
+                const filterExpression = this.buildFilterExpression(filter, {}, {});
+                if (filterExpression.expression) {
+                    params.FilterExpression = filterExpression.expression;
+                    params.ExpressionAttributeNames = filterExpression.names;
+                    params.ExpressionAttributeValues = filterExpression.values;
+                }
+                // Projection
+                if (query.options.select) {
+                    params.ExpressionAttributeNames = params.ExpressionAttributeNames || {};
+                    params.ProjectionExpression = query.options.select
+                        .map((col, i) => {
+                        params.ExpressionAttributeNames[`#proj${i}`] = col;
+                        return `#proj${i}`;
+                    })
+                        .join(', ');
+                }
+                // Limit
+                if (query.options.limit) {
+                    params.Limit = query.options.limit;
+                }
+                const response = await this.docClient.send(new ScanCommand(params));
+                items = response.Items || [];
+                // Use Count (items after filtering) not ScannedCount (items before filtering)
+                count = response.Count || items.length;
+            }
+            // Apply offset (DynamoDB doesn't have native offset)
+            if (query.options.offset && query.options.offset > 0) {
+                items = items.slice(query.options.offset);
             }
-            const executionTime = Date.now() - startTime;
             return {
-                data: (result.Items || []),
-                count: result.Count || 0,
-                executionTime,
+                data: items,
+                count,
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB query failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
         }
     }
-    async insert(connection, options) {
-        const startTime = Date.now();
+    async raw(options) {
+        this.ensureConnected();
+        try {
+            const { ScanCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            // For DynamoDB, raw query is a PartiQL statement or direct command
+            // Here we support simple scan with filter
+            const params = Object.assign({ TableName: options.table || options.collection }, options.query);
+            const response = await this.docClient.send(new ScanCommand(params));
+            return {
+                data: (response.Items || []),
+                count: response.Count || 0,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    // ==================== WRITE METHODS ====================
+    async insert(options) {
+        var _a, _b;
+        this.ensureConnected();
         try {
             const { PutCommand, BatchWriteCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
-            const docClient = connection.getClient();
-            const dataArray = Array.isArray(options.data) ? options.data : [options.data];
-            if (dataArray.length === 1) {
-                // Single item insert
-                await docClient.send(new PutCommand({
+            const data = Array.isArray(options.data) ? options.data : [options.data];
+            if (data.length === 0) {
+                return { data: [], count: 0, insertedIds: [] };
+            }
+            const insertedIds = [];
+            if (data.length === 1) {
+                // Single item put
+                await this.docClient.send(new PutCommand({
                     TableName: options.table,
-                    Item: dataArray[0],
+                    Item: data[0],
+                    ConditionExpression: ((_a = options.onConflict) === null || _a === void 0 ? void 0 : _a.action) === 'ignore'
+                        ? 'attribute_not_exists(#pk)'
+                        : undefined,
+                    ExpressionAttributeNames: ((_b = options.onConflict) === null || _b === void 0 ? void 0 : _b.action) === 'ignore'
+                        ? { '#pk': options.onConflict.columns[0] }
+                        : undefined,
                 }));
+                insertedIds.push(data[0].id || data[0]._id);
             }
             else {
-                // Batch insert (max 25 items per batch)
-                const batches = this.chunkArray(dataArray, 25);
+                // Batch write (max 25 items per batch)
+                const batches = this.chunkArray(data, 25);
                 for (const batch of batches) {
-                    await docClient.send(new BatchWriteCommand({
+                    await this.docClient.send(new BatchWriteCommand({
                         RequestItems: {
-                            [options.table]: batch.map((item) => ({
+                            [options.table]: batch.map(item => ({
                                 PutRequest: { Item: item },
                             })),
                         },
                     }));
+                    batch.forEach(item => insertedIds.push(item.id || item._id));
                 }
             }
-            const executionTime = Date.now() - startTime;
             return {
-                insertedCount: dataArray.length,
-                insertedIds: [], // DynamoDB doesn't auto-generate IDs
-                data: undefined,
-                executionTime,
-                success: true,
+                data: options.returning ? data : [],
+                count: data.length,
+                insertedIds,
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB insert failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
         }
     }
-    async update(connection, options) {
-        const startTime = Date.now();
+    async update(options) {
+        this.ensureConnected();
         try {
-            const { UpdateCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
-            const docClient = connection.getClient();
-            // DynamoDB requires a key to update - extract from where clause
-            const key = this.extractKeyFromWhere(options.where);
-            // Build update expression
-            const { updateExpression, expressionAttributeNames, expressionAttributeValues } = this.buildUpdateExpression(options.data);
-            await docClient.send(new UpdateCommand({
+            const { UpdateCommand, ScanCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            // First, find items to update
+            const filter = options.where || {};
+            const filterExpression = this.buildFilterExpression(filter, {}, {});
+            const scanParams = {
                 TableName: options.table,
-                Key: key,
-                UpdateExpression: updateExpression,
-                ExpressionAttributeNames: expressionAttributeNames,
-                ExpressionAttributeValues: expressionAttributeValues,
-            }));
-            const executionTime = Date.now() - startTime;
+            };
+            if (filterExpression.expression) {
+                scanParams.FilterExpression = filterExpression.expression;
+                scanParams.ExpressionAttributeNames = filterExpression.names;
+                scanParams.ExpressionAttributeValues = filterExpression.values;
+            }
+            const scanResponse = await this.docClient.send(new ScanCommand(scanParams));
+            const itemsToUpdate = scanResponse.Items || [];
+            // Build update expression
+            const { expression, names, values } = this.buildUpdateExpression(options.data);
+            let updatedCount = 0;
+            const updatedItems = [];
+            for (const item of itemsToUpdate) {
+                // Get primary key from item
+                const key = await this.getTableKey(options.table, item);
+                const updateParams = {
+                    TableName: options.table,
+                    Key: key,
+                    UpdateExpression: expression,
+                    ExpressionAttributeNames: names,
+                    ExpressionAttributeValues: values,
+                    ReturnValues: options.returning ? 'ALL_NEW' : 'NONE',
+                };
+                const response = await this.docClient.send(new UpdateCommand(updateParams));
+                updatedCount++;
+                if (options.returning && response.Attributes) {
+                    updatedItems.push(response.Attributes);
+                }
+            }
             return {
-                updatedCount: 1, // DynamoDB updates one item at a time
-                matchedCount: 1,
-                data: undefined,
-                executionTime,
-                success: true,
+                data: updatedItems,
+                count: updatedCount,
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB update failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
         }
     }
-    async delete(connection, options) {
-        const startTime = Date.now();
+    async delete(options) {
+        this.ensureConnected();
         try {
-            const { DeleteCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
-            const docClient = connection.getClient();
-            // DynamoDB requires a key to delete - extract from where clause
-            const key = this.extractKeyFromWhere(options.where);
-            await docClient.send(new DeleteCommand({
+            const { DeleteCommand, ScanCommand, BatchWriteCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            // First, find items to delete
+            const filter = options.where || {};
+            const filterExpression = this.buildFilterExpression(filter, {}, {});
+            const scanParams = {
                 TableName: options.table,
-                Key: key,
-            }));
-            const executionTime = Date.now() - startTime;
+            };
+            if (filterExpression.expression) {
+                scanParams.FilterExpression = filterExpression.expression;
+                scanParams.ExpressionAttributeNames = filterExpression.names;
+                scanParams.ExpressionAttributeValues = filterExpression.values;
+            }
+            const scanResponse = await this.docClient.send(new ScanCommand(scanParams));
+            const itemsToDelete = scanResponse.Items || [];
+            if (itemsToDelete.length === 0) {
+                return { count: 0 };
+            }
+            // Delete items in batches of 25
+            const batches = this.chunkArray(itemsToDelete, 25);
+            for (const batch of batches) {
+                const deleteRequests = await Promise.all(batch.map(async (item) => {
+                    const key = await this.getTableKey(options.table, item);
+                    return { DeleteRequest: { Key: key } };
+                }));
+                await this.docClient.send(new BatchWriteCommand({
+                    RequestItems: {
+                        [options.table]: deleteRequests,
+                    },
+                }));
+            }
             return {
-                deletedCount: 1,
-                data: undefined,
-                executionTime,
-                success: true,
+                count: itemsToDelete.length,
+                data: options.returning ? itemsToDelete : undefined,
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB delete failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
         }
     }
-    async upsert(connection, options) {
-        const startTime = Date.now();
+    async upsert(options) {
+        this.ensureConnected();
         try {
             const { PutCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
-            const docClient = connection.getClient();
-            const data = Array.isArray(options.data) ? options.data[0] : options.data;
-            // PutItem automatically does upsert in DynamoDB
-            await docClient.send(new PutCommand({
+            // DynamoDB PutCommand is an upsert by default
+            await this.docClient.send(new PutCommand({
                 TableName: options.table,
-                Item: data,
+                Item: options.data,
+                ReturnValues: 'NONE',
             }));
-            const executionTime = Date.now() - startTime;
             return {
-                insertedCount: 0, // Can't distinguish in DynamoDB
-                updatedCount: 0,
-                affectedCount: 1,
-                data: undefined,
-                executionTime,
-                success: true,
+                data: [options.data],
+                count: 1,
+                operation: 'inserted', // DynamoDB doesn't distinguish
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB upsert failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
         }
     }
-    async executeRaw(connection, options) {
-        var _a;
-        const startTime = Date.now();
+    // ==================== AGGREGATION METHODS ====================
+    async count(options) {
+        this.ensureConnected();
         try {
-            const { ExecuteStatementCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const client = connection.getRawClient();
-            // DynamoDB PartiQL support
-            const result = await client.send(new ExecuteStatementCommand({
-                Statement: options.query,
-                Parameters: options.params,
-            }));
-            const executionTime = Date.now() - startTime;
-            return {
-                rows: (result.Items || []),
-                rowCount: ((_a = result.Items) === null || _a === void 0 ? void 0 : _a.length) || 0,
-                executionTime,
+            const { ScanCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            const params = {
+                TableName: options.table,
+                Select: 'COUNT',
             };
+            if (options.where) {
+                const filterExpression = this.buildFilterExpression(options.where, {}, {});
+                if (filterExpression.expression) {
+                    params.FilterExpression = filterExpression.expression;
+                    params.ExpressionAttributeNames = filterExpression.names;
+                    params.ExpressionAttributeValues = filterExpression.values;
+                }
+            }
+            const response = await this.docClient.send(new ScanCommand(params));
+            return response.Count || 0;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB raw query failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
         }
     }
-    // ==================== Aggregation Methods ====================
-    async count(connection, options) {
+    async sum(options) {
+        this.ensureConnected();
         try {
+            // DynamoDB doesn't have native aggregations, need to scan and sum
             const { ScanCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
-            const docClient = connection.getClient();
             const params = {
                 TableName: options.table,
-                Select: 'COUNT',
+                ProjectionExpression: `#col`,
+                ExpressionAttributeNames: { '#col': options.column },
             };
             if (options.where) {
-                const { filterExpression, expressionAttributeNames, expressionAttributeValues } = this.buildFilterExpression(options.where);
-                params.FilterExpression = filterExpression;
-                params.ExpressionAttributeNames = expressionAttributeNames;
-                params.ExpressionAttributeValues = expressionAttributeValues;
+                const filterExpression = this.buildFilterExpression(options.where, params.ExpressionAttributeNames, {});
+                if (filterExpression.expression) {
+                    params.FilterExpression = filterExpression.expression;
+                    Object.assign(params.ExpressionAttributeNames, filterExpression.names);
+                    params.ExpressionAttributeValues = filterExpression.values;
+                }
             }
-            const result = await docClient.send(new ScanCommand(params));
-            return result.Count || 0;
+            const response = await this.docClient.send(new ScanCommand(params));
+            const items = response.Items || [];
+            return items.reduce((sum, item) => sum + (Number(item[options.column]) || 0), 0);
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB count failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
         }
     }
-    async sum(connection, options) {
-        // DynamoDB doesn't support aggregations natively - need to scan and calculate
+    async avg(options) {
+        this.ensureConnected();
         try {
-            const result = await this.query(connection, {
-                table: options.table,
-                where: options.where,
-                env: options.env,
-                product: options.product,
-                database: options.database,
-            });
-            return result.data.reduce((sum, item) => sum + (item[options.column] || 0), 0);
+            // DynamoDB doesn't have native aggregations, need to scan and calculate
+            const { ScanCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            const params = {
+                TableName: options.table,
+                ProjectionExpression: `#col`,
+                ExpressionAttributeNames: { '#col': options.column },
+            };
+            if (options.where) {
+                const filterExpression = this.buildFilterExpression(options.where, params.ExpressionAttributeNames, {});
+                if (filterExpression.expression) {
+                    params.FilterExpression = filterExpression.expression;
+                    Object.assign(params.ExpressionAttributeNames, filterExpression.names);
+                    params.ExpressionAttributeValues = filterExpression.values;
+                }
+            }
+            const response = await this.docClient.send(new ScanCommand(params));
+            const items = response.Items || [];
+            if (items.length === 0)
+                return 0;
+            const sum = items.reduce((acc, item) => acc + (Number(item[options.column]) || 0), 0);
+            return sum / items.length;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB sum failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
         }
     }
-    async avg(connection, options) {
+    async min(options) {
+        this.ensureConnected();
         try {
-            const result = await this.query(connection, {
-                table: options.table,
-                where: options.where,
-                env: options.env,
-                product: options.product,
-                database: options.database,
-            });
-            const sum = result.data.reduce((total, item) => total + (item[options.column] || 0), 0);
-            return result.data.length > 0 ? sum / result.data.length : 0;
+            const { ScanCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            const params = {
+                TableName: options.table,
+                ProjectionExpression: `#col`,
+                ExpressionAttributeNames: { '#col': options.column },
+            };
+            if (options.where) {
+                const filterExpression = this.buildFilterExpression(options.where, params.ExpressionAttributeNames, {});
+                if (filterExpression.expression) {
+                    params.FilterExpression = filterExpression.expression;
+                    Object.assign(params.ExpressionAttributeNames, filterExpression.names);
+                    params.ExpressionAttributeValues = filterExpression.values;
+                }
+            }
+            const response = await this.docClient.send(new ScanCommand(params));
+            const items = response.Items || [];
+            if (items.length === 0)
+                return null;
+            return items.reduce((min, item) => {
+                const val = item[options.column];
+                return min === null || val < min ? val : min;
+            }, null);
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB avg failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
         }
     }
-    async min(connection, options) {
+    async max(options) {
+        this.ensureConnected();
         try {
-            const result = await this.query(connection, {
-                table: options.table,
-                where: options.where,
-                env: options.env,
-                product: options.product,
-                database: options.database,
-            });
-            if (result.data.length === 0)
-                return 0;
-            return result.data.reduce((min, item) => {
-                const value = item[options.column];
-                return value < min ? value : min;
-            }, result.data[0][options.column]);
+            const { ScanCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            const params = {
+                TableName: options.table,
+                ProjectionExpression: `#col`,
+                ExpressionAttributeNames: { '#col': options.column },
+            };
+            if (options.where) {
+                const filterExpression = this.buildFilterExpression(options.where, params.ExpressionAttributeNames, {});
+                if (filterExpression.expression) {
+                    params.FilterExpression = filterExpression.expression;
+                    Object.assign(params.ExpressionAttributeNames, filterExpression.names);
+                    params.ExpressionAttributeValues = filterExpression.values;
+                }
+            }
+            const response = await this.docClient.send(new ScanCommand(params));
+            const items = response.Items || [];
+            if (items.length === 0)
+                return null;
+            return items.reduce((max, item) => {
+                const val = item[options.column];
+                return max === null || val > max ? val : max;
+            }, null);
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB min failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
         }
     }
-    async max(connection, options) {
+    async aggregate(builtAggregation) {
+        this.ensureConnected();
         try {
-            const result = await this.query(connection, {
-                table: options.table,
-                where: options.where,
-                env: options.env,
-                product: options.product,
-                database: options.database,
-            });
-            if (result.data.length === 0)
-                return 0;
-            return result.data.reduce((max, item) => {
-                const value = item[options.column];
-                return value > max ? value : max;
-            }, result.data[0][options.column]);
+            // DynamoDB doesn't support native aggregations - scan and compute in memory
+            const { ScanCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            const options = builtAggregation.options;
+            const params = {
+                TableName: options.table,
+            };
+            if (options.where) {
+                const filterExpression = this.buildFilterExpression(options.where, {}, {});
+                if (filterExpression.expression) {
+                    params.FilterExpression = filterExpression.expression;
+                    params.ExpressionAttributeNames = filterExpression.names;
+                    params.ExpressionAttributeValues = filterExpression.values;
+                }
+            }
+            const response = await this.docClient.send(new ScanCommand(params));
+            const items = response.Items || [];
+            // Compute aggregations in memory
+            const result = {};
+            const operations = options.operations || {};
+            for (const [alias, op] of Object.entries(operations)) {
+                const operation = op;
+                if (operation.$COUNT) {
+                    result[alias] = items.length;
+                }
+                else if (operation.$SUM) {
+                    result[alias] = items.reduce((sum, item) => sum + (Number(item[operation.$SUM]) || 0), 0);
+                }
+                else if (operation.$AVG) {
+                    const values = items.map((item) => Number(item[operation.$AVG]) || 0);
+                    result[alias] = values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+                }
+                else if (operation.$MIN) {
+                    const values = items.map((item) => item[operation.$MIN]).filter((v) => v != null);
+                    result[alias] = values.length > 0 ? Math.min(...values) : null;
+                }
+                else if (operation.$MAX) {
+                    const values = items.map((item) => item[operation.$MAX]).filter((v) => v != null);
+                    result[alias] = values.length > 0 ? Math.max(...values) : null;
+                }
+            }
+            return result;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB max failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
         }
     }
-    async groupBy(connection, options) {
+    async groupBy(builtGroupBy) {
+        this.ensureConnected();
         try {
-            // DynamoDB doesn't support GROUP BY - need to scan and group manually
-            // WARNING: This scans the entire table - use with caution on large tables
-            const result = await this.query(connection, {
-                table: options.table,
-                where: options.where,
-                env: options.env,
-                product: options.product,
-                database: options.database,
-            });
+            // DynamoDB doesn't support native GROUP BY - scan and group in memory
+            const { ScanCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            const options = builtGroupBy.options;
+            const params = {
+                TableName: options.table,
+            };
+            if (options.where) {
+                const filterExpression = this.buildFilterExpression(options.where, {}, {});
+                if (filterExpression.expression) {
+                    params.FilterExpression = filterExpression.expression;
+                    params.ExpressionAttributeNames = filterExpression.names;
+                    params.ExpressionAttributeValues = filterExpression.values;
+                }
+            }
+            const response = await this.docClient.send(new ScanCommand(params));
+            const items = response.Items || [];
+            // Group items in memory
             const groups = new Map();
-            result.data.forEach((item) => {
-                // Create group key
-                const groupKey = options.groupBy.map((col) => item[col]).join('|');
+            const groupByColumns = options.groupBy || [];
+            for (const item of items) {
+                const groupKey = groupByColumns.map((col) => String(item[col])).join('|');
                 if (!groups.has(groupKey)) {
-                    const groupData = {};
-                    options.groupBy.forEach((col) => {
-                        groupData[col] = item[col];
-                    });
-                    groups.set(groupKey, groupData);
+                    groups.set(groupKey, []);
                 }
-                // Accumulate aggregations
-                if (options.aggregate) {
-                    const groupData = groups.get(groupKey);
-                    Object.entries(options.aggregate).forEach(([alias, agg]) => {
-                        const aggObj = agg;
-                        // Parse operation and column
-                        let operation;
-                        let column;
-                        if (aggObj.$COUNT !== undefined) {
-                            operation = 'count';
-                            column = aggObj.$COUNT;
-                        }
-                        else if (aggObj.$SUM !== undefined) {
-                            operation = 'sum';
-                            column = aggObj.$SUM;
-                        }
-                        else if (aggObj.$AVG !== undefined) {
-                            operation = 'avg';
-                            column = aggObj.$AVG;
-                        }
-                        else if (aggObj.$MIN !== undefined) {
-                            operation = 'min';
-                            column = aggObj.$MIN;
-                        }
-                        else if (aggObj.$MAX !== undefined) {
-                            operation = 'max';
-                            column = aggObj.$MAX;
-                        }
-                        else {
-                            return; // Skip unknown format
-                        }
-                        const value = column === '*' ? 1 : item[column];
-                        if (groupData[alias] === undefined) {
-                            groupData[alias] = 0;
-                            if (operation === 'min')
-                                groupData[alias] = Infinity;
-                            if (operation === 'max')
-                                groupData[alias] = -Infinity;
-                        }
-                        switch (operation) {
-                            case 'count':
-                                groupData[alias]++;
-                                break;
-                            case 'sum':
-                                groupData[alias] += value || 0;
-                                break;
-                            case 'avg':
-                                if (!groupData[`${alias}_sum`])
-                                    groupData[`${alias}_sum`] = 0;
-                                if (!groupData[`${alias}_count`])
-                                    groupData[`${alias}_count`] = 0;
-                                groupData[`${alias}_sum`] += value || 0;
-                                groupData[`${alias}_count`]++;
-                                groupData[alias] = groupData[`${alias}_sum`] / groupData[`${alias}_count`];
-                                break;
-                            case 'min':
-                                if (value !== undefined && value < groupData[alias]) {
-                                    groupData[alias] = value;
-                                }
-                                break;
-                            case 'max':
-                                if (value !== undefined && value > groupData[alias]) {
-                                    groupData[alias] = value;
-                                }
-                                break;
-                        }
-                    });
-                }
-            });
-            // Clean up helper fields used for avg calculation
-            const results = Array.from(groups.values());
-            results.forEach((group) => {
-                Object.keys(group).forEach((key) => {
-                    if (key.endsWith('_sum') || key.endsWith('_count')) {
-                        delete group[key];
-                    }
+                groups.get(groupKey).push(item);
+            }
+            // Compute aggregations for each group
+            const results = [];
+            const operations = options.operations || {};
+            for (const [groupKey, groupItems] of groups) {
+                const group = {};
+                const keyParts = groupKey.split('|');
+                groupByColumns.forEach((col, i) => {
+                    group[col] = keyParts[i];
                 });
-            });
+                const aggregates = {};
+                for (const [alias, op] of Object.entries(operations)) {
+                    const operation = op;
+                    if (operation.$COUNT) {
+                        aggregates[alias] = groupItems.length;
+                    }
+                    else if (operation.$SUM) {
+                        aggregates[alias] = groupItems.reduce((sum, item) => sum + (Number(item[operation.$SUM]) || 0), 0);
+                    }
+                    else if (operation.$AVG) {
+                        const values = groupItems.map(item => Number(item[operation.$AVG]) || 0);
+                        aggregates[alias] = values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+                    }
+                    else if (operation.$MIN) {
+                        const values = groupItems.map(item => item[operation.$MIN]).filter(v => v != null);
+                        aggregates[alias] = values.length > 0 ? Math.min(...values) : null;
+                    }
+                    else if (operation.$MAX) {
+                        const values = groupItems.map(item => item[operation.$MAX]).filter(v => v != null);
+                        aggregates[alias] = values.length > 0 ? Math.max(...values) : null;
+                    }
+                }
+                results.push({ group, aggregates: aggregates });
+            }
             return results;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB groupBy failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
         }
     }
-    async aggregate(connection, options) {
+    // ==================== TRANSACTION METHODS ====================
+    async beginTransaction(isolationLevel, readOnly, timeout) {
+        this.ensureConnected();
+        // DynamoDB uses TransactWriteItems for transactions, not traditional BEGIN/COMMIT
+        // We create a transaction context that collects operations
+        const id = `dynamo_txn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        return {
+            id,
+            databaseType: 'dynamodb',
+            isolationLevel: enums_1.IsolationLevel.SERIALIZABLE, // DynamoDB transactions are serializable
+            readOnly: readOnly || false,
+            timeout,
+            startedAt: new Date(),
+            client: {
+                operations: [],
+                conditionChecks: [],
+            },
+            savepoints: new Map(),
+            status: 'active',
+        };
+    }
+    async commitTransaction(context) {
+        this.ensureConnected();
         try {
-            // WARNING: DynamoDB does NOT support native aggregations
-            // This implementation scans the entire table - use with caution on large tables
-            const result = await this.query(connection, {
-                table: options.table,
-                where: options.where,
-                env: options.env,
-                product: options.product,
-                database: options.database,
-            });
-            const aggregateResult = {};
-            Object.entries(options.operations).forEach(([alias, agg]) => {
-                const aggObj = agg;
-                // Parse operation and column
-                let operation;
-                let column;
-                if (aggObj.$COUNT !== undefined) {
-                    operation = 'count';
-                    column = aggObj.$COUNT;
-                }
-                else if (aggObj.$SUM !== undefined) {
-                    operation = 'sum';
-                    column = aggObj.$SUM;
-                }
-                else if (aggObj.$AVG !== undefined) {
-                    operation = 'avg';
-                    column = aggObj.$AVG;
-                }
-                else if (aggObj.$MIN !== undefined) {
-                    operation = 'min';
-                    column = aggObj.$MIN;
-                }
-                else if (aggObj.$MAX !== undefined) {
-                    operation = 'max';
-                    column = aggObj.$MAX;
-                }
-                else {
-                    return; // Skip unknown format
-                }
-                const values = column === '*'
-                    ? result.data.map(() => 1)
-                    : result.data.map((item) => item[column]);
-                switch (operation) {
-                    case 'count':
-                        aggregateResult[alias] = result.data.length;
-                        break;
-                    case 'sum':
-                        aggregateResult[alias] = values.reduce((sum, val) => sum + (val || 0), 0);
-                        break;
-                    case 'avg':
-                        const sum = values.reduce((s, val) => s + (val || 0), 0);
-                        aggregateResult[alias] = values.length > 0 ? sum / values.length : 0;
-                        break;
-                    case 'min':
-                        const minValues = values.filter((v) => v !== undefined && v !== null);
-                        aggregateResult[alias] = minValues.length > 0 ? Math.min(...minValues) : null;
-                        break;
-                    case 'max':
-                        const maxValues = values.filter((v) => v !== undefined && v !== null);
-                        aggregateResult[alias] = maxValues.length > 0 ? Math.max(...maxValues) : null;
-                        break;
-                }
-            });
-            return aggregateResult;
+            const { TransactWriteCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            const operations = context.client.operations || [];
+            if (operations.length === 0) {
+                context.status = 'committed';
+                return;
+            }
+            await this.docClient.send(new TransactWriteCommand({
+                TransactItems: operations,
+            }));
+            context.status = 'committed';
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB aggregate failed: ${error.message}`, error);
+            context.status = 'error';
+            throw database_error_1.DatabaseError.transactionError(`Failed to commit transaction: ${error.message}`, error);
         }
     }
-    // ==================== Schema Methods ====================
-    async createTable(connection, schema, options) {
-        const startTime = Date.now();
+    async rollbackTransaction(context) {
+        // DynamoDB doesn't have explicit rollback - transaction is simply not committed
+        context.client.operations = [];
+        context.status = 'rolled_back';
+    }
+    async createSavepoint(context, name) {
+        // DynamoDB does not support savepoints
+        throw new database_error_1.DatabaseError('DynamoDB does not support savepoints.', enums_1.DatabaseErrorType.NOT_SUPPORTED);
+    }
+    async releaseSavepoint(context, savepoint) {
+        throw new database_error_1.DatabaseError('DynamoDB does not support savepoints.', enums_1.DatabaseErrorType.NOT_SUPPORTED);
+    }
+    async rollbackToSavepoint(context, savepoint) {
+        throw new database_error_1.DatabaseError('DynamoDB does not support savepoints.', enums_1.DatabaseErrorType.NOT_SUPPORTED);
+    }
+    supportsSavepoints() {
+        return false;
+    }
+    // ==================== SCHEMA METHODS ====================
+    async createTable(definition, options) {
+        this.ensureConnected();
         try {
             const { CreateTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const client = connection.getRawClient();
-            // Extract key schema from columns
-            const keySchema = [];
-            const attributeDefinitions = [];
-            schema.columns.forEach((col) => {
-                if (col.primaryKey) {
-                    keySchema.push({
-                        AttributeName: col.name,
-                        KeyType: 'HASH', // Partition key
-                    });
-                    attributeDefinitions.push({
-                        AttributeName: col.name,
-                        AttributeType: this.mapColumnTypeToDynamoDB(col.type),
-                    });
-                }
-            });
-            // If no sort key specified, DynamoDB only needs partition key
-            await client.send(new CreateTableCommand({
-                TableName: schema.name,
+            // Find primary key column
+            const pkColumn = definition.columns.find(c => c.primaryKey);
+            if (!pkColumn) {
+                throw new Error('DynamoDB tables require a primary key column');
+            }
+            const keySchema = [
+                { AttributeName: pkColumn.name, KeyType: 'HASH' },
+            ];
+            const attributeDefinitions = [
+                { AttributeName: pkColumn.name, AttributeType: this.mapToDynamoType(pkColumn.type) },
+            ];
+            // Check for sort key (second column marked as primary key or sort key)
+            const sortKeyColumn = definition.columns.find(c => c.name !== pkColumn.name && c.sortKey);
+            if (sortKeyColumn) {
+                keySchema.push({ AttributeName: sortKeyColumn.name, KeyType: 'RANGE' });
+                attributeDefinitions.push({
+                    AttributeName: sortKeyColumn.name,
+                    AttributeType: this.mapToDynamoType(sortKeyColumn.type),
+                });
+            }
+            const params = {
+                TableName: definition.name,
                 KeySchema: keySchema,
                 AttributeDefinitions: attributeDefinitions,
-                BillingMode: 'PAY_PER_REQUEST', // On-demand billing
-            }));
-            const executionTime = Date.now() - startTime;
-            return {
-                success: true,
-                operation: 'create',
-                table: schema.name,
-                executionTime,
+                BillingMode: 'PAY_PER_REQUEST', // On-demand capacity
             };
+            await this.dynamoClient.send(new CreateTableCommand(params));
+            // Wait for table to be active
+            await this.waitForTableActive(definition.name);
+            // Create GSIs if defined
+            if (definition.indexes) {
+                for (const index of definition.indexes) {
+                    await this.createIndex(index);
+                }
+            }
         }
         catch (error) {
-            return {
-                success: false,
-                operation: 'create',
-                table: schema.name,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
+            if ((options === null || options === void 0 ? void 0 : options.ifNotExists) && error.name === 'ResourceInUseException') {
+                return;
+            }
+            throw database_error_1.DatabaseError.schemaError(`Failed to create table: ${error.message}`, error);
         }
     }
-    async dropTable(connection, tableName) {
-        const startTime = Date.now();
+    async alterTable(tableName, operations) {
+        this.ensureConnected();
+        // DynamoDB has very limited ALTER capabilities
+        // Can only modify GSIs and some table settings
         try {
-            const { DeleteTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const client = connection.getRawClient();
-            await client.send(new DeleteTableCommand({
-                TableName: tableName,
-            }));
-            return {
-                success: true,
-                operation: 'drop',
-                table: tableName,
-                executionTime: Date.now() - startTime,
-            };
+            for (const op of operations) {
+                if (op.type === 'ADD' && op.constraint) {
+                    // Add GSI
+                    // This would require UpdateTableCommand with GlobalSecondaryIndexUpdates
+                    throw new database_error_1.DatabaseError('Adding indexes to DynamoDB requires table recreation or GSI updates. Use createIndex instead.', enums_1.DatabaseErrorType.NOT_SUPPORTED);
+                }
+            }
         }
         catch (error) {
-            return {
-                success: false,
-                operation: 'drop',
-                table: tableName,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
+            throw database_error_1.DatabaseError.schemaError(`Failed to alter table: ${error.message}`, error);
         }
     }
-    async alterTable(connection, tableName, alterations, options) {
-        // DynamoDB doesn't support schema alterations in the traditional sense
-        // Can only modify throughput, streams, TTL, etc.
-        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.SCHEMA_ERROR, 'DynamoDB does not support traditional table alterations. You can only modify table settings.');
-    }
-    async getTableSchema(connection, tableName) {
+    async dropTable(tableName, ifExists, cascade) {
+        this.ensureConnected();
         try {
-            const { DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const client = connection.getRawClient();
-            const result = await client.send(new DescribeTableCommand({
+            const { DeleteTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+            await this.dynamoClient.send(new DeleteTableCommand({
                 TableName: tableName,
             }));
-            const table = result.Table;
-            const columns = table.KeySchema.map((key) => {
-                const attr = table.AttributeDefinitions.find((a) => a.AttributeName === key.AttributeName);
-                return {
-                    name: key.AttributeName,
-                    type: this.mapDynamoDBTypeToColumnType((attr === null || attr === void 0 ? void 0 : attr.AttributeType) || 'S'),
-                    primaryKey: key.KeyType === 'HASH',
-                    nullable: false,
-                };
-            });
-            return {
-                name: tableName,
-                columns,
-            };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.SCHEMA_ERROR, `Failed to get DynamoDB table schema: ${error.message}`, error);
+            if (ifExists && error.name === 'ResourceNotFoundException') {
+                return;
+            }
+            throw database_error_1.DatabaseError.schemaError(`Failed to drop table: ${error.message}`, error);
         }
     }
-    async listTables(connection) {
+    async listTables() {
+        this.ensureConnected();
         try {
             const { ListTablesCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const client = connection.getRawClient();
-            const result = await client.send(new ListTablesCommand({}));
-            return result.TableNames || [];
+            const response = await this.dynamoClient.send(new ListTablesCommand({}));
+            return response.TableNames || [];
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.SCHEMA_ERROR, `Failed to list DynamoDB tables: ${error.message}`, error);
+            throw database_error_1.DatabaseError.schemaError(`Failed to list tables: ${error.message}`, error);
         }
     }
-    async tableExists(connection, tableName) {
+    async tableExists(tableName) {
+        this.ensureConnected();
         try {
             const { DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const client = connection.getRawClient();
-            await client.send(new DescribeTableCommand({
+            await this.dynamoClient.send(new DescribeTableCommand({
                 TableName: tableName,
             }));
             return true;
@@ -791,761 +843,607 @@ class DynamoDBAdapter extends base_adapter_1.BaseDatabaseAdapter {
             if (error.name === 'ResourceNotFoundException') {
                 return false;
             }
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.SCHEMA_ERROR, `Failed to check DynamoDB table existence: ${error.message}`, error);
+            throw database_error_1.DatabaseError.schemaError(`Failed to check table existence: ${error.message}`, error);
         }
     }
-    // ==================== Index Methods ====================
-    async createIndex(connection, options) {
-        const startTime = Date.now();
+    async getTableSchema(tableName) {
+        var _a;
+        this.ensureConnected();
         try {
-            const { UpdateTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const client = connection.getRawClient();
-            // Build GSI definition
-            const keySchema = options.index.columns.map((col, idx) => ({
-                AttributeName: col.name,
-                KeyType: idx === 0 ? 'HASH' : 'RANGE',
-            }));
-            const attributeDefinitions = options.index.columns.map((col) => ({
-                AttributeName: col.name,
-                AttributeType: 'S', // Default to String
-            }));
-            await client.send(new UpdateTableCommand({
-                TableName: options.table,
-                AttributeDefinitions: attributeDefinitions,
-                GlobalSecondaryIndexUpdates: [
-                    {
-                        Create: {
-                            IndexName: options.index.name,
-                            KeySchema: keySchema,
-                            Projection: {
-                                ProjectionType: 'ALL',
-                            },
-                        },
-                    },
-                ],
+            const { DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+            const response = await this.dynamoClient.send(new DescribeTableCommand({
+                TableName: tableName,
             }));
+            const table = response.Table;
+            // Map attribute definitions to columns
+            const columns = (table.AttributeDefinitions || []).map((attr) => {
+                var _a;
+                return ({
+                    name: attr.AttributeName,
+                    type: this.mapFromDynamoType(attr.AttributeType),
+                    nullable: true,
+                    isPrimaryKey: ((_a = table.KeySchema) === null || _a === void 0 ? void 0 : _a.some((k) => k.AttributeName === attr.AttributeName && k.KeyType === 'HASH')) || false,
+                    isUnique: false,
+                    isAutoIncrement: false,
+                });
+            });
+            // Get primary key
+            const primaryKey = ((_a = table.KeySchema) === null || _a === void 0 ? void 0 : _a.filter((k) => k.KeyType === 'HASH').map((k) => k.AttributeName)) || [];
+            // Get GSIs as indexes
+            const indexes = (table.GlobalSecondaryIndexes || []).map((gsi) => {
+                var _a;
+                return ({
+                    name: gsi.IndexName,
+                    table: tableName,
+                    columns: ((_a = gsi.KeySchema) === null || _a === void 0 ? void 0 : _a.map((k) => k.AttributeName)) || [],
+                    unique: false,
+                    primaryKey: false,
+                    type: 'GSI',
+                });
+            });
+            // Add LSIs
+            (table.LocalSecondaryIndexes || []).forEach((lsi) => {
+                var _a;
+                indexes.push({
+                    name: lsi.IndexName,
+                    table: tableName,
+                    columns: ((_a = lsi.KeySchema) === null || _a === void 0 ? void 0 : _a.map((k) => k.AttributeName)) || [],
+                    unique: false,
+                    primaryKey: false,
+                    type: 'LSI',
+                });
+            });
             return {
-                success: true,
-                operation: 'create',
-                indexName: options.index.name,
-                table: options.table,
-                executionTime: Date.now() - startTime,
+                name: tableName,
+                columns,
+                indexes,
+                constraints: [],
+                primaryKey,
+                estimatedRowCount: Number(table.ItemCount) || 0,
             };
         }
         catch (error) {
-            return {
-                success: false,
-                operation: 'create',
-                indexName: options.index.name,
-                table: options.table,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
+            throw database_error_1.DatabaseError.schemaError(`Failed to get table schema: ${error.message}`, error);
         }
     }
-    async dropIndex(connection, options) {
-        const startTime = Date.now();
+    async createIndex(index, ifNotExists, concurrent) {
+        this.ensureConnected();
+        // DynamoDB indexes (GSI) can only be created during table creation
+        // or via UpdateTable (which is limited)
+        throw new database_error_1.DatabaseError('DynamoDB Global Secondary Indexes must be created during table creation or via UpdateTable with specific parameters.', enums_1.DatabaseErrorType.NOT_SUPPORTED);
+    }
+    async dropIndex(tableName, indexName, ifExists, concurrent, cascade) {
+        this.ensureConnected();
         try {
             const { UpdateTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const client = connection.getRawClient();
-            await client.send(new UpdateTableCommand({
-                TableName: options.table,
+            await this.dynamoClient.send(new UpdateTableCommand({
+                TableName: tableName,
                 GlobalSecondaryIndexUpdates: [
                     {
                         Delete: {
-                            IndexName: options.indexName,
+                            IndexName: indexName,
                         },
                     },
                 ],
             }));
-            return {
-                success: true,
-                operation: 'drop',
-                indexName: options.indexName,
-                table: options.table,
-                executionTime: Date.now() - startTime,
-            };
         }
         catch (error) {
-            return {
-                success: false,
-                operation: 'drop',
-                indexName: options.indexName,
-                table: options.table,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
+            if (ifExists && error.name === 'ResourceNotFoundException') {
+                return;
+            }
+            throw database_error_1.DatabaseError.schemaError(`Failed to drop index: ${error.message}`, error);
         }
     }
-    async listIndexes(connection, options) {
-        var _a, _b;
+    async listIndexes(tableName, includeSystem) {
+        this.ensureConnected();
         try {
-            const { DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const client = connection.getRawClient();
-            const result = await client.send(new DescribeTableCommand({
-                TableName: options.table,
-            }));
-            const indexes = [];
-            // Add GSIs
-            if ((_a = result.Table) === null || _a === void 0 ? void 0 : _a.GlobalSecondaryIndexes) {
-                result.Table.GlobalSecondaryIndexes.forEach((gsi) => {
-                    indexes.push({
-                        name: gsi.IndexName,
-                        table: options.table,
-                        columns: gsi.KeySchema.map((key) => key.AttributeName),
-                        columnDetails: gsi.KeySchema.map((key) => ({
-                            name: key.AttributeName,
-                            order: 'ASC',
-                        })),
-                        unique: false,
-                        primaryKey: false,
-                        type: 'GSI',
-                    });
-                });
-            }
-            // Add LSIs
-            if ((_b = result.Table) === null || _b === void 0 ? void 0 : _b.LocalSecondaryIndexes) {
-                result.Table.LocalSecondaryIndexes.forEach((lsi) => {
-                    indexes.push({
-                        name: lsi.IndexName,
-                        table: options.table,
-                        columns: lsi.KeySchema.map((key) => key.AttributeName),
-                        columnDetails: lsi.KeySchema.map((key) => ({
-                            name: key.AttributeName,
-                            order: 'ASC',
-                        })),
-                        unique: false,
-                        primaryKey: false,
-                        type: 'LSI',
-                    });
-                });
-            }
-            return indexes;
+            const schema = await this.getTableSchema(tableName);
+            return schema.indexes;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to list DynamoDB indexes: ${error.message}`, error);
+            throw database_error_1.DatabaseError.schemaError(`Failed to list indexes: ${error.message}`, error);
         }
     }
-    async getIndexStatistics(connection, tableName, indexName) {
-        var _a;
+    async getIndexStatistics(tableName, indexName) {
+        this.ensureConnected();
         try {
             const { DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const client = connection.getRawClient();
-            const result = await client.send(new DescribeTableCommand({
+            const response = await this.dynamoClient.send(new DescribeTableCommand({
                 TableName: tableName,
             }));
-            const statistics = [];
-            if ((_a = result.Table) === null || _a === void 0 ? void 0 : _a.GlobalSecondaryIndexes) {
-                result.Table.GlobalSecondaryIndexes.forEach((gsi) => {
-                    if (!indexName || gsi.IndexName === indexName) {
-                        statistics.push({
-                            indexName: gsi.IndexName,
-                            table: tableName,
-                            size: gsi.IndexSizeBytes || 0,
-                            tuplesRead: gsi.ItemCount || 0,
-                        });
-                    }
+            const results = [];
+            const table = response.Table;
+            // Add table itself as primary index
+            if (!indexName || indexName === 'PRIMARY') {
+                results.push({
+                    indexName: 'PRIMARY',
+                    tableName,
+                    scans: 0,
+                    tuplesRead: Number(table.ItemCount) || 0,
+                    sizeBytes: Number(table.TableSizeBytes) || 0,
+                    sizeFormatted: this.formatBytes(Number(table.TableSizeBytes) || 0),
                 });
             }
-            return statistics;
+            // Add GSIs
+            for (const gsi of table.GlobalSecondaryIndexes || []) {
+                if (!indexName || indexName === gsi.IndexName) {
+                    results.push({
+                        indexName: gsi.IndexName,
+                        tableName,
+                        scans: 0,
+                        tuplesRead: Number(gsi.ItemCount) || 0,
+                        sizeBytes: Number(gsi.IndexSizeBytes) || 0,
+                        sizeFormatted: this.formatBytes(Number(gsi.IndexSizeBytes) || 0),
+                    });
+                }
+            }
+            return results;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to get DynamoDB index statistics: ${error.message}`, error);
+            throw database_error_1.DatabaseError.schemaError(`Failed to get index statistics: ${error.message}`, error);
         }
     }
-    // ==================== Migration Methods ====================
+    // ==================== UTILITY METHODS ====================
+    escapeIdentifier(identifier) {
+        return identifier;
+    }
+    escapeValue(value) {
+        return JSON.stringify(value);
+    }
     /**
-     * Execute a migration operation
-     * Note: DynamoDB is schema-less, so column operations are skipped
+     * Check if value is an update operator object
      */
-    async executeMigrationOperation(connection, operation) {
-        var _a, _b, _c, _d;
-        const { CreateTableCommand, DeleteTableCommand, UpdateTableCommand, ExecuteStatementCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-        const client = connection.getRawClient();
-        switch (operation.type) {
-            case 'create_table':
-                if ((_a = operation.params) === null || _a === void 0 ? void 0 : _a.schema) {
-                    const schema = operation.params.schema;
-                    const keySchema = [];
-                    const attributeDefinitions = [];
-                    // Extract partition and sort keys from schema
-                    schema.columns.forEach((col) => {
-                        if (col.primaryKey) {
-                            keySchema.push({
-                                AttributeName: col.name,
-                                KeyType: 'HASH',
-                            });
-                            attributeDefinitions.push({
-                                AttributeName: col.name,
-                                AttributeType: this.mapColumnTypeToDynamoDB(col.type),
-                            });
-                        }
-                    });
-                    await client.send(new CreateTableCommand({
-                        TableName: schema.name,
-                        KeySchema: keySchema,
-                        AttributeDefinitions: attributeDefinitions,
-                        BillingMode: 'PAY_PER_REQUEST',
-                    }));
-                    return { executed: true, command: `CreateTable: ${schema.name}` };
-                }
-                return { executed: false };
-            case 'drop_table':
-                if (operation.table) {
-                    await client.send(new DeleteTableCommand({
-                        TableName: operation.table,
-                    }));
-                    return { executed: true, command: `DropTable: ${operation.table}` };
-                }
-                return { executed: false };
-            case 'add_index':
-                if (operation.table && ((_b = operation.params) === null || _b === void 0 ? void 0 : _b.indexName) && ((_c = operation.params) === null || _c === void 0 ? void 0 : _c.columns)) {
-                    const keySchema = operation.params.columns.map((col, idx) => ({
-                        AttributeName: col,
-                        KeyType: idx === 0 ? 'HASH' : 'RANGE',
-                    }));
-                    const attributeDefinitions = operation.params.columns.map((col) => ({
-                        AttributeName: col,
-                        AttributeType: 'S', // Default to String
-                    }));
-                    await client.send(new UpdateTableCommand({
-                        TableName: operation.table,
-                        AttributeDefinitions: attributeDefinitions,
-                        GlobalSecondaryIndexUpdates: [
-                            {
-                                Create: {
-                                    IndexName: operation.params.indexName,
-                                    KeySchema: keySchema,
-                                    Projection: {
-                                        ProjectionType: 'ALL',
-                                    },
-                                },
-                            },
-                        ],
-                    }));
-                    return { executed: true, command: `AddIndex: ${operation.params.indexName}` };
-                }
-                return { executed: false };
-            case 'drop_index':
-                if (operation.table && ((_d = operation.params) === null || _d === void 0 ? void 0 : _d.indexName)) {
-                    await client.send(new UpdateTableCommand({
-                        TableName: operation.table,
-                        GlobalSecondaryIndexUpdates: [
-                            {
-                                Delete: {
-                                    IndexName: operation.params.indexName,
-                                },
-                            },
-                        ],
-                    }));
-                    return { executed: true, command: `DropIndex: ${operation.params.indexName}` };
-                }
-                return { executed: false };
-            case 'raw_sql':
-                if (operation.sql) {
-                    // Use PartiQL for raw queries
-                    await client.send(new ExecuteStatementCommand({
-                        Statement: operation.sql,
-                    }));
-                    return { executed: true, command: `PartiQL: ${operation.sql.substring(0, 50)}...` };
-                }
-                return { executed: false };
-            // Schema-less operations - skip silently for DynamoDB
-            case 'add_column':
-            case 'drop_column':
-            case 'modify_column':
-            case 'rename_column':
-            case 'alter_table':
-                return { executed: false, command: `Skipped (schema-less): ${operation.type}` };
-            // Constraint operations - not applicable to DynamoDB
-            case 'add_constraint':
-            case 'drop_constraint':
-                return { executed: false, command: `Skipped (no constraints): ${operation.type}` };
-            default:
-                return { executed: false };
+    isUpdateOperator(value) {
+        if (!value || typeof value !== 'object')
+            return false;
+        const operators = ['$INC', '$DEC', '$MUL', '$MIN', '$MAX', '$SET', '$UNSET', '$PUSH', '$PULL', '$ADDTOSET'];
+        return operators.some(op => op in value);
+    }
+    getParameterPlaceholder(index) {
+        return `:val${index}`;
+    }
+    getColumnTypeString(columnType, options) {
+        return this.mapToDynamoType(columnType);
+    }
+    getSupportedFeatures() {
+        return [
+            base_adapter_1.DatabaseFeature.TRANSACTIONS,
+            base_adapter_1.DatabaseFeature.TTL,
+            base_adapter_1.DatabaseFeature.GLOBAL_SECONDARY_INDEXES,
+            base_adapter_1.DatabaseFeature.LOCAL_SECONDARY_INDEXES,
+            base_adapter_1.DatabaseFeature.BATCH_OPERATIONS,
+            base_adapter_1.DatabaseFeature.ATOMIC_COUNTERS,
+            base_adapter_1.DatabaseFeature.CHANGE_STREAMS,
+        ];
+    }
+    parseError(error) {
+        const name = error.name || error.code;
+        let type = enums_1.DatabaseErrorType.UNKNOWN_ERROR;
+        switch (name) {
+            case 'ConditionalCheckFailedException':
+                type = enums_1.DatabaseErrorType.UNIQUE_VIOLATION;
+                break;
+            case 'ResourceNotFoundException':
+                type = enums_1.DatabaseErrorType.NOT_FOUND;
+                break;
+            case 'ResourceInUseException':
+                type = enums_1.DatabaseErrorType.SCHEMA_ERROR;
+                break;
+            case 'ValidationException':
+                type = enums_1.DatabaseErrorType.VALIDATION_ERROR;
+                break;
+            case 'ProvisionedThroughputExceededException':
+            case 'ThrottlingException':
+                type = enums_1.DatabaseErrorType.QUERY_ERROR;
+                break;
+            case 'AccessDeniedException':
+                type = enums_1.DatabaseErrorType.AUTHENTICATION_ERROR;
+                break;
         }
+        return {
+            type,
+            message: error.message || 'Unknown database error',
+            code: name,
+        };
     }
-    async runMigration(connection, migration, options) {
-        const startTime = Date.now();
-        const statements = [];
-        try {
-            // DynamoDB doesn't support transactions for schema changes
-            // Execute operations sequentially
-            for (const operation of migration.up) {
-                const result = await this.executeMigrationOperation(connection, operation);
-                if (result.command) {
-                    statements.push(result.command);
+    // ==================== PRIVATE HELPER METHODS ====================
+    ensureConnected() {
+        if (!this.connected || !this.docClient) {
+            throw new database_error_1.DatabaseError('Not connected to DynamoDB', enums_1.DatabaseErrorType.CONNECTION_ERROR);
+        }
+    }
+    buildFilterExpression(where, existingNames, existingValues) {
+        const conditions = [];
+        const names = Object.assign({}, existingNames);
+        const values = Object.assign({}, existingValues);
+        let valueIndex = Object.keys(existingValues).length;
+        for (const [key, value] of Object.entries(where)) {
+            if (key === '$AND') {
+                const andConditions = [];
+                for (const [andKey, andValue] of Object.entries(value)) {
+                    const result = this.buildFilterExpression({ [andKey]: andValue }, names, values);
+                    andConditions.push(result.expression);
+                    Object.assign(names, result.names);
+                    Object.assign(values, result.values);
                 }
+                conditions.push(`(${andConditions.join(' AND ')})`);
+            }
+            else if (key === '$OR') {
+                const orConditions = [];
+                for (const [orKey, orValue] of Object.entries(value)) {
+                    const result = this.buildFilterExpression({ [orKey]: orValue }, names, values);
+                    orConditions.push(result.expression);
+                    Object.assign(names, result.names);
+                    Object.assign(values, result.values);
+                }
+                conditions.push(`(${orConditions.join(' OR ')})`);
+            }
+            else if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                const nameKey = `#${key.replace(/[^a-zA-Z0-9]/g, '')}`;
+                names[nameKey] = key;
+                for (const [op, opValue] of Object.entries(value)) {
+                    const valueKey = `:val${valueIndex++}`;
+                    values[valueKey] = opValue;
+                    switch (op) {
+                        case '$EQ':
+                            conditions.push(`${nameKey} = ${valueKey}`);
+                            break;
+                        case '$NE':
+                        case '$NOT':
+                            conditions.push(`${nameKey} <> ${valueKey}`);
+                            break;
+                        case '$GT':
+                            conditions.push(`${nameKey} > ${valueKey}`);
+                            break;
+                        case '$GTE':
+                            conditions.push(`${nameKey} >= ${valueKey}`);
+                            break;
+                        case '$LT':
+                            conditions.push(`${nameKey} < ${valueKey}`);
+                            break;
+                        case '$LTE':
+                            conditions.push(`${nameKey} <= ${valueKey}`);
+                            break;
+                        case '$IN':
+                            // DynamoDB requires separate placeholders for each value in IN clause
+                            if (Array.isArray(opValue)) {
+                                const inPlaceholders = [];
+                                for (const item of opValue) {
+                                    const itemKey = `:val${valueIndex++}`;
+                                    values[itemKey] = item;
+                                    inPlaceholders.push(itemKey);
+                                }
+                                // Remove the original valueKey since we're using individual placeholders
+                                delete values[valueKey];
+                                conditions.push(`${nameKey} IN (${inPlaceholders.join(', ')})`);
+                            }
+                            else {
+                                // Single value - treat as equality
+                                conditions.push(`${nameKey} = ${valueKey}`);
+                            }
+                            break;
+                        case '$BETWEEN':
+                            const [min, max] = opValue;
+                            const minKey = `:val${valueIndex++}`;
+                            const maxKey = `:val${valueIndex++}`;
+                            values[minKey] = min;
+                            values[maxKey] = max;
+                            conditions.push(`${nameKey} BETWEEN ${minKey} AND ${maxKey}`);
+                            break;
+                        case '$LIKE':
+                            conditions.push(`contains(${nameKey}, ${valueKey})`);
+                            break;
+                        case '$IS_NULL':
+                            if (opValue) {
+                                conditions.push(`attribute_not_exists(${nameKey})`);
+                            }
+                            else {
+                                conditions.push(`attribute_exists(${nameKey})`);
+                            }
+                            delete values[valueKey];
+                            break;
+                        case '$IS_NOT_NULL':
+                            if (opValue) {
+                                conditions.push(`attribute_exists(${nameKey})`);
+                            }
+                            else {
+                                conditions.push(`attribute_not_exists(${nameKey})`);
+                            }
+                            delete values[valueKey];
+                            break;
+                    }
+                }
+            }
+            else {
+                const nameKey = `#${key.replace(/[^a-zA-Z0-9]/g, '')}`;
+                const valueKey = `:val${valueIndex++}`;
+                names[nameKey] = key;
+                values[valueKey] = value;
+                conditions.push(`${nameKey} = ${valueKey}`);
             }
-            // Record migration in history table
-            await this.recordMigration(connection, migration);
-            return {
-                tag: migration.tag,
-                status: migration_types_1.MigrationStatus.COMPLETED,
-                direction: migration_types_1.MigrationDirection.UP,
-                executedAt: new Date(),
-                duration: Date.now() - startTime,
-                statements,
-            };
-        }
-        catch (error) {
-            return {
-                tag: migration.tag,
-                status: migration_types_1.MigrationStatus.FAILED,
-                direction: migration_types_1.MigrationDirection.UP,
-                executedAt: new Date(),
-                duration: Date.now() - startTime,
-                error: error.message,
-                statements,
-            };
         }
+        return {
+            expression: conditions.join(' AND '),
+            names,
+            values,
+        };
     }
-    async rollbackMigration(connection, migration, options) {
-        const startTime = Date.now();
-        const statements = [];
-        try {
-            // Execute rollback operations
-            for (const operation of migration.down) {
-                const result = await this.executeMigrationOperation(connection, operation);
-                if (result.command) {
-                    statements.push(result.command);
+    buildUpdateExpression(data) {
+        const setClauses = [];
+        const addClauses = [];
+        const names = {};
+        const values = {};
+        let valueIndex = 0;
+        for (const [key, value] of Object.entries(data)) {
+            const nameKey = `#${key.replace(/[^a-zA-Z0-9]/g, '')}`;
+            names[nameKey] = key;
+            if (value && typeof value === 'object' && this.isUpdateOperator(value)) {
+                const valueKey = `:val${valueIndex++}`;
+                if ('$INC' in value) {
+                    values[valueKey] = value.$INC;
+                    addClauses.push(`${nameKey} ${valueKey}`);
+                }
+                else if ('$DEC' in value) {
+                    values[valueKey] = -value.$DEC;
+                    addClauses.push(`${nameKey} ${valueKey}`);
+                }
+                else if ('$MUL' in value) {
+                    // DynamoDB doesn't have native multiply - use SET with expression
+                    const mulValueKey = `:mul${valueIndex++}`;
+                    values[mulValueKey] = value.$MUL;
+                    setClauses.push(`${nameKey} = ${nameKey} * ${mulValueKey}`);
+                }
+                else if ('$MIN' in value) {
+                    // DynamoDB doesn't have native min - use if_not_exists or conditional
+                    // For simplicity, just set the value (user should use conditional writes for atomic min)
+                    values[valueKey] = value.$MIN;
+                    setClauses.push(`${nameKey} = if_not_exists(${nameKey}, ${valueKey})`);
+                }
+                else if ('$MAX' in value) {
+                    // DynamoDB doesn't have native max - similar to min
+                    values[valueKey] = value.$MAX;
+                    setClauses.push(`${nameKey} = if_not_exists(${nameKey}, ${valueKey})`);
+                }
+                else if ('$SET' in value) {
+                    values[valueKey] = value.$SET;
+                    setClauses.push(`${nameKey} = ${valueKey}`);
+                }
+                else if ('$UNSET' in value && value.$UNSET) {
+                    // Use REMOVE clause for unsetting
+                    // Note: REMOVE is handled separately
+                    setClauses.push(`REMOVE ${nameKey}`);
+                }
+                else if ('$PUSH' in value) {
+                    // DynamoDB list_append for arrays
+                    values[valueKey] = [value.$PUSH];
+                    setClauses.push(`${nameKey} = list_append(if_not_exists(${nameKey}, :emptyList), ${valueKey})`);
+                    values[':emptyList'] = [];
+                }
+                else if ('$ADDTOSET' in value) {
+                    // DynamoDB ADD for sets
+                    values[valueKey] = new Set([value.$ADDTOSET]);
+                    addClauses.push(`${nameKey} ${valueKey}`);
                 }
             }
-            // Remove migration from history table
-            await this.removeMigration(connection, migration.tag);
-            return {
-                tag: migration.tag,
-                status: migration_types_1.MigrationStatus.ROLLED_BACK,
-                direction: migration_types_1.MigrationDirection.DOWN,
-                executedAt: new Date(),
-                duration: Date.now() - startTime,
-                statements,
-            };
-        }
-        catch (error) {
-            return {
-                tag: migration.tag,
-                status: migration_types_1.MigrationStatus.FAILED,
-                direction: migration_types_1.MigrationDirection.DOWN,
-                executedAt: new Date(),
-                duration: Date.now() - startTime,
-                error: error.message,
-                statements,
-            };
+            else {
+                const valueKey = `:val${valueIndex++}`;
+                values[valueKey] = value;
+                setClauses.push(`${nameKey} = ${valueKey}`);
+            }
         }
-    }
-    async getMigrationHistory(connection, options) {
-        try {
-            const { ScanCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
-            const docClient = connection.getClient();
-            // Ensure migration table exists
-            await this.ensureMigrationTable(connection);
-            const result = await docClient.send(new ScanCommand({
-                TableName: '_ductape_migrations',
-            }));
-            return (result.Items || []).map((item) => ({
-                tag: item.tag,
-                name: item.name,
-                env: options.env,
-                product: options.product,
-                database: options.database,
-                status: migration_types_1.MigrationStatus.COMPLETED,
-                direction: migration_types_1.MigrationDirection.UP,
-                appliedAt: new Date(item.executed_at),
-            }));
+        let expression = '';
+        if (setClauses.length > 0) {
+            expression += `SET ${setClauses.join(', ')}`;
         }
-        catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.MIGRATION_ERROR, `Failed to get DynamoDB migration history: ${error.message}`, error);
+        if (addClauses.length > 0) {
+            if (expression)
+                expression += ' ';
+            expression += `ADD ${addClauses.join(', ')}`;
         }
+        return { expression, names, values };
     }
     /**
-     * Ensure migration tracking table exists
+     * Extract key condition from where clause if partition key is present.
+     * This enables using Query instead of Scan for better performance.
      */
-    async ensureMigrationTable(connection) {
+    async extractKeyCondition(where, tableName) {
+        var _a, _b, _c;
+        if (!where || Object.keys(where).length === 0) {
+            return { keyCondition: null, filterCondition: null };
+        }
         try {
-            const { CreateTableCommand, DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const client = connection.getRawClient();
-            // Check if table exists
-            try {
-                await client.send(new DescribeTableCommand({
-                    TableName: '_ductape_migrations',
-                }));
-                return; // Table exists
+            const { DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+            const response = await this.dynamoClient.send(new DescribeTableCommand({
+                TableName: tableName,
+            }));
+            const keySchema = ((_a = response.Table) === null || _a === void 0 ? void 0 : _a.KeySchema) || [];
+            if (keySchema.length === 0) {
+                return { keyCondition: null, filterCondition: null };
             }
-            catch (error) {
-                if (error.name !== 'ResourceNotFoundException') {
-                    throw error;
+            // Get partition key and sort key names
+            const partitionKeyName = (_b = keySchema.find((k) => k.KeyType === 'HASH')) === null || _b === void 0 ? void 0 : _b.AttributeName;
+            const sortKeyName = (_c = keySchema.find((k) => k.KeyType === 'RANGE')) === null || _c === void 0 ? void 0 : _c.AttributeName;
+            if (!partitionKeyName) {
+                return { keyCondition: null, filterCondition: null };
+            }
+            // Check if partition key is in the where clause
+            const partitionKeyValue = this.getWhereValue(where, partitionKeyName);
+            if (partitionKeyValue === undefined) {
+                // No partition key - must use Scan
+                return { keyCondition: null, filterCondition: null };
+            }
+            // Build key condition expression
+            const keyNames = {};
+            const keyValues = {};
+            const keyConditions = [];
+            // Add partition key condition (must be equality)
+            const pkNameKey = `#pk`;
+            const pkValueKey = `:pkval`;
+            keyNames[pkNameKey] = partitionKeyName;
+            keyValues[pkValueKey] = partitionKeyValue;
+            keyConditions.push(`${pkNameKey} = ${pkValueKey}`);
+            // Check for sort key condition (can be equality or range)
+            if (sortKeyName) {
+                const sortKeyOp = this.getWhereOperator(where, sortKeyName);
+                if (sortKeyOp) {
+                    const skNameKey = `#sk`;
+                    keyNames[skNameKey] = sortKeyName;
+                    if (sortKeyOp.op === '$EQ' || sortKeyOp.op === 'equality') {
+                        const skValueKey = `:skval`;
+                        keyValues[skValueKey] = sortKeyOp.value;
+                        keyConditions.push(`${skNameKey} = ${skValueKey}`);
+                    }
+                    else if (sortKeyOp.op === '$GT') {
+                        const skValueKey = `:skval`;
+                        keyValues[skValueKey] = sortKeyOp.value;
+                        keyConditions.push(`${skNameKey} > ${skValueKey}`);
+                    }
+                    else if (sortKeyOp.op === '$GTE') {
+                        const skValueKey = `:skval`;
+                        keyValues[skValueKey] = sortKeyOp.value;
+                        keyConditions.push(`${skNameKey} >= ${skValueKey}`);
+                    }
+                    else if (sortKeyOp.op === '$LT') {
+                        const skValueKey = `:skval`;
+                        keyValues[skValueKey] = sortKeyOp.value;
+                        keyConditions.push(`${skNameKey} < ${skValueKey}`);
+                    }
+                    else if (sortKeyOp.op === '$LTE') {
+                        const skValueKey = `:skval`;
+                        keyValues[skValueKey] = sortKeyOp.value;
+                        keyConditions.push(`${skNameKey} <= ${skValueKey}`);
+                    }
+                    else if (sortKeyOp.op === '$BETWEEN') {
+                        const [min, max] = sortKeyOp.value;
+                        keyValues[`:skmin`] = min;
+                        keyValues[`:skmax`] = max;
+                        keyConditions.push(`${skNameKey} BETWEEN :skmin AND :skmax`);
+                    }
+                    else if (sortKeyOp.op === '$BEGINS_WITH') {
+                        const skValueKey = `:skval`;
+                        keyValues[skValueKey] = sortKeyOp.value;
+                        keyConditions.push(`begins_with(${skNameKey}, ${skValueKey})`);
+                    }
                 }
             }
-            // Create migration table
-            await client.send(new CreateTableCommand({
-                TableName: '_ductape_migrations',
-                KeySchema: [
-                    {
-                        AttributeName: 'tag',
-                        KeyType: 'HASH',
-                    },
-                ],
-                AttributeDefinitions: [
-                    {
-                        AttributeName: 'tag',
-                        AttributeType: 'S',
-                    },
-                ],
-                BillingMode: 'PAY_PER_REQUEST',
-            }));
-            // Wait for table to be active
-            await new Promise((resolve) => setTimeout(resolve, 5000));
-        }
-        catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.MIGRATION_ERROR, `Failed to ensure migration table: ${error.message}`, error);
-        }
-    }
-    /**
-     * Record migration execution
-     */
-    async recordMigration(connection, migration) {
-        try {
-            const { PutCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
-            const docClient = connection.getClient();
-            await this.ensureMigrationTable(connection);
-            await docClient.send(new PutCommand({
-                TableName: '_ductape_migrations',
-                Item: {
-                    tag: migration.tag,
-                    name: migration.name,
-                    executed_at: new Date().toISOString(),
+            // Build filter condition for remaining where clauses
+            const filterWhere = Object.assign({}, where);
+            delete filterWhere[partitionKeyName];
+            if (sortKeyName) {
+                delete filterWhere[sortKeyName];
+            }
+            let filterCondition = null;
+            if (Object.keys(filterWhere).length > 0) {
+                filterCondition = this.buildFilterExpression(filterWhere, {}, {});
+            }
+            return {
+                keyCondition: {
+                    expression: keyConditions.join(' AND '),
+                    names: keyNames,
+                    values: keyValues,
                 },
-            }));
+                filterCondition,
+            };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.MIGRATION_ERROR, `Failed to record migration: ${error.message}`, error);
+            // If we can't get table metadata, fall back to Scan
+            return { keyCondition: null, filterCondition: null };
         }
     }
     /**
-     * Remove migration from history
+     * Get simple value from where clause for a specific field
      */
-    async removeMigration(connection, tag) {
-        try {
-            const { DeleteCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
-            const docClient = connection.getClient();
-            await docClient.send(new DeleteCommand({
-                TableName: '_ductape_migrations',
-                Key: { tag },
-            }));
-        }
-        catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.MIGRATION_ERROR, `Failed to remove migration: ${error.message}`, error);
+    getWhereValue(where, fieldName) {
+        const value = where[fieldName];
+        if (value === undefined) {
+            return undefined;
         }
-    }
-    // ==================== Helper Methods ====================
-    hasPartitionKeyInWhere(where) {
-        // Simple check - in production would need table metadata
-        return where && typeof where === 'object' && Object.keys(where).length > 0;
-    }
-    buildQueryParams(options) {
-        const params = {
-            TableName: options.table,
-        };
-        if (options.where) {
-            const { keyConditionExpression, expressionAttributeNames, expressionAttributeValues } = this.buildKeyConditionExpression(options.where);
-            params.KeyConditionExpression = keyConditionExpression;
-            params.ExpressionAttributeNames = expressionAttributeNames;
-            params.ExpressionAttributeValues = expressionAttributeValues;
+        // Simple equality check
+        if (typeof value !== 'object' || value === null) {
+            return value;
         }
-        if (options.limit) {
-            params.Limit = options.limit;
+        // Check for $EQ operator
+        if (value.$EQ !== undefined) {
+            return value.$EQ;
         }
-        return params;
-    }
-    buildScanParams(options) {
-        const params = {
-            TableName: options.table,
-        };
-        if (options.where) {
-            const { filterExpression, expressionAttributeNames, expressionAttributeValues } = this.buildFilterExpression(options.where);
-            params.FilterExpression = filterExpression;
-            params.ExpressionAttributeNames = expressionAttributeNames;
-            params.ExpressionAttributeValues = expressionAttributeValues;
-        }
-        if (options.limit) {
-            params.Limit = options.limit;
-        }
-        return params;
+        return undefined;
     }
     /**
-     * Build DynamoDB key condition expression (for Query operations)
-     * Supports both simplified syntax (GT, LT, etc.) and legacy $ prefix operators
+     * Get operator and value from where clause for a specific field
      */
-    buildKeyConditionExpression(where) {
-        const names = {};
-        const values = {};
-        let valueIndex = 0;
-        const buildCondition = (condition) => {
-            if (typeof condition !== 'object' || condition === null) {
-                const valKey = `:val${valueIndex++}`;
-                values[valKey] = condition;
-                return valKey;
+    getWhereOperator(where, fieldName) {
+        const value = where[fieldName];
+        if (value === undefined) {
+            return null;
+        }
+        // Simple equality
+        if (typeof value !== 'object' || value === null) {
+            return { op: 'equality', value };
+        }
+        // Check for operators
+        for (const op of ['$EQ', '$GT', '$GTE', '$LT', '$LTE', '$BETWEEN', '$BEGINS_WITH']) {
+            if (value[op] !== undefined) {
+                return { op, value: value[op] };
             }
-            const conditions = [];
-            for (const [key, value] of Object.entries(condition)) {
-                const attrName = `#${key}`;
-                names[attrName] = key;
-                if (typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
-                    // Handle comparison operators
-                    for (const [op, opValue] of Object.entries(value)) {
-                        const valKey = `:val${valueIndex++}`;
-                        values[valKey] = opValue;
-                        switch (op) {
-                            case 'GT':
-                            case '$gt':
-                                conditions.push(`${attrName} > ${valKey}`);
-                                break;
-                            case 'GTE':
-                            case '$gte':
-                                conditions.push(`${attrName} >= ${valKey}`);
-                                break;
-                            case 'LT':
-                            case '$lt':
-                                conditions.push(`${attrName} < ${valKey}`);
-                                break;
-                            case 'LTE':
-                            case '$lte':
-                                conditions.push(`${attrName} <= ${valKey}`);
-                                break;
-                            case 'NE':
-                            case 'NOT':
-                            case '$ne':
-                                conditions.push(`${attrName} <> ${valKey}`);
-                                break;
-                            case 'BETWEEN':
-                            case '$between':
-                                if (Array.isArray(opValue) && opValue.length === 2) {
-                                    const valKey2 = `:val${valueIndex++}`;
-                                    values[valKey] = opValue[0];
-                                    values[valKey2] = opValue[1];
-                                    conditions.push(`${attrName} BETWEEN ${valKey} AND ${valKey2}`);
-                                }
-                                break;
-                            default:
-                                // Simple equality for unknown operators
-                                conditions.push(`${attrName} = ${valKey}`);
-                        }
-                    }
-                }
-                else {
-                    // Simple equality
-                    const valKey = `:val${valueIndex++}`;
-                    values[valKey] = value;
-                    conditions.push(`${attrName} = ${valKey}`);
-                }
-            }
-            return conditions.join(' AND ');
-        };
-        const expression = buildCondition(where);
-        return {
-            keyConditionExpression: expression,
-            expressionAttributeNames: names,
-            expressionAttributeValues: values,
-        };
+        }
+        return null;
     }
-    /**
-     * Build DynamoDB filter expression (for Scan and Query operations)
-     * Supports both simplified syntax (GT, LT, AND, OR, etc.) and legacy $ prefix operators
-     */
-    buildFilterExpression(where) {
-        const names = {};
-        const values = {};
-        let valueIndex = 0;
-        const buildCondition = (condition) => {
-            if (typeof condition !== 'object' || condition === null) {
-                const valKey = `:val${valueIndex++}`;
-                values[valKey] = condition;
-                return valKey;
-            }
-            // Handle logical operators (supports $AND, AND, and legacy $and)
-            if (condition.$AND || condition.AND || condition.$and) {
-                const andConditions = condition.$AND || condition.AND || condition.$and;
-                if (typeof andConditions === 'object' && !Array.isArray(andConditions)) {
-                    // New syntax: { $AND: { col1: val1, col2: val2 } }
-                    return buildCondition(andConditions);
-                }
-                else {
-                    // Array syntax: { $AND: [cond1, cond2] }
-                    const subConditions = andConditions.map(buildCondition);
-                    return `(${subConditions.join(' AND ')})`;
-                }
-            }
-            if (condition.$OR || condition.OR || condition.$or) {
-                const orConditions = condition.$OR || condition.OR || condition.$or;
-                if (typeof orConditions === 'object' && !Array.isArray(orConditions)) {
-                    // New syntax: { $OR: { col1: val1, col2: val2 } }
-                    const subConditions = [];
-                    for (const [key, value] of Object.entries(orConditions)) {
-                        if (key === '$AND' || key === 'AND' || key === '$and' || key === '$OR' || key === 'OR' || key === '$or') {
-                            subConditions.push(buildCondition({ [key]: value }));
-                        }
-                        else {
-                            subConditions.push(buildCondition({ [key]: value }));
-                        }
-                    }
-                    return `(${subConditions.join(' OR ')})`;
-                }
-                else {
-                    // Array syntax: { $OR: [cond1, cond2] }
-                    const subConditions = orConditions.map(buildCondition);
-                    return `(${subConditions.join(' OR ')})`;
-                }
-            }
-            // Handle column conditions
-            const conditions = [];
-            for (const [key, value] of Object.entries(condition)) {
-                // Skip logical operators at this level
-                if (key === '$AND' || key === 'AND' || key === '$and' || key === '$OR' || key === 'OR' || key === '$or') {
-                    continue;
-                }
-                const attrName = `#${key}`;
-                names[attrName] = key;
-                if (typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
-                    // Handle comparison operators
-                    for (const [op, opValue] of Object.entries(value)) {
-                        switch (op) {
-                            // Preferred $-prefixed syntax
-                            case '$GT':
-                            case 'GT':
-                            case '$gt': {
-                                const valKey = `:val${valueIndex++}`;
-                                values[valKey] = opValue;
-                                conditions.push(`${attrName} > ${valKey}`);
-                                break;
-                            }
-                            case '$GTE':
-                            case 'GTE':
-                            case '$gte': {
-                                const valKey = `:val${valueIndex++}`;
-                                values[valKey] = opValue;
-                                conditions.push(`${attrName} >= ${valKey}`);
-                                break;
-                            }
-                            case '$LT':
-                            case 'LT':
-                            case '$lt': {
-                                const valKey = `:val${valueIndex++}`;
-                                values[valKey] = opValue;
-                                conditions.push(`${attrName} < ${valKey}`);
-                                break;
-                            }
-                            case '$LTE':
-                            case 'LTE':
-                            case '$lte': {
-                                const valKey = `:val${valueIndex++}`;
-                                values[valKey] = opValue;
-                                conditions.push(`${attrName} <= ${valKey}`);
-                                break;
-                            }
-                            case '$NE':
-                            case '$NOT':
-                            case 'NE':
-                            case 'NOT':
-                            case '$ne': {
-                                const valKey = `:val${valueIndex++}`;
-                                values[valKey] = opValue;
-                                conditions.push(`${attrName} <> ${valKey}`);
-                                break;
-                            }
-                            case '$IN':
-                            case 'IN':
-                            case '$in':
-                                if (Array.isArray(opValue)) {
-                                    const inConditions = opValue.map((val) => {
-                                        const valKey = `:val${valueIndex++}`;
-                                        values[valKey] = val;
-                                        return `${attrName} = ${valKey}`;
-                                    });
-                                    conditions.push(`(${inConditions.join(' OR ')})`);
-                                }
-                                break;
-                            case '$NOT_IN':
-                            case 'NOT_IN':
-                            case '$nin':
-                                if (Array.isArray(opValue)) {
-                                    const notInConditions = opValue.map((val) => {
-                                        const valKey = `:val${valueIndex++}`;
-                                        values[valKey] = val;
-                                        return `${attrName} <> ${valKey}`;
-                                    });
-                                    conditions.push(`(${notInConditions.join(' AND ')})`);
-                                }
-                                break;
-                            case '$LIKE':
-                            case 'LIKE':
-                            case '$like': {
-                                // DynamoDB uses contains() function for substring matching
-                                const valKey = `:val${valueIndex++}`;
-                                // Convert SQL LIKE pattern to substring (remove % wildcards)
-                                const searchValue = String(opValue).replace(/%/g, '');
-                                values[valKey] = searchValue;
-                                conditions.push(`contains(${attrName}, ${valKey})`);
-                                break;
-                            }
-                            case '$IS_NULL':
-                            case 'IS_NULL':
-                            case '$null':
-                                conditions.push(`attribute_not_exists(${attrName})`);
-                                break;
-                            case '$IS_NOT_NULL':
-                            case 'IS_NOT_NULL':
-                            case '$notNull':
-                                conditions.push(`attribute_exists(${attrName})`);
-                                break;
-                            case '$BETWEEN':
-                            case 'BETWEEN':
-                            case '$between':
-                                if (Array.isArray(opValue) && opValue.length === 2) {
-                                    const valKey1 = `:val${valueIndex++}`;
-                                    const valKey2 = `:val${valueIndex++}`;
-                                    values[valKey1] = opValue[0];
-                                    values[valKey2] = opValue[1];
-                                    conditions.push(`${attrName} BETWEEN ${valKey1} AND ${valKey2}`);
-                                }
-                                break;
-                        }
-                    }
-                }
-                else {
-                    // Simple equality
-                    const valKey = `:val${valueIndex++}`;
-                    values[valKey] = value;
-                    conditions.push(`${attrName} = ${valKey}`);
-                }
+    async getTableKey(tableName, item) {
+        var _a;
+        const { DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+        const response = await this.dynamoClient.send(new DescribeTableCommand({
+            TableName: tableName,
+        }));
+        const key = {};
+        const keySchema = ((_a = response.Table) === null || _a === void 0 ? void 0 : _a.KeySchema) || [];
+        for (const keyDef of keySchema) {
+            key[keyDef.AttributeName] = item[keyDef.AttributeName];
+        }
+        return key;
+    }
+    async waitForTableActive(tableName, maxWait = 60000) {
+        var _a;
+        const { DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+        const startTime = Date.now();
+        while (Date.now() - startTime < maxWait) {
+            const response = await this.dynamoClient.send(new DescribeTableCommand({
+                TableName: tableName,
+            }));
+            if (((_a = response.Table) === null || _a === void 0 ? void 0 : _a.TableStatus) === 'ACTIVE') {
+                return;
             }
-            return conditions.join(' AND ');
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+        throw new Error(`Table ${tableName} did not become active within ${maxWait}ms`);
+    }
+    mapToDynamoType(columnType) {
+        const typeMap = {
+            [enums_1.ColumnType.INTEGER]: 'N',
+            [enums_1.ColumnType.BIGINT]: 'N',
+            [enums_1.ColumnType.FLOAT]: 'N',
+            [enums_1.ColumnType.DOUBLE]: 'N',
+            [enums_1.ColumnType.DECIMAL]: 'N',
+            [enums_1.ColumnType.STRING]: 'S',
+            [enums_1.ColumnType.TEXT]: 'S',
+            [enums_1.ColumnType.BOOLEAN]: 'BOOL',
+            [enums_1.ColumnType.BINARY]: 'B',
+            [enums_1.ColumnType.UUID]: 'S',
         };
-        const expression = buildCondition(where);
-        return {
-            filterExpression: expression,
-            expressionAttributeNames: names,
-            expressionAttributeValues: values,
+        return typeMap[columnType] || 'S';
+    }
+    mapFromDynamoType(dynamoType) {
+        const typeMap = {
+            'N': 'number',
+            'S': 'string',
+            'B': 'binary',
+            'BOOL': 'boolean',
+            'L': 'list',
+            'M': 'map',
+            'SS': 'stringSet',
+            'NS': 'numberSet',
+            'BS': 'binarySet',
         };
-    }
-    buildUpdateExpression(data) {
-        const names = {};
-        const values = {};
-        const updates = [];
-        Object.entries(data).forEach(([key, value], idx) => {
-            names[`#${key}`] = key;
-            values[`:val${idx}`] = value;
-            updates.push(`#${key} = :val${idx}`);
-        });
-        return {
-            updateExpression: `SET ${updates.join(', ')}`,
-            expressionAttributeNames: names,
-            expressionAttributeValues: values,
-        };
-    }
-    extractKeyFromWhere(where) {
-        // Simple implementation - extract key fields from where clause
-        return where || {};
+        return typeMap[dynamoType] || 'unknown';
     }
     chunkArray(array, size) {
         const chunks = [];
@@ -1554,54 +1452,13 @@ class DynamoDBAdapter extends base_adapter_1.BaseDatabaseAdapter {
         }
         return chunks;
     }
-    mapColumnTypeToDynamoDB(type) {
-        // DynamoDB only supports S (String), N (Number), and B (Binary) for keys
-        switch (type) {
-            case schema_types_1.ColumnType.INTEGER:
-            case schema_types_1.ColumnType.BIGINT:
-            case schema_types_1.ColumnType.SMALLINT:
-            case schema_types_1.ColumnType.DECIMAL:
-            case schema_types_1.ColumnType.NUMERIC:
-            case schema_types_1.ColumnType.FLOAT:
-            case schema_types_1.ColumnType.DOUBLE:
-            case schema_types_1.ColumnType.REAL:
-                return 'N';
-            case schema_types_1.ColumnType.BLOB:
-            case schema_types_1.ColumnType.BINARY:
-                return 'B';
-            default:
-                return 'S';
-        }
-    }
-    mapDynamoDBTypeToColumnType(dynamoType) {
-        switch (dynamoType) {
-            case 'N':
-                return schema_types_1.ColumnType.DECIMAL;
-            case 'B':
-                return schema_types_1.ColumnType.BINARY;
-            default:
-                return schema_types_1.ColumnType.STRING;
-        }
-    }
-    // ==================== Utility Methods ====================
-    escapeIdentifier(identifier) {
-        // DynamoDB doesn't require escaping identifiers
-        return identifier;
-    }
-    escapeValue(value) {
-        if (value === null || value === undefined) {
-            return 'null';
-        }
-        if (typeof value === 'string') {
-            return `"${value.replace(/"/g, '\\"')}"`;
-        }
-        if (typeof value === 'object') {
-            return JSON.stringify(value);
-        }
-        return String(value);
-    }
-    async getDatabaseVersion(connection) {
-        return 'DynamoDB (AWS Managed)';
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
     }
 }
 exports.DynamoDBAdapter = DynamoDBAdapter;