@ductape/sdk 0.1.7 → 0.1.8

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

@@ -1,1564 +0,0 @@
-"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 listTablesWithInfo() {
-        this.ensureConnected();
-        try {
-            const { ListTablesCommand, DescribeTableCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-dynamodb')));
-            const response = await this.dynamoClient.send(new ListTablesCommand({}));
-            const tableNames = response.TableNames || [];
-            // Get table info including item count for each table
-            const tablesWithInfo = await Promise.all(tableNames.map(async (tableName) => {
-                var _a;
-                try {
-                    const describeResponse = await this.dynamoClient.send(new DescribeTableCommand({ TableName: tableName }));
-                    return {
-                        name: tableName,
-                        estimatedRowCount: (_a = describeResponse.Table) === null || _a === void 0 ? void 0 : _a.ItemCount,
-                    };
-                }
-                catch (error) {
-                    // If we can't describe a table, return it without count
-                    return {
-                        name: tableName,
-                        estimatedRowCount: undefined,
-                    };
-                }
-            }));
-            return tablesWithInfo;
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.schemaError(`Failed to list tables with info: ${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