@ductape/sdk 0.0.4-v51 → 0.0.4-v52

package/dist/database/database.service.js

@@ -1,802 +0,0 @@
-"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