@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -0,0 +1,1608 @@
+"use strict";
+/**
+ * DynamoDB Database Adapter
+ * Implements database operations for Amazon DynamoDB
+ */
+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 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");
+/**
+ * DynamoDB Connection wrapper
+ */
+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 {
+    constructor() {
+        super(...arguments);
+        this.type = database_types_1.DatabaseType.DYNAMODB;
+    }
+    // ==================== Connection Methods ====================
+    async connect(config) {
+        var _a, _b, _c, _d;
+        try {
+            // Dynamic import of AWS SDK v3
+            const { DynamoDBClient } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+            const { DynamoDBDocumentClient } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            const clientConfig = {
+                region: ((_a = config.options) === null || _a === void 0 ? void 0 : _a.region) || 'us-east-1',
+            };
+            // 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,
+                };
+            }
+            // Add endpoint for local development
+            if ((_d = config.options) === null || _d === void 0 ? void 0 : _d.endpoint) {
+                clientConfig.endpoint = config.options.endpoint;
+            }
+            const client = new DynamoDBClient(clientConfig);
+            const docClient = DynamoDBDocumentClient.from(client);
+            return new DynamoDBConnection(`dynamodb-${Date.now()}`, client, docClient);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, `Failed to connect to DynamoDB: ${error.message}`, error);
+        }
+    }
+    async disconnect(connection) {
+        await connection.disconnect();
+    }
+    async testConnection(connection) {
+        const startTime = Date.now();
+        try {
+            const { ListTablesCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+            const client = connection.getRawClient();
+            await client.send(new ListTablesCommand({ Limit: 1 }));
+            return {
+                connected: true,
+                message: 'DynamoDB connection successful',
+                databaseType: 'DynamoDB',
+                responseTime: Date.now() - startTime,
+            };
+        }
+        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.');
+    }
+    // ==================== Query Methods ====================
+    async query(connection, options) {
+        const startTime = Date.now();
+        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));
+            }
+            else {
+                const params = this.buildScanParams(options);
+                result = await docClient.send(new ScanCommand(params));
+            }
+            const executionTime = Date.now() - startTime;
+            return {
+                data: (result.Items || []),
+                count: result.Count || 0,
+                executionTime,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB query failed: ${error.message}`, error);
+        }
+    }
+    async insert(connection, options) {
+        const startTime = Date.now();
+        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({
+                    TableName: options.table,
+                    Item: dataArray[0],
+                }));
+            }
+            else {
+                // Batch insert (max 25 items per batch)
+                const batches = this.chunkArray(dataArray, 25);
+                for (const batch of batches) {
+                    await docClient.send(new BatchWriteCommand({
+                        RequestItems: {
+                            [options.table]: batch.map((item) => ({
+                                PutRequest: { Item: item },
+                            })),
+                        },
+                    }));
+                }
+            }
+            const executionTime = Date.now() - startTime;
+            return {
+                insertedCount: dataArray.length,
+                insertedIds: [], // DynamoDB doesn't auto-generate IDs
+                data: undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB insert failed: ${error.message}`, error);
+        }
+    }
+    async update(connection, options) {
+        const startTime = Date.now();
+        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({
+                TableName: options.table,
+                Key: key,
+                UpdateExpression: updateExpression,
+                ExpressionAttributeNames: expressionAttributeNames,
+                ExpressionAttributeValues: expressionAttributeValues,
+            }));
+            const executionTime = Date.now() - startTime;
+            return {
+                updatedCount: 1, // DynamoDB updates one item at a time
+                matchedCount: 1,
+                data: undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB update failed: ${error.message}`, error);
+        }
+    }
+    async delete(connection, options) {
+        const startTime = Date.now();
+        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({
+                TableName: options.table,
+                Key: key,
+            }));
+            const executionTime = Date.now() - startTime;
+            return {
+                deletedCount: 1,
+                data: undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB delete failed: ${error.message}`, error);
+        }
+    }
+    async upsert(connection, options) {
+        const startTime = Date.now();
+        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({
+                TableName: options.table,
+                Item: data,
+            }));
+            const executionTime = Date.now() - startTime;
+            return {
+                insertedCount: 0, // Can't distinguish in DynamoDB
+                updatedCount: 0,
+                affectedCount: 1,
+                data: undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB upsert failed: ${error.message}`, error);
+        }
+    }
+    async executeRaw(connection, options) {
+        var _a;
+        const startTime = Date.now();
+        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,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB raw query failed: ${error.message}`, error);
+        }
+    }
+    // ==================== Aggregation Methods ====================
+    async count(connection, options) {
+        try {
+            const { ScanCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/lib-dynamodb')));
+            const docClient = connection.getClient();
+            const params = {
+                TableName: options.table,
+                Select: 'COUNT',
+            };
+            if (options.where) {
+                const { filterExpression, expressionAttributeNames, expressionAttributeValues } = this.buildFilterExpression(options.where);
+                params.FilterExpression = filterExpression;
+                params.ExpressionAttributeNames = expressionAttributeNames;
+                params.ExpressionAttributeValues = expressionAttributeValues;
+            }
+            const result = await docClient.send(new ScanCommand(params));
+            return result.Count || 0;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB count failed: ${error.message}`, error);
+        }
+    }
+    async sum(connection, options) {
+        // DynamoDB doesn't support aggregations natively - need to scan and calculate
+        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);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB sum failed: ${error.message}`, error);
+        }
+    }
+    async avg(connection, options) {
+        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;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB avg failed: ${error.message}`, error);
+        }
+    }
+    async min(connection, options) {
+        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]);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB min failed: ${error.message}`, error);
+        }
+    }
+    async max(connection, options) {
+        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]);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB max failed: ${error.message}`, error);
+        }
+    }
+    async groupBy(connection, options) {
+        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,
+            });
+            const groups = new Map();
+            result.data.forEach((item) => {
+                // Create group key
+                const groupKey = options.groupBy.map((col) => item[col]).join('|');
+                if (!groups.has(groupKey)) {
+                    const groupData = {};
+                    options.groupBy.forEach((col) => {
+                        groupData[col] = item[col];
+                    });
+                    groups.set(groupKey, groupData);
+                }
+                // 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];
+                    }
+                });
+            });
+            return results;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB groupBy failed: ${error.message}`, error);
+        }
+    }
+    async aggregate(connection, options) {
+        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;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `DynamoDB aggregate failed: ${error.message}`, error);
+        }
+    }
+    // ==================== Schema Methods ====================
+    async createTable(connection, schema, options) {
+        const startTime = Date.now();
+        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,
+                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,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'create',
+                table: schema.name,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async dropTable(connection, tableName) {
+        const startTime = Date.now();
+        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,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'drop',
+                table: tableName,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    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) {
+        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: 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);
+        }
+    }
+    async listTables(connection) {
+        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 || [];
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.SCHEMA_ERROR, `Failed to list DynamoDB tables: ${error.message}`, error);
+        }
+    }
+    async tableExists(connection, tableName) {
+        try {
+            const { DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
+            const client = connection.getRawClient();
+            await client.send(new DescribeTableCommand({
+                TableName: tableName,
+            }));
+            return true;
+        }
+        catch (error) {
+            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);
+        }
+    }
+    // ==================== Index Methods ====================
+    async createIndex(connection, options) {
+        const startTime = Date.now();
+        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',
+                            },
+                        },
+                    },
+                ],
+            }));
+            return {
+                success: true,
+                operation: 'create',
+                indexName: options.index.name,
+                table: options.table,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'create',
+                indexName: options.index.name,
+                table: options.table,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async dropIndex(connection, options) {
+        const startTime = Date.now();
+        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,
+                GlobalSecondaryIndexUpdates: [
+                    {
+                        Delete: {
+                            IndexName: options.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,
+            };
+        }
+    }
+    async listIndexes(connection, options) {
+        var _a, _b;
+        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;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to list DynamoDB indexes: ${error.message}`, error);
+        }
+    }
+    async getIndexStatistics(connection, tableName, indexName) {
+        var _a;
+        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: 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,
+                        });
+                    }
+                });
+            }
+            return statistics;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to get DynamoDB index statistics: ${error.message}`, error);
+        }
+    }
+    // ==================== Migration Methods ====================
+    /**
+     * Execute a migration operation
+     * Note: DynamoDB is schema-less, so column operations are skipped
+     */
+    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 };
+        }
+    }
+    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);
+                }
+            }
+            // 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,
+            };
+        }
+    }
+    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);
+                }
+            }
+            // 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,
+            };
+        }
+    }
+    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),
+            }));
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.MIGRATION_ERROR, `Failed to get DynamoDB migration history: ${error.message}`, error);
+        }
+    }
+    /**
+     * Ensure migration tracking table exists
+     */
+    async ensureMigrationTable(connection) {
+        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
+            }
+            catch (error) {
+                if (error.name !== 'ResourceNotFoundException') {
+                    throw error;
+                }
+            }
+            // 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(),
+                },
+            }));
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.MIGRATION_ERROR, `Failed to record migration: ${error.message}`, error);
+        }
+    }
+    /**
+     * Remove migration from history
+     */
+    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);
+        }
+    }
+    // ==================== 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;
+        }
+        if (options.limit) {
+            params.Limit = options.limit;
+        }
+        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;
+    }
+    /**
+     * Build DynamoDB key condition expression (for Query operations)
+     * Supports both simplified syntax (GT, LT, etc.) and legacy $ prefix operators
+     */
+    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;
+            }
+            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,
+        };
+    }
+    /**
+     * 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}`);
+                }
+            }
+            return conditions.join(' AND ');
+        };
+        const expression = buildCondition(where);
+        return {
+            filterExpression: expression,
+            expressionAttributeNames: names,
+            expressionAttributeValues: values,
+        };
+    }
+    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 || {};
+    }
+    chunkArray(array, size) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += size) {
+            chunks.push(array.slice(i, i + size));
+        }
+        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)';
+    }
+}
+exports.DynamoDBAdapter = DynamoDBAdapter;
+//# sourceMappingURL=dynamodb.adapter.js.map