@ductape/sdk 0.0.4-v6 → 0.0.4-v61

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

@@ -0,0 +1,1534 @@
+"use strict";
+/**
+ * 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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDBAdapter = void 0;
+const base_adapter_1 = require("./base.adapter");
+const enums_1 = require("../types/enums");
+const database_error_1 = require("../utils/database-error");
+/**
+ * DynamoDB database adapter
+ * Provides DynamoDB-specific implementations for all database operations
+ */
+class DynamoDBAdapter extends base_adapter_1.BaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.databaseType = enums_1.DatabaseType.DYNAMODB;
+        this.dynamoClient = null;
+        this.docClient = null;
+        this.region = '';
+    }
+    // ==================== CONNECTION METHODS ====================
+    async connect(options) {
+        console.log(`[DynamoDBAdapter] connect() called`);
+        console.log(`[DynamoDBAdapter] Options:`, JSON.stringify(Object.assign(Object.assign({}, options), { connectionUrl: '***REDACTED***' }), null, 2));
+        try {
+            console.log(`[DynamoDBAdapter] Importing AWS SDK libraries...`);
+            // 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')));
+            console.log(`[DynamoDBAdapter] AWS SDK libraries imported successfully`);
+            this.connectionUrl = options.connectionUrl;
+            console.log(`[DynamoDBAdapter] Connection URL stored`);
+            // Parse connection URL: dynamodb://region/access-key/secret-key
+            // Or: dynamodb://region (uses default credentials)
+            console.log(`[DynamoDBAdapter] Parsing connection URL...`);
+            const url = new URL(options.connectionUrl);
+            this.region = url.hostname || 'us-east-1';
+            console.log(`[DynamoDBAdapter] Region: ${this.region}`);
+            const clientConfig = {
+                region: this.region,
+            };
+            // 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],
+                    };
+                    console.log(`[DynamoDBAdapter] Credentials found in URL`);
+                }
+            }
+            else {
+                console.log(`[DynamoDBAdapter] Using default credentials from environment`);
+            }
+            // Custom endpoint for local DynamoDB
+            if (url.port) {
+                clientConfig.endpoint = `http://${url.hostname}:${url.port}`;
+                console.log(`[DynamoDBAdapter] Custom endpoint: ${clientConfig.endpoint}`);
+            }
+            console.log(`[DynamoDBAdapter] Creating DynamoDBClient...`);
+            this.dynamoClient = new DynamoDBClient(clientConfig);
+            console.log(`[DynamoDBAdapter] DynamoDBClient created`);
+            console.log(`[DynamoDBAdapter] Creating DynamoDBDocumentClient...`);
+            this.docClient = DynamoDBDocumentClient.from(this.dynamoClient, {
+                marshallOptions: {
+                    removeUndefinedValues: true,
+                    convertEmptyValues: true,
+                },
+            });
+            console.log(`[DynamoDBAdapter] DynamoDBDocumentClient created`);
+            console.log(`[DynamoDBAdapter] Testing connection by listing tables...`);
+            // 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 }));
+            console.log(`[DynamoDBAdapter] Connection test successful`);
+            this.client = this.docClient;
+            this.connected = true;
+            console.log(`[DynamoDBAdapter] Connection marked as connected`);
+            return {
+                connected: true,
+                version: `DynamoDB (${this.region})`,
+            };
+        }
+        catch (error) {
+            console.error(`[DynamoDBAdapter] Connection failed with error:`, error);
+            console.error(`[DynamoDBAdapter] Error type:`, error.constructor.name);
+            console.error(`[DynamoDBAdapter] Error message:`, error.message);
+            console.error(`[DynamoDBAdapter] Error code:`, error.code);
+            console.error(`[DynamoDBAdapter] Full error:`, JSON.stringify(error, null, 2));
+            throw database_error_1.DatabaseError.connectionError(`Failed to connect to DynamoDB: ${error.message}`, error);
+        }
+    }
+    async testConnection(options) {
+        try {
+            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,
+                version: `DynamoDB (${region})`,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                error: error.message,
+            };
+        }
+    }
+    async disconnect() {
+        if (this.dynamoClient) {
+            this.dynamoClient.destroy();
+            this.dynamoClient = null;
+            this.docClient = null;
+            this.client = null;
+            this.connected = false;
+        }
+    }
+    // ==================== QUERY METHODS ====================
+    async query(query) {
+        var _a;
+        this.ensureConnected();
+        try {
+            const { ScanCommand, QueryCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            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 {
+                // 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);
+            }
+            return {
+                data: items,
+                count,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    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 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: 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 write (max 25 items per batch)
+                const batches = this.chunkArray(data, 25);
+                for (const batch of batches) {
+                    await this.docClient.send(new BatchWriteCommand({
+                        RequestItems: {
+                            [options.table]: batch.map(item => ({
+                                PutRequest: { Item: item },
+                            })),
+                        },
+                    }));
+                    batch.forEach(item => insertedIds.push(item.id || item._id));
+                }
+            }
+            return {
+                data: options.returning ? data : [],
+                count: data.length,
+                insertedIds,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    async update(options) {
+        this.ensureConnected();
+        try {
+            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,
+            };
+            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 {
+                data: updatedItems,
+                count: updatedCount,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    async delete(options) {
+        this.ensureConnected();
+        try {
+            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,
+            };
+            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 {
+                count: itemsToDelete.length,
+                data: options.returning ? itemsToDelete : undefined,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    async upsert(options) {
+        this.ensureConnected();
+        try {
+            const { PutCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            // DynamoDB PutCommand is an upsert by default
+            await this.docClient.send(new PutCommand({
+                TableName: options.table,
+                Item: options.data,
+                ReturnValues: 'NONE',
+            }));
+            return {
+                data: [options.data],
+                count: 1,
+                operation: 'inserted', // DynamoDB doesn't distinguish
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    // ==================== AGGREGATION METHODS ====================
+    async count(options) {
+        this.ensureConnected();
+        try {
+            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 database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    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 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 || [];
+            return items.reduce((sum, item) => sum + (Number(item[options.column]) || 0), 0);
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    async avg(options) {
+        this.ensureConnected();
+        try {
+            // 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 database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    async min(options) {
+        this.ensureConnected();
+        try {
+            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 database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    async max(options) {
+        this.ensureConnected();
+        try {
+            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 database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    async aggregate(builtAggregation) {
+        this.ensureConnected();
+        try {
+            // 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 database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    async groupBy(builtGroupBy) {
+        this.ensureConnected();
+        try {
+            // 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();
+            const groupByColumns = options.groupBy || [];
+            for (const item of items) {
+                const groupKey = groupByColumns.map((col) => String(item[col])).join('|');
+                if (!groups.has(groupKey)) {
+                    groups.set(groupKey, []);
+                }
+                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 database_error_1.DatabaseError.fromDatabaseError(error, 'dynamodb');
+        }
+    }
+    // ==================== 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 {
+            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) {
+            context.status = 'error';
+            throw database_error_1.DatabaseError.transactionError(`Failed to commit transaction: ${error.message}`, error);
+        }
+    }
+    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')));
+            // 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 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) {
+            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 alterTable(tableName, operations) {
+        this.ensureConnected();
+        // DynamoDB has very limited ALTER capabilities
+        // Can only modify GSIs and some table settings
+        try {
+            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) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to alter table: ${error.message}`, error);
+        }
+    }
+    async dropTable(tableName, ifExists, cascade) {
+        this.ensureConnected();
+        try {
+            const { DeleteTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+            await this.dynamoClient.send(new DeleteTableCommand({
+                TableName: tableName,
+            }));
+        }
+        catch (error) {
+            if (ifExists && error.name === 'ResourceNotFoundException') {
+                return;
+            }
+            throw database_error_1.DatabaseError.schemaError(`Failed to drop table: ${error.message}`, error);
+        }
+    }
+    async listTables() {
+        this.ensureConnected();
+        try {
+            const { ListTablesCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+            const response = await this.dynamoClient.send(new ListTablesCommand({}));
+            return response.TableNames || [];
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to list tables: ${error.message}`, error);
+        }
+    }
+    async tableExists(tableName) {
+        this.ensureConnected();
+        try {
+            const { DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+            await this.dynamoClient.send(new DescribeTableCommand({
+                TableName: tableName,
+            }));
+            return true;
+        }
+        catch (error) {
+            if (error.name === 'ResourceNotFoundException') {
+                return false;
+            }
+            throw database_error_1.DatabaseError.schemaError(`Failed to check table existence: ${error.message}`, error);
+        }
+    }
+    async getTableSchema(tableName) {
+        var _a;
+        this.ensureConnected();
+        try {
+            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 {
+                name: tableName,
+                columns,
+                indexes,
+                constraints: [],
+                primaryKey,
+                estimatedRowCount: Number(table.ItemCount) || 0,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to get table schema: ${error.message}`, error);
+        }
+    }
+    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')));
+            await this.dynamoClient.send(new UpdateTableCommand({
+                TableName: tableName,
+                GlobalSecondaryIndexUpdates: [
+                    {
+                        Delete: {
+                            IndexName: indexName,
+                        },
+                    },
+                ],
+            }));
+        }
+        catch (error) {
+            if (ifExists && error.name === 'ResourceNotFoundException') {
+                return;
+            }
+            throw database_error_1.DatabaseError.schemaError(`Failed to drop index: ${error.message}`, error);
+        }
+    }
+    async listIndexes(tableName, includeSystem) {
+        this.ensureConnected();
+        try {
+            const schema = await this.getTableSchema(tableName);
+            return schema.indexes;
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to list indexes: ${error.message}`, error);
+        }
+    }
+    async getIndexStatistics(tableName, indexName) {
+        this.ensureConnected();
+        try {
+            const { DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+            const response = await this.dynamoClient.send(new DescribeTableCommand({
+                TableName: tableName,
+            }));
+            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),
+                });
+            }
+            // 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 database_error_1.DatabaseError.schemaError(`Failed to get index statistics: ${error.message}`, error);
+        }
+    }
+    // ==================== UTILITY METHODS ====================
+    escapeIdentifier(identifier) {
+        return identifier;
+    }
+    escapeValue(value) {
+        return JSON.stringify(value);
+    }
+    /**
+     * Check if value is an update operator object
+     * Supports both lowercase (new) and uppercase (legacy) operators
+     */
+    isUpdateOperator(value) {
+        if (!value || typeof value !== 'object')
+            return false;
+        // Support both lowercase (Mongoose style) and uppercase (legacy) operators
+        const operators = [
+            '$inc', '$INC', '$dec', '$DEC', '$mul', '$MUL', '$min', '$MIN', '$max', '$MAX',
+            '$set', '$SET', '$unset', '$UNSET', '$push', '$PUSH', '$pull', '$PULL',
+            '$addToSet', '$ADDTOSET', '$currentDate', '$CURRENTDATE'
+        ];
+        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,
+        };
+    }
+    // ==================== 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)) {
+            // Normalize key to lowercase for logical operators (support both cases for backwards compatibility)
+            const normalizedKey = key.toLowerCase();
+            if (normalizedKey === '$and') {
+                const conditions_list = Array.isArray(value) ? value : Object.entries(value).map(([k, v]) => ({ [k]: v }));
+                const andConditions = [];
+                for (const cond of conditions_list) {
+                    const result = this.buildFilterExpression(cond, names, values);
+                    andConditions.push(result.expression);
+                    Object.assign(names, result.names);
+                    Object.assign(values, result.values);
+                }
+                conditions.push(`(${andConditions.join(' AND ')})`);
+            }
+            else if (normalizedKey === '$or') {
+                const conditions_list = Array.isArray(value) ? value : Object.entries(value).map(([k, v]) => ({ [k]: v }));
+                const orConditions = [];
+                for (const cond of conditions_list) {
+                    const result = this.buildFilterExpression(cond, names, values);
+                    orConditions.push(result.expression);
+                    Object.assign(names, result.names);
+                    Object.assign(values, result.values);
+                }
+                conditions.push(`(${orConditions.join(' OR ')})`);
+            }
+            else if (normalizedKey === '$not') {
+                const result = this.buildFilterExpression(value, names, values);
+                conditions.push(`NOT (${result.expression})`);
+                Object.assign(names, result.names);
+                Object.assign(values, result.values);
+            }
+            else if (normalizedKey === '$nor') {
+                const conditions_list = Array.isArray(value) ? value : [value];
+                const norConditions = [];
+                for (const cond of conditions_list) {
+                    const result = this.buildFilterExpression(cond, names, values);
+                    norConditions.push(result.expression);
+                    Object.assign(names, result.names);
+                    Object.assign(values, result.values);
+                }
+                conditions.push(`NOT (${norConditions.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;
+                    // Normalize operator to lowercase (support both cases for backwards compatibility)
+                    const normalizedOp = op.toLowerCase();
+                    switch (normalizedOp) {
+                        case '$eq':
+                            conditions.push(`${nameKey} = ${valueKey}`);
+                            break;
+                        case '$ne':
+                            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 '$isnull':
+                        case '$is_null':
+                            if (opValue) {
+                                conditions.push(`attribute_not_exists(${nameKey})`);
+                            }
+                            else {
+                                conditions.push(`attribute_exists(${nameKey})`);
+                            }
+                            delete values[valueKey];
+                            break;
+                        case '$isnotnull':
+                        case '$is_not_null':
+                            if (opValue) {
+                                conditions.push(`attribute_exists(${nameKey})`);
+                            }
+                            else {
+                                conditions.push(`attribute_not_exists(${nameKey})`);
+                            }
+                            delete values[valueKey];
+                            break;
+                        case '$exists':
+                            if (opValue) {
+                                conditions.push(`attribute_exists(${nameKey})`);
+                            }
+                            else {
+                                conditions.push(`attribute_not_exists(${nameKey})`);
+                            }
+                            delete values[valueKey];
+                            break;
+                        case '$contains':
+                            conditions.push(`contains(${nameKey}, ${valueKey})`);
+                            break;
+                        case '$begins_with':
+                            conditions.push(`begins_with(${nameKey}, ${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}`);
+            }
+        }
+        return {
+            expression: conditions.join(' AND '),
+            names,
+            values,
+        };
+    }
+    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}`);
+                }
+            }
+            else {
+                const valueKey = `:val${valueIndex++}`;
+                values[valueKey] = value;
+                setClauses.push(`${nameKey} = ${valueKey}`);
+            }
+        }
+        let expression = '';
+        if (setClauses.length > 0) {
+            expression += `SET ${setClauses.join(', ')}`;
+        }
+        if (addClauses.length > 0) {
+            if (expression)
+                expression += ' ';
+            expression += `ADD ${addClauses.join(', ')}`;
+        }
+        return { expression, names, values };
+    }
+    /**
+     * Extract key condition from where clause if partition key is present.
+     * This enables using Query instead of Scan for better performance.
+     */
+    async extractKeyCondition(where, tableName) {
+        var _a, _b, _c;
+        if (!where || Object.keys(where).length === 0) {
+            return { keyCondition: null, filterCondition: null };
+        }
+        try {
+            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 };
+            }
+            // 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})`);
+                    }
+                }
+            }
+            // 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) {
+            // If we can't get table metadata, fall back to Scan
+            return { keyCondition: null, filterCondition: null };
+        }
+    }
+    /**
+     * Get simple value from where clause for a specific field
+     */
+    getWhereValue(where, fieldName) {
+        const value = where[fieldName];
+        if (value === undefined) {
+            return undefined;
+        }
+        // Simple equality check
+        if (typeof value !== 'object' || value === null) {
+            return value;
+        }
+        // Check for $EQ operator
+        if (value.$EQ !== undefined) {
+            return value.$EQ;
+        }
+        return undefined;
+    }
+    /**
+     * Get operator and value from where clause for a specific field
+     */
+    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] };
+            }
+        }
+        return null;
+    }
+    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;
+            }
+            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',
+        };
+        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',
+        };
+        return typeMap[dynamoType] || 'unknown';
+    }
+    chunkArray(array, size) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += size) {
+            chunks.push(array.slice(i, i + size));
+        }
+        return chunks;
+    }
+    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;
+//# sourceMappingURL=dynamodb.adapter.js.map