@ductape/sdk 0.0.4-v5 → 0.0.4-v51

package/dist/database/database.service.js

@@ -0,0 +1,802 @@
+"use strict";
+/**
+ * Main Database Service
+ * Entry point for all database operations
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseService = void 0;
+const database_types_1 = require("./types/database.types");
+const postgresql_adapter_1 = require("./adapters/postgresql.adapter");
+const mongodb_adapter_1 = require("./adapters/mongodb.adapter");
+const mysql_adapter_1 = require("./adapters/mysql.adapter");
+const dynamodb_adapter_1 = require("./adapters/dynamodb.adapter");
+const products_service_1 = __importDefault(require("../products/services/products.service"));
+const index_types_1 = require("../types/index.types");
+const productsBuilder_types_1 = require("../types/productsBuilder.types");
+const logs_service_1 = __importDefault(require("../logs/logs.service"));
+const logs_types_1 = require("../logs/logs.types");
+const uuid_1 = require("uuid");
+/**
+ * Main Database Service Class
+ */
+class DatabaseService {
+    constructor(config) {
+        this.connections = new Map();
+        this.adapters = new Map();
+        this.activeConnection = null;
+        this.config = config;
+        this.environment = config.env_type || index_types_1.EnvType.PRODUCTION;
+        this.initializeAdapters();
+    }
+    /**
+     * Initialize database adapters
+     */
+    initializeAdapters() {
+        // Register PostgreSQL adapter
+        this.adapters.set(database_types_1.DatabaseType.POSTGRESQL, new postgresql_adapter_1.PostgreSQLAdapter());
+        // Register MongoDB adapter
+        this.adapters.set(database_types_1.DatabaseType.MONGODB, new mongodb_adapter_1.MongoDBAdapter());
+        // Register MySQL adapter
+        this.adapters.set(database_types_1.DatabaseType.MYSQL, new mysql_adapter_1.MySQLAdapter());
+        // Register DynamoDB adapter
+        this.adapters.set(database_types_1.DatabaseType.DYNAMODB, new dynamodb_adapter_1.DynamoDBAdapter());
+    }
+    /**
+     * Get adapter for database type
+     */
+    getAdapter(type) {
+        const adapter = this.adapters.get(type);
+        if (!adapter) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, `No adapter registered for database type: ${type}`);
+        }
+        return adapter;
+    }
+    /**
+     * Resolve connection configuration from product database
+     */
+    async resolveProductConnection(config) {
+        var _a;
+        try {
+            // Create ProductBuilder instance
+            const productBuilder = new products_service_1.default({
+                workspace_id: this.config.workspace_id,
+                user_id: this.config.user_id,
+                public_key: this.config.public_key,
+                token: this.config.token,
+                env_type: this.environment,
+            });
+            // Initialize the product by tag
+            await productBuilder.initializeProductByTag(config.product);
+            // Fetch the database configuration
+            const database = await productBuilder.fetchDatabase(config.database);
+            if (!database) {
+                throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, `Database '${config.database}' not found in product '${config.product}'`);
+            }
+            // Find the environment configuration
+            const envConfig = (_a = database.envs) === null || _a === void 0 ? void 0 : _a.find((env) => env.slug === config.env);
+            if (!envConfig) {
+                throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, `Environment '${config.env}' not found for database '${config.database}'`);
+            }
+            if (!envConfig.connection_url) {
+                throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, `No connection URL configured for database '${config.database}' in environment '${config.env}'`);
+            }
+            // Parse the connection URL to create a database config
+            const dbConfig = this.parseConnectionUrl(envConfig.connection_url, database.type, config.env, config.database);
+            // Get the adapter for the database type
+            const adapter = this.getAdapter(dbConfig.type);
+            // Create connection using the parsed config
+            const connectionKey = `${config.product}-${config.database}-${config.env}`;
+            let connection = this.connections.get(connectionKey);
+            if (connection && connection.isConnected()) {
+                return { connection, adapter };
+            }
+            connection = await adapter.connect(dbConfig);
+            this.connections.set(connectionKey, connection);
+            return { connection, adapter };
+        }
+        catch (error) {
+            if (error instanceof database_types_1.DatabaseError) {
+                throw error;
+            }
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, `Failed to resolve product connection: ${error.message}`);
+        }
+    }
+    /**
+     * Parse connection URL into database config
+     */
+    parseConnectionUrl(connectionUrl, dbType, env, databaseName) {
+        try {
+            // Map product database types to DatabaseType enum
+            const typeMapping = {
+                postgresql: database_types_1.DatabaseType.POSTGRESQL,
+                postgres: database_types_1.DatabaseType.POSTGRESQL,
+                mysql: database_types_1.DatabaseType.MYSQL,
+                mongodb: database_types_1.DatabaseType.MONGODB,
+                mongo: database_types_1.DatabaseType.MONGODB,
+                dynamodb: database_types_1.DatabaseType.DYNAMODB,
+            };
+            const mappedType = typeMapping[dbType.toLowerCase()];
+            if (!mappedType) {
+                throw new Error(`Unsupported database type: ${dbType}`);
+            }
+            // Parse the connection URL based on database type
+            if (mappedType === database_types_1.DatabaseType.MONGODB) {
+                // MongoDB connection string format: mongodb://[username:password@]host[:port][/database][?options]
+                return {
+                    type: database_types_1.DatabaseType.MONGODB,
+                    env,
+                    database: databaseName,
+                    options: {
+                        connectionString: connectionUrl,
+                        uri: connectionUrl,
+                    },
+                };
+            }
+            else if (mappedType === database_types_1.DatabaseType.DYNAMODB) {
+                // DynamoDB uses region/credentials rather than connection URL
+                // Connection URL format: dynamodb://region?accessKeyId=xxx&secretAccessKey=xxx
+                const url = new URL(connectionUrl);
+                const region = url.hostname;
+                const accessKeyId = url.searchParams.get('accessKeyId') || undefined;
+                const secretAccessKey = url.searchParams.get('secretAccessKey') || undefined;
+                const sessionToken = url.searchParams.get('sessionToken') || undefined;
+                return {
+                    type: database_types_1.DatabaseType.DYNAMODB,
+                    env,
+                    database: databaseName,
+                    options: {
+                        region,
+                        accessKeyId,
+                        secretAccessKey,
+                        sessionToken,
+                    },
+                };
+            }
+            else {
+                // PostgreSQL/MySQL connection string format: protocol://[user:password@]host[:port]/database[?options]
+                const url = new URL(connectionUrl);
+                const urlOptions = this.parseUrlOptions(url.searchParams);
+                return {
+                    type: mappedType,
+                    env,
+                    database: url.pathname.slice(1) || databaseName,
+                    options: Object.assign({ host: url.hostname, port: url.port ? parseInt(url.port) : mappedType === database_types_1.DatabaseType.POSTGRESQL ? 5432 : 3306, user: url.username || undefined, username: url.username || undefined, password: url.password || undefined }, urlOptions),
+                };
+            }
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, `Failed to parse connection URL: ${error.message}`);
+        }
+    }
+    /**
+     * Parse URL search parameters into options object
+     */
+    parseUrlOptions(params) {
+        const options = {};
+        params.forEach((value, key) => {
+            // Try to parse as number or boolean
+            if (value === 'true') {
+                options[key] = true;
+            }
+            else if (value === 'false') {
+                options[key] = false;
+            }
+            else if (!isNaN(Number(value))) {
+                options[key] = Number(value);
+            }
+            else {
+                options[key] = value;
+            }
+        });
+        return options;
+    }
+    /**
+     * Resolve connection config using active connection context
+     */
+    resolveConnectionConfig(options) {
+        // If all parameters are provided, use them
+        if (options.env && options.product && options.database) {
+            return {
+                env: options.env,
+                product: options.product,
+                database: options.database,
+            };
+        }
+        // If no active connection, throw error
+        if (!this.activeConnection) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, 'No active connection. Call connect() first or provide env, product, and database parameters.');
+        }
+        // Use active connection with any overrides
+        return {
+            env: options.env || this.activeConnection.env,
+            product: options.product || this.activeConnection.product,
+            database: options.database || this.activeConnection.database,
+        };
+    }
+    /**
+     * Get or create a connection
+     */
+    async getConnection(config) {
+        // Check if it's a product-based connection
+        if ('product' in config) {
+            return this.resolveProductConnection(config);
+        }
+        // Direct connection configuration
+        const adapter = this.getAdapter(config.type);
+        const connectionKey = `${config.type}-${config.env}-${config.database}`;
+        // Check if connection already exists
+        let connection = this.connections.get(connectionKey);
+        if (connection && connection.isConnected()) {
+            return { connection, adapter };
+        }
+        // Create new connection
+        connection = await adapter.connect(config);
+        this.connections.set(connectionKey, connection);
+        return { connection, adapter };
+    }
+    // ==================== Connection Methods ====================
+    /**
+     * Connect to a database
+     */
+    async connect(config) {
+        const { connection, adapter } = await this.getConnection(config);
+        // Store the active connection context
+        this.activeConnection = config;
+        return adapter.testConnection(connection);
+    }
+    /**
+     * Disconnect from a database
+     */
+    async disconnect(config) {
+        const connectionKey = `${config.product}-${config.database}-${config.env}`;
+        const connection = this.connections.get(connectionKey);
+        if (connection) {
+            await connection.disconnect();
+            this.connections.delete(connectionKey);
+            // Clear active connection if it matches
+            if (this.activeConnection &&
+                this.activeConnection.product === config.product &&
+                this.activeConnection.database === config.database &&
+                this.activeConnection.env === config.env) {
+                this.activeConnection = null;
+            }
+        }
+    }
+    /**
+     * Test database connection
+     */
+    async testConnection(config) {
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.testConnection(connection);
+    }
+    // ==================== Transaction Methods ====================
+    /**
+     * Begin a new transaction
+     */
+    async beginTransaction(config, options) {
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.beginTransaction(connection, options);
+    }
+    /**
+     * Execute operations within a transaction (callback-based)
+     */
+    async transaction(config, callback) {
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.executeTransaction(connection, callback, config);
+    }
+    // ==================== Query Methods ====================
+    /**
+     * Execute a SELECT query
+     */
+    async query(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.query(connection, options);
+    }
+    /**
+     * Insert records
+     */
+    async insert(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.insert(connection, options);
+    }
+    /**
+     * Update records
+     */
+    async update(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.update(connection, options);
+    }
+    /**
+     * Delete records
+     */
+    async delete(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.delete(connection, options);
+    }
+    /**
+     * Upsert records
+     */
+    async upsert(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.upsert(connection, options);
+    }
+    /**
+     * Execute raw SQL/query
+     */
+    async raw(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.executeRaw(connection, options);
+    }
+    // ==================== Aggregation Methods ====================
+    /**
+     * Count records
+     */
+    async count(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.count(connection, options);
+    }
+    /**
+     * Sum column values
+     */
+    async sum(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.sum(connection, options);
+    }
+    /**
+     * Get average value
+     */
+    async avg(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.avg(connection, options);
+    }
+    /**
+     * Get minimum value
+     */
+    async min(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.min(connection, options);
+    }
+    /**
+     * Get maximum value
+     */
+    async max(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.max(connection, options);
+    }
+    /**
+     * Group by and aggregate
+     */
+    async groupBy(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.groupBy(connection, options);
+    }
+    /**
+     * Multiple aggregations
+     */
+    async aggregate(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.aggregate(connection, options);
+    }
+    // ==================== Schema Methods ====================
+    /**
+     * Create a table
+     */
+    async createTable(config, schema, options) {
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.createTable(connection, schema, options);
+    }
+    /**
+     * Drop a table
+     */
+    async dropTable(config, tableName) {
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.dropTable(connection, tableName);
+    }
+    /**
+     * Alter a table
+     */
+    async alterTable(config, tableName, alterations, options) {
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.alterTable(connection, tableName, alterations, options);
+    }
+    /**
+     * Get table schema
+     */
+    async getTableSchema(config, tableName) {
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.getTableSchema(connection, tableName);
+    }
+    /**
+     * List all tables
+     */
+    async listTables(config) {
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.listTables(connection);
+    }
+    /**
+     * Check if table exists
+     */
+    async tableExists(config, tableName) {
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.tableExists(connection, tableName);
+    }
+    // ==================== Index Methods ====================
+    /**
+     * Create an index
+     */
+    async createIndex(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.createIndex(connection, options);
+    }
+    /**
+     * Drop an index
+     */
+    async dropIndex(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.dropIndex(connection, options);
+    }
+    /**
+     * List indexes
+     */
+    async listIndexes(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.listIndexes(connection, options);
+    }
+    /**
+     * Get index statistics
+     */
+    async getIndexStatistics(config, tableName, indexName) {
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.getIndexStatistics(connection, tableName, indexName);
+    }
+    // ==================== Migration Methods ====================
+    /**
+     * Run migrations
+     */
+    async runMigration(migration, options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.runMigration(connection, migration, options);
+    }
+    /**
+     * Rollback migration
+     */
+    async rollbackMigration(migration, options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.rollbackMigration(connection, migration, options);
+    }
+    /**
+     * Get migration history
+     */
+    async getMigrationHistory(options) {
+        const config = this.resolveConnectionConfig(options);
+        const { connection, adapter } = await this.getConnection(config);
+        return adapter.getMigrationHistory(connection, options);
+    }
+    /**
+     * Get migration status
+     */
+    async getMigrationStatus(options) {
+        // Get migration history from database
+        const history = await this.getMigrationHistory(options);
+        const appliedTags = new Set(history.map((h) => h.tag));
+        // Get defined migrations (from options or empty array)
+        const definedMigrations = options.definedMigrations || [];
+        // Calculate pending migrations
+        const pendingMigrations = definedMigrations
+            .filter((m) => !appliedTags.has(m.tag))
+            .map((m) => ({
+            tag: m.tag,
+            name: m.name,
+            description: m.description,
+            createdAt: m.createdAt || new Date(),
+            dependencies: m.dependencies,
+        }));
+        // Get last applied migration
+        const lastApplied = history.length > 0 ? history[0] : undefined;
+        return {
+            total: definedMigrations.length,
+            completed: history.length,
+            pending: pendingMigrations.length,
+            failed: 0, // Would need to track failed migrations separately
+            lastApplied,
+            pendingMigrations,
+        };
+    }
+    // ==================== Execute Action Methods ====================
+    /**
+     * Execute a database action by tag
+     *
+     * @example
+     * ```typescript
+     * await ductape.database.execute({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   database: 'my-database',
+     *   action: 'get-users',
+     *   input: { limit: 10, offset: 0 }
+     * });
+     * ```
+     */
+    async execute(options) {
+        const { product, env, database, action: actionTag, input = {} } = options;
+        const startTime = Date.now();
+        const processId = (0, uuid_1.v4)();
+        let logService = null;
+        let productTag = product;
+        try {
+            // Create ProductBuilder instance to fetch action
+            const productBuilder = new products_service_1.default({
+                workspace_id: this.config.workspace_id,
+                user_id: this.config.user_id,
+                public_key: this.config.public_key,
+                token: this.config.token,
+                env_type: this.environment,
+                redis_client: this.config.redis_client,
+            });
+            // Initialize the product
+            await productBuilder.initializeProductByTag(product);
+            productTag = product; // The product parameter is already the tag
+            // Initialize LogsService for fire-and-forget logging
+            logService = new logs_service_1.default({
+                workspace_id: this.config.workspace_id,
+                user_id: this.config.user_id,
+                public_key: this.config.public_key,
+                token: this.config.token,
+                product_id: productBuilder.fetchProductId(),
+                env_type: this.environment,
+                app_id: null,
+            });
+            // Fetch the database action
+            const fullActionTag = `${database}:${actionTag}`;
+            const dbAction = await productBuilder.fetchDatabaseAction(fullActionTag);
+            if (!dbAction) {
+                throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `Database action '${fullActionTag}' not found in product '${product}'`);
+            }
+            // Get connection to the database
+            const connectionConfig = {
+                product,
+                env,
+                database,
+            };
+            const { connection, adapter } = await this.getConnection(connectionConfig);
+            // Process the action template with input parameters
+            const processedQuery = this.processActionTemplate(dbAction, input);
+            // Execute based on action type
+            let result;
+            switch (dbAction.type) {
+                // Query operations (READ is legacy alias for QUERY)
+                case productsBuilder_types_1.DatabaseActionTypes.QUERY:
+                case productsBuilder_types_1.DatabaseActionTypes.READ:
+                    result = await adapter.query(connection, Object.assign({ table: dbAction.tableName }, processedQuery)).then(res => res.data);
+                    break;
+                // Insert operations (CREATE is legacy alias for INSERT)
+                case productsBuilder_types_1.DatabaseActionTypes.INSERT:
+                case productsBuilder_types_1.DatabaseActionTypes.CREATE:
+                    result = await adapter.insert(connection, {
+                        table: dbAction.tableName,
+                        data: processedQuery.data || input,
+                        returning: true,
+                    }).then(res => res.data);
+                    break;
+                case productsBuilder_types_1.DatabaseActionTypes.UPDATE:
+                    result = await adapter.update(connection, {
+                        table: dbAction.tableName,
+                        data: processedQuery.data || input,
+                        where: processedQuery.where,
+                        returning: true,
+                    }).then(res => res.data);
+                    break;
+                case productsBuilder_types_1.DatabaseActionTypes.DELETE:
+                    result = await adapter.delete(connection, {
+                        table: dbAction.tableName,
+                        where: processedQuery.where,
+                        returning: true,
+                    }).then(res => res.data);
+                    break;
+                case productsBuilder_types_1.DatabaseActionTypes.UPSERT:
+                    result = await adapter.upsert(connection, {
+                        table: dbAction.tableName,
+                        data: processedQuery.data || input,
+                        uniqueColumns: processedQuery.uniqueColumns || processedQuery.conflictKeys || [],
+                        updateColumns: processedQuery.updateColumns,
+                        returning: true,
+                    }).then(res => res.data);
+                    break;
+                // Aggregation operations
+                case productsBuilder_types_1.DatabaseActionTypes.COUNT:
+                    result = await adapter.count(connection, {
+                        table: dbAction.tableName,
+                        where: processedQuery.where,
+                        column: processedQuery.column,
+                        distinct: processedQuery.distinct,
+                    });
+                    break;
+                case productsBuilder_types_1.DatabaseActionTypes.SUM:
+                    result = await adapter.sum(connection, {
+                        table: dbAction.tableName,
+                        column: processedQuery.column,
+                        where: processedQuery.where,
+                    });
+                    break;
+                case productsBuilder_types_1.DatabaseActionTypes.AVERAGE:
+                    result = await adapter.avg(connection, {
+                        table: dbAction.tableName,
+                        column: processedQuery.column,
+                        where: processedQuery.where,
+                    });
+                    break;
+                case productsBuilder_types_1.DatabaseActionTypes.MINIMUM:
+                    result = await adapter.min(connection, {
+                        table: dbAction.tableName,
+                        column: processedQuery.column,
+                        where: processedQuery.where,
+                    });
+                    break;
+                case productsBuilder_types_1.DatabaseActionTypes.MAXIMUM:
+                    result = await adapter.max(connection, {
+                        table: dbAction.tableName,
+                        column: processedQuery.column,
+                        where: processedQuery.where,
+                    });
+                    break;
+                case productsBuilder_types_1.DatabaseActionTypes.GROUP_BY:
+                    result = await adapter.groupBy(connection, {
+                        table: dbAction.tableName,
+                        groupBy: processedQuery.groupBy || [],
+                        aggregate: processedQuery.aggregate,
+                        where: processedQuery.where,
+                        having: processedQuery.having,
+                        orderBy: processedQuery.orderBy,
+                        limit: processedQuery.limit,
+                        offset: processedQuery.offset,
+                    });
+                    break;
+                case productsBuilder_types_1.DatabaseActionTypes.AGGREGATE:
+                    result = await adapter.aggregate(connection, {
+                        table: dbAction.tableName,
+                        operations: processedQuery.operations || {},
+                        where: processedQuery.where,
+                        groupBy: processedQuery.groupBy,
+                        having: processedQuery.having,
+                    });
+                    break;
+                // Raw SQL query
+                case productsBuilder_types_1.DatabaseActionTypes.RAW_SQL:
+                    result = await adapter.executeRaw(connection, {
+                        query: processedQuery.query || processedQuery.raw,
+                        params: processedQuery.params,
+                        namedParams: processedQuery.namedParams,
+                    }).then(res => res.rows);
+                    break;
+                default:
+                    throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `Unsupported action type: ${dbAction.type}`);
+            }
+            // Fire-and-forget success logging
+            if (logService) {
+                logService.add({
+                    process_id: processId,
+                    product_tag: productTag,
+                    env,
+                    type: logs_types_1.LogEventTypes.DB_ACTION,
+                    action: fullActionTag,
+                    status: logs_types_1.LogEventStatus.SUCCESS,
+                    start: startTime,
+                    end: Date.now(),
+                    data: { action: actionTag, database, actionType: dbAction.type },
+                });
+                logService.publish().catch(() => { }); // Silent fail - don't affect main request
+            }
+            return result;
+        }
+        catch (error) {
+            // Fire-and-forget failure logging
+            if (logService) {
+                logService.add({
+                    process_id: processId,
+                    product_tag: productTag,
+                    env,
+                    type: logs_types_1.LogEventTypes.DB_ACTION,
+                    action: `${database}:${actionTag}`,
+                    status: logs_types_1.LogEventStatus.FAIL,
+                    start: startTime,
+                    end: Date.now(),
+                    data: { action: actionTag, database, error: error.message },
+                });
+                logService.publish().catch(() => { }); // Silent fail - don't affect main request
+            }
+            if (error instanceof database_types_1.DatabaseError) {
+                throw error;
+            }
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `Failed to execute database action: ${error.message}`);
+        }
+    }
+    /**
+     * Process action template with input parameters
+     */
+    processActionTemplate(action, input) {
+        let template = action.template;
+        // If template is a string, parse it as JSON
+        if (typeof template === 'string') {
+            try {
+                template = JSON.parse(template);
+            }
+            catch (_a) {
+                // If it's not valid JSON, return it as a raw query
+                return { raw: this.replaceTemplateParams(template, input) };
+            }
+        }
+        // Deep clone to avoid mutation
+        const processed = JSON.parse(JSON.stringify(template));
+        // Replace parameters in the template
+        return this.replaceParamsInObject(processed, input);
+    }
+    /**
+     * Replace template parameters with actual values
+     */
+    replaceTemplateParams(template, params) {
+        let result = template;
+        for (const [key, value] of Object.entries(params)) {
+            const placeholder = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+            result = result.replace(placeholder, typeof value === 'string' ? value : JSON.stringify(value));
+        }
+        return result;
+    }
+    /**
+     * Recursively replace parameters in an object
+     */
+    replaceParamsInObject(obj, params) {
+        if (typeof obj === 'string') {
+            // Check if it's a parameter placeholder
+            const match = obj.match(/^\{\{(\w+)\}\}$/);
+            if (match) {
+                const paramName = match[1];
+                return params[paramName] !== undefined ? params[paramName] : obj;
+            }
+            // Replace inline parameters
+            return this.replaceTemplateParams(obj, params);
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(item => this.replaceParamsInObject(item, params));
+        }
+        if (obj && typeof obj === 'object') {
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                result[key] = this.replaceParamsInObject(value, params);
+            }
+            return result;
+        }
+        return obj;
+    }
+    // ==================== Utility Methods ====================
+    /**
+     * Close all connections
+     */
+    async closeAll() {
+        const closePromises = Array.from(this.connections.values()).map((connection) => connection.disconnect());
+        await Promise.all(closePromises);
+        this.connections.clear();
+    }
+}
+exports.DatabaseService = DatabaseService;
+//# sourceMappingURL=database.service.js.map