@ductape/sdk 0.0.4-v6 → 0.0.4-v60

package/dist/database/databases.service.js

@@ -0,0 +1,2821 @@
+"use strict";
+/**
+ * DatabaseService - Main ORM Service Class
+ *
+ * This is the primary entry point for all database operations in the Ductape SDK.
+ * It provides a unified interface for querying, writing, transactions, schema management,
+ * migrations, and database actions across multiple database types.
+ *
+ * Supported databases: PostgreSQL, MySQL, MongoDB, DynamoDB, MariaDB, Cassandra
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.databaseService = exports.DatabaseConnection = exports.DatabaseService = void 0;
+const enums_1 = require("./types/enums");
+const presave_processor_1 = require("./presave/presave-processor");
+const adapter_factory_1 = require("./adapters/adapter.factory");
+const query_builder_1 = require("./operators/query-builder");
+const aggregation_builder_1 = require("./operators/aggregation-builder");
+const transaction_manager_1 = require("./transactions/transaction-manager");
+const schema_manager_1 = require("./schema/schema-manager");
+const migration_engine_1 = require("./migrations/migration-engine");
+const action_manager_1 = require("./actions/action-manager");
+const trigger_processor_1 = require("./triggers/trigger-processor");
+const trigger_interface_1 = require("./types/trigger.interface");
+const database_error_1 = require("./utils/database-error");
+const products_service_1 = __importDefault(require("../products/services/products.service"));
+const types_1 = require("../types");
+const cache_manager_1 = require("../cache/cache.manager");
+const processor_service_1 = __importDefault(require("../processor/services/processor.service"));
+const crypto_1 = require("crypto");
+const logs_service_1 = __importDefault(require("../logs/logs.service"));
+const logs_types_1 = require("../logs/logs.types");
+const processor_utils_1 = require("../processor/utils/processor.utils");
+const secrets_1 = require("../secrets");
+/**
+ * Main Database Service class
+ * Provides unified ORM interface for all supported databases
+ */
+class DatabaseService {
+    /**
+     * Create a new DatabaseService instance
+     * @param config - Optional configuration for authentication and workspace context
+     */
+    constructor(config) {
+        this.adapters = new Map();
+        this.connectionContexts = new Map();
+        this.currentContext = null;
+        this.schemaManagers = new Map();
+        this.migrationEngines = new Map();
+        /** Service configuration */
+        this.config = null;
+        /** ProductBuilder instances cache (keyed by product tag) */
+        this.productBuilders = new Map();
+        /** LogService instance for logging operations */
+        this.logService = null;
+        /** Current product ID for logging */
+        this.productId = '';
+        /** CacheManager for two-tier caching (Redis + remote) */
+        this.cacheManager = null;
+        /** Private keys cache for products (keyed by product tag) */
+        this.privateKeys = new Map();
+        this.config = config || null;
+        this.adapterFactory = new adapter_factory_1.AdapterFactory();
+        this.transactionManager = new transaction_manager_1.TransactionManager();
+        this.actionManager = new action_manager_1.ActionManager(this);
+        this._privateKey = (config === null || config === void 0 ? void 0 : config.private_key) || '';
+        // Initialize CacheManager if Redis client is provided
+        if (config === null || config === void 0 ? void 0 : config.redis_client) {
+            this.cacheManager = new cache_manager_1.CacheManager({
+                workspace_id: config.workspace_id,
+                public_key: config.public_key,
+                user_id: config.user_id,
+                token: config.token,
+                env_type: config.env_type,
+                redis_client: config.redis_client,
+            });
+        }
+    }
+    /**
+     * Get or create a SchemaManager for the given adapter key or current context
+     */
+    getSchemaManager(adapterKey) {
+        // If no key provided, use current context
+        if (!adapterKey) {
+            if (!this.currentContext) {
+                throw new database_error_1.DatabaseError('No active database connection. Please connect first.', enums_1.DatabaseErrorType.CONNECTION_ERROR);
+            }
+            adapterKey = this.buildContextKey(this.currentContext.database, this.currentContext.env);
+        }
+        let manager = this.schemaManagers.get(adapterKey);
+        if (!manager) {
+            const adapter = this.adapters.get(adapterKey);
+            if (!adapter) {
+                throw new database_error_1.DatabaseError(`No adapter found for key: ${adapterKey}`, enums_1.DatabaseErrorType.NOT_FOUND);
+            }
+            manager = new schema_manager_1.SchemaManager(adapter);
+            this.schemaManagers.set(adapterKey, manager);
+        }
+        return manager;
+    }
+    /**
+     * Get or create a MigrationEngine for the given adapter key or current context
+     */
+    getMigrationEngine(adapterKey) {
+        // If no key provided, use current context
+        if (!adapterKey) {
+            if (!this.currentContext) {
+                throw new database_error_1.DatabaseError('No active database connection. Please connect first.', enums_1.DatabaseErrorType.CONNECTION_ERROR);
+            }
+            adapterKey = this.buildContextKey(this.currentContext.database, this.currentContext.env);
+        }
+        let engine = this.migrationEngines.get(adapterKey);
+        if (!engine) {
+            const adapter = this.adapters.get(adapterKey);
+            if (!adapter) {
+                throw new database_error_1.DatabaseError(`No adapter found for key: ${adapterKey}`, enums_1.DatabaseErrorType.NOT_FOUND);
+            }
+            engine = new migration_engine_1.MigrationEngine(adapter);
+            this.migrationEngines.set(adapterKey, engine);
+        }
+        return engine;
+    }
+    // ==================== PRODUCT BUILDER MANAGEMENT ====================
+    /**
+     * Create a new ProductBuilder instance
+     */
+    createNewProductBuilder() {
+        if (!this.config) {
+            throw new database_error_1.DatabaseError('DatabaseService not configured. Please provide config when initializing.', enums_1.DatabaseErrorType.CONFIGURATION_ERROR);
+        }
+        return new products_service_1.default({
+            workspace_id: this.config.workspace_id,
+            public_key: this.config.public_key,
+            user_id: this.config.user_id,
+            token: this.config.token,
+            env_type: this.config.env_type,
+            access_key: this.config.access_key,
+        });
+    }
+    /**
+     * Get or create a ProductBuilder instance for the given product tag
+     */
+    async getProductBuilder(productTag) {
+        let builder = this.productBuilders.get(productTag);
+        if (!builder) {
+            builder = this.createNewProductBuilder();
+            await builder.initializeProductByTag(productTag);
+            this.productBuilders.set(productTag, builder);
+            // Update productId for logging
+            this.productId = builder.fetchProductId() || '';
+            // Cache private key for caching operations
+            const privateKey = builder.fetchPrivateKey();
+            if (privateKey) {
+                this.privateKeys.set(productTag, privateKey);
+            }
+        }
+        return builder;
+    }
+    /**
+     * Initialize logging service
+     */
+    initializeLogService() {
+        if (!this.logService && this.config) {
+            this.logService = new logs_service_1.default({
+                product_id: this.productId,
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+            });
+        }
+    }
+    /**
+     * Create a new ProcessorService instance for job scheduling
+     */
+    createNewProcessor() {
+        if (!this.config) {
+            throw new database_error_1.DatabaseError('DatabaseService not configured. Please provide config when initializing.', enums_1.DatabaseErrorType.CONFIGURATION_ERROR);
+        }
+        return new processor_service_1.default({
+            workspace_id: this.config.workspace_id,
+            public_key: this.config.public_key,
+            user_id: this.config.user_id,
+            token: this.config.token,
+            env_type: this.config.env_type,
+            private_key: this._privateKey,
+        });
+    }
+    // ==================== DATABASE CRUD OPERATIONS ====================
+    /**
+     * Register a new database configuration for a product
+     * @param productTag - The product tag
+     * @param data - The database configuration data
+     */
+    async registerDatabase(productTag, data) {
+        const builder = await this.getProductBuilder(productTag);
+        return builder.createDatabase(data);
+    }
+    /**
+     * Fetch all databases for a product
+     * @param productTag - The product tag
+     * @returns Array of database configurations
+     */
+    async fetchAllDatabases(productTag) {
+        const builder = await this.getProductBuilder(productTag);
+        return builder.fetchDatabases();
+    }
+    /**
+     * Fetch a specific database by tag
+     * @param productTag - The product tag
+     * @param databaseTag - The database tag
+     * @returns The database configuration or null if not found
+     */
+    async fetchDatabase(productTag, databaseTag) {
+        const builder = await this.getProductBuilder(productTag);
+        return builder.fetchDatabase(databaseTag);
+    }
+    /**
+     * Update a database configuration
+     * @param productTag - The product tag
+     * @param databaseTag - The database tag
+     * @param data - The data to update
+     */
+    async updateDatabase(productTag, databaseTag, data) {
+        const builder = await this.getProductBuilder(productTag);
+        // Process connection URLs in envs if provided
+        if (data.envs && data.envs.length > 0) {
+            const secretsService = (0, secrets_1.getSecretsService)();
+            const processedEnvs = [];
+            for (const env of data.envs) {
+                let connectionUrl = env.connection_url;
+                const secretCheck = (0, secrets_1.isSecretReference)(connectionUrl);
+                // If not already a secret reference and we have a secrets service, store it as a secret
+                if (!secretCheck.isSecret && secretsService) {
+                    const secretKey = this.generateDbSecretKey(productTag, databaseTag, env.slug);
+                    try {
+                        const exists = await secretsService.exists(secretKey);
+                        if (exists) {
+                            await secretsService.update(secretKey, { value: connectionUrl });
+                            console.log(`[Secrets] Updated existing secret '${secretKey}' for database '${databaseTag}' in environment '${env.slug}'`);
+                        }
+                        else {
+                            await secretsService.create({
+                                key: secretKey,
+                                value: connectionUrl,
+                                description: `Database connection URL for ${databaseTag} in ${env.slug}`,
+                                scope: [productTag, databaseTag],
+                                envs: [env.slug],
+                            });
+                            console.log(`[Secrets] Created new secret '${secretKey}' for database '${databaseTag}' in environment '${env.slug}'`);
+                        }
+                        // Update the connection URL to use the secret reference
+                        connectionUrl = `$Secret{${secretKey}}`;
+                        console.log(`[Secrets] Connection URL converted to secret reference: $Secret{${secretKey}}`);
+                    }
+                    catch (error) {
+                        console.warn(`[Secrets] Failed to store database connection URL as secret: ${error}`);
+                        // Continue with the original connection URL
+                    }
+                }
+                processedEnvs.push(Object.assign(Object.assign({}, env), { connection_url: connectionUrl }));
+            }
+            data = Object.assign(Object.assign({}, data), { envs: processedEnvs });
+        }
+        return builder.updateDatabase(databaseTag, data);
+    }
+    // ==================== DATABASE TRIGGER OPERATIONS ====================
+    /**
+     * Create a database trigger
+     * @param productTag - The product tag
+     * @param data - The trigger configuration
+     */
+    async createTrigger(productTag, data) {
+        const builder = await this.getProductBuilder(productTag);
+        return builder.createDatabaseTrigger(data);
+    }
+    /**
+     * Update a database trigger
+     * @param productTag - The product tag
+     * @param data - The trigger configuration
+     */
+    async updateTrigger(productTag, data) {
+        const builder = await this.getProductBuilder(productTag);
+        return builder.updateDatabaseTrigger(data);
+    }
+    /**
+     * Fetch a database trigger
+     * @param productTag - The product tag
+     * @param tag - The trigger tag (format: database_tag:trigger_tag)
+     */
+    async fetchTrigger(productTag, tag) {
+        const builder = await this.getProductBuilder(productTag);
+        return builder.fetchDatabaseTrigger(tag);
+    }
+    /**
+     * Fetch all triggers for a database
+     * @param productTag - The product tag
+     * @param databaseTag - The database tag
+     */
+    async fetchTriggers(productTag, databaseTag) {
+        const builder = await this.getProductBuilder(productTag);
+        return builder.fetchDatabaseTriggers(databaseTag);
+    }
+    /**
+     * Delete a database trigger
+     * @param productTag - The product tag
+     * @param tag - The trigger tag (format: database_tag:trigger_tag)
+     */
+    async deleteTrigger(productTag, tag) {
+        const builder = await this.getProductBuilder(productTag);
+        return builder.deleteDatabaseTrigger(tag);
+    }
+    /**
+     * Get the current service configuration
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Update the service configuration (used after auth is complete)
+     */
+    updateConfig(config) {
+        if (this.config) {
+            this.config = Object.assign(Object.assign({}, this.config), config);
+        }
+        else {
+            this.config = config;
+        }
+    }
+    /**
+     * Get workspace ID from config
+     */
+    getWorkspaceId() {
+        var _a;
+        return ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || null;
+    }
+    /**
+     * Get user ID from config
+     */
+    getUserId() {
+        var _a;
+        return ((_a = this.config) === null || _a === void 0 ? void 0 : _a.user_id) || null;
+    }
+    /**
+     * Get authentication token from config
+     */
+    getToken() {
+        var _a;
+        return ((_a = this.config) === null || _a === void 0 ? void 0 : _a.token) || null;
+    }
+    /**
+     * Get environment type from config
+     */
+    getEnvType() {
+        var _a;
+        return ((_a = this.config) === null || _a === void 0 ? void 0 : _a.env_type) || null;
+    }
+    // ==================== CONNECTION MANAGEMENT ====================
+    /**
+     * Create/register a new database configuration
+     *
+     * @example
+     * // Persist to product
+     * await ductape.database.create({
+     *   product: 'my-product',
+     *   name: 'User Database',
+     *   tag: 'users-db',
+     *   type: 'postgresql',
+     *   description: 'Stores user accounts and profiles',
+     *   envs: [
+     *     { slug: 'dev', connection_url: 'postgresql://localhost:5432/myapp_dev' },
+     *     { slug: 'prd', connection_url: 'postgresql://prod-host:5432/myapp_prod' },
+     *   ],
+     * });
+     *
+     * // Local only (not persisted)
+     * await ductape.database.create({
+     *   name: 'Temp Database',
+     *   tag: 'temp-db',
+     *   type: 'postgresql',
+     *   envs: [{ slug: 'dev', connection_url: 'postgresql://localhost:5432/temp' }],
+     * });
+     */
+    async create(config) {
+        var _a;
+        // Validate required fields
+        if (!config.name || !config.tag || !config.type || !((_a = config.envs) === null || _a === void 0 ? void 0 : _a.length)) {
+            throw new database_error_1.DatabaseError('Missing required fields: name, tag, type, and envs are required', enums_1.DatabaseErrorType.VALIDATION_ERROR);
+        }
+        const exists = await this.fetchDatabase(config.product, config.tag);
+        console.log(`[DatabaseService] Creating database config: ${config.product} : ${config.tag} (exists: ${!!exists})`);
+        if (exists) {
+            return;
+        }
+        // Validate database type
+        if (!Object.values(enums_1.DatabaseType).includes(config.type)) {
+            throw new database_error_1.DatabaseError(`Unsupported database type: ${config.type}. Supported types: ${Object.values(enums_1.DatabaseType).join(', ')}`, enums_1.DatabaseErrorType.VALIDATION_ERROR);
+        }
+        // Process connection URLs - store as secrets if not already secret references
+        const secretsService = (0, secrets_1.getSecretsService)();
+        const processedEnvs = [];
+        for (const env of config.envs) {
+            let connectionUrl = env.connection_url;
+            const secretCheck = (0, secrets_1.isSecretReference)(connectionUrl);
+            // If not already a secret reference and we have a secrets service, store it as a secret
+            if (!secretCheck.isSecret && secretsService && config.product) {
+                const secretKey = this.generateDbSecretKey(config.product, config.tag, env.slug);
+                try {
+                    const exists = await secretsService.exists(secretKey);
+                    if (exists) {
+                        await secretsService.update(secretKey, { value: connectionUrl });
+                        console.log(`[Secrets] Updated existing secret '${secretKey}' for database '${config.tag}' in environment '${env.slug}'`);
+                    }
+                    else {
+                        await secretsService.create({
+                            key: secretKey,
+                            value: connectionUrl,
+                            description: `Database connection URL for ${config.tag} in ${env.slug}`,
+                            scope: [config.product, config.tag],
+                            envs: [env.slug],
+                        });
+                        console.log(`[Secrets] Created new secret '${secretKey}' for database '${config.tag}' in environment '${env.slug}'`);
+                    }
+                    // Update the connection URL to use the secret reference
+                    connectionUrl = `$Secret{${secretKey}}`;
+                    console.log(`[Secrets] Connection URL converted to secret reference: $Secret{${secretKey}}`);
+                }
+                catch (error) {
+                    console.log(error);
+                    console.warn(`[Secrets] Failed to store database connection URL as secret: ${secretKey} : ${error}`);
+                    // Continue with the original connection URL
+                }
+            }
+            processedEnvs.push(Object.assign(Object.assign({}, env), { connection_url: connectionUrl }));
+        }
+        // Persist to ProductBuilder if product is specified
+        if (config.product) {
+            const productBuilder = await this.getProductBuilder(config.product);
+            await productBuilder.createDatabase({
+                name: config.name,
+                tag: config.tag,
+                type: config.type, // DatabaseType maps to DatabaseTypes enum
+                description: config.description,
+                envs: processedEnvs.map(env => ({
+                    slug: env.slug,
+                    connection_url: env.connection_url,
+                    description: env.description,
+                })),
+            });
+        }
+        // Store the configuration locally - prepare the adapter for each environment
+        for (const envConfig of processedEnvs) {
+            const contextKey = this.buildContextKey(config.tag, envConfig.slug);
+            const adapter = this.adapterFactory.create(config.type);
+            this.adapters.set(contextKey, adapter);
+            this.connectionContexts.set(contextKey, {
+                database: config.tag,
+                env: envConfig.slug,
+                type: config.type,
+                connectionUrl: envConfig.connection_url,
+                connected: false,
+                name: config.name,
+                description: config.description,
+            });
+        }
+    }
+    /**
+     * Generate a secret key for database connection URLs
+     * Format: DB_{PRODUCT}_{ASSET_TAG}_{ENV}_{KEY}
+     *
+     * Where:
+     * - PRODUCT = productTag.split('.')[1] (second part after workspace)
+     * - ASSET_TAG = if dbTag starts with same workspace prefix, use second part; otherwise sanitize full tag
+     * - All parts are automatically capitalized
+     */
+    generateDbSecretKey(product, dbTag, env) {
+        const sanitize = (str) => str.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+        // Support both ':' and '.' delimiters for product tags (e.g., 'ductape:rematch' or 'ductape.rematch')
+        const productParts = product.includes(':') ? product.split(':') : product.split('.');
+        const productKey = productParts[1] || productParts[0]; // Use product name (index 1), fallback to index 0
+        const workspace = productParts[0];
+        // Support both ':' and '.' delimiters for database tags
+        const dbParts = dbTag.includes(':') ? dbTag.split(':') : dbTag.split('.');
+        let assetTag;
+        if (dbParts.length > 1 && dbParts[0] === workspace) {
+            // Same workspace prefix, use second part
+            assetTag = dbParts[1];
+        }
+        else {
+            // Different or no prefix, use full tag
+            assetTag = dbTag;
+        }
+        return `DB_${sanitize(productKey)}_${sanitize(assetTag)}_${sanitize(env)}_URL`;
+    }
+    /**
+     * Connect to a database
+     *
+     * @example
+     * const result = await ductape.database.connect({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   database: 'users-db',
+     * });
+     * console.log('Connected:', result.connected);
+     * console.log('Database Version:', result.version);
+     * console.log('Latency:', result.latency, 'ms');
+     *
+     * // With the returned connection object, you can use scoped operations:
+     * const db = await ductape.databases.connect({ env: 'dev', product: 'my-app', database: 'users-db' });
+     * await db.triggers.create({ tag: 'my-trigger', ... });
+     */
+    async connect(config) {
+        var _a, _b, _c, _d, _e, _f;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        const contextKey = this.buildContextKey(config.database, config.env);
+        console.log(`[DatabaseService] Starting connection process...`);
+        console.log(`[DatabaseService] Config:`, JSON.stringify(config, null, 2));
+        console.log(`[DatabaseService] Context key: ${contextKey}`);
+        let adapter = this.adapters.get(contextKey);
+        let context = this.connectionContexts.get(contextKey);
+        console.log(`[DatabaseService] Adapter exists: ${!!adapter}`);
+        console.log(`[DatabaseService] Context exists: ${!!context}`);
+        // If not found locally, fetch from the remote API
+        if (!adapter || !context) {
+            console.log(`[DatabaseService] Adapter or context not found locally, fetching from remote...`);
+            if (!config.product) {
+                throw new database_error_1.DatabaseError(`Database '${config.database}' not found locally. Please provide 'product' to fetch from remote.`, enums_1.DatabaseErrorType.NOT_FOUND);
+            }
+            console.log(`[DatabaseService] Initializing product builder for: ${config.product}`);
+            // Initialize product builder to get productId for logging
+            await this.getProductBuilder(config.product);
+            console.log(`[DatabaseService] Fetching database config from API...`);
+            // Fetch the database config from the API
+            const dbConfig = await this.fetchDatabase(config.product, config.database);
+            console.log(`[DatabaseService] Database config received:`, JSON.stringify(dbConfig, null, 2));
+            if (!dbConfig) {
+                throw new database_error_1.DatabaseError(`Database '${config.database}' not found for product '${config.product}'.`, enums_1.DatabaseErrorType.NOT_FOUND);
+            }
+            console.log(`[DatabaseService] Looking for environment: ${config.env}`);
+            console.log(`[DatabaseService] Available environments:`, dbConfig.envs.map(e => e.slug).join(', '));
+            // Find the environment connection URL
+            const envConfig = dbConfig.envs.find((e) => e.slug === config.env);
+            if (!envConfig) {
+                throw new database_error_1.DatabaseError(`Environment '${config.env}' not found for database '${config.database}'. Available environments: ${dbConfig.envs.map(e => e.slug).join(', ')}`, enums_1.DatabaseErrorType.NOT_FOUND);
+            }
+            console.log(`[DatabaseService] Environment config found:`, JSON.stringify(envConfig, null, 2));
+            // Create and store the adapter and context
+            const databaseType = this.convertDatabaseType(dbConfig.type);
+            console.log(`[DatabaseService] Database type: ${dbConfig.type} -> ${databaseType}`);
+            console.log(`[DatabaseService] Creating adapter...`);
+            adapter = this.adapterFactory.create(databaseType);
+            console.log(`[DatabaseService] Adapter created successfully`);
+            // Resolve secret references in connection URL
+            let connectionUrl = envConfig.connection_url;
+            console.log(`[DatabaseService] Raw connection URL: ${connectionUrl}`);
+            const secretCheck = (0, secrets_1.isSecretReference)(connectionUrl);
+            console.log(`[DatabaseService] Is secret reference: ${secretCheck.isSecret}`);
+            if (secretCheck.isSecret) {
+                console.log(`[DatabaseService] Resolving secret reference...`);
+                const secretsService = (0, secrets_1.getSecretsService)();
+                if (secretsService) {
+                    const resolved = await secretsService.resolve(connectionUrl, { env: config.env });
+                    connectionUrl = resolved.value;
+                    console.log(`[DatabaseService] Secret resolved successfully`);
+                    console.log(`[DatabaseService] Resolved connection URL: ${connectionUrl}`);
+                }
+                else {
+                    throw new database_error_1.DatabaseError(`Connection URL contains secret reference '${connectionUrl}' but secrets service is not initialized. ` +
+                        `Please ensure the Ductape client is properly initialized.`, enums_1.DatabaseErrorType.CONNECTION_ERROR);
+                }
+            }
+            console.log(`[DatabaseService] Creating database config: ${config.product}:${config.database} : ${dbConfig.name} (exists: ${!!context})`);
+            context = {
+                database: config.database,
+                env: config.env,
+                type: databaseType,
+                connectionUrl,
+                connected: false,
+                name: dbConfig.name,
+                description: dbConfig.description,
+            };
+            console.log(`[DatabaseService] Context created:`, JSON.stringify(Object.assign(Object.assign({}, context), { connectionUrl: '***REDACTED***' }), null, 2));
+            this.adapters.set(contextKey, adapter);
+            this.connectionContexts.set(contextKey, context);
+            console.log(`[DatabaseService] Adapter and context stored with key: ${contextKey}`);
+        }
+        // Initialize logging
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: config.product || '',
+            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            env: config.env,
+            process_id,
+            type: logs_types_1.LogEventTypes.DATABASE,
+            parent_tag: config.database,
+            data: { database: config.database, env: config.env },
+        };
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database connect - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        console.log(`[DatabaseService] Calling adapter.connect() with connectionUrl...`);
+        console.log(`[DatabaseService] Connection URL length: ${context.connectionUrl.length}`);
+        console.log(`[DatabaseService] Connection URL preview: ${context.connectionUrl.substring(0, 20)}...`);
+        try {
+            console.log(`[DatabaseService] Invoking adapter.connect()...`);
+            await adapter.connect({
+                connectionUrl: context.connectionUrl,
+            });
+            console.log(`[DatabaseService] adapter.connect() completed successfully`);
+            context.connected = true;
+            context.product = config.product;
+            this.currentContext = context;
+            console.log(`[DatabaseService] Connection established and context updated`);
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database connect - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+            // Return a DatabaseConnection object for scoped operations
+            return new DatabaseConnection(this, config.database, config.env, config.product || '');
+        }
+        catch (error) {
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database connect - failed', failed_execution: true, data: { database: config.database, env: config.env, error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            throw new database_error_1.DatabaseError(`Failed to connect to database: ${error.message}`, enums_1.DatabaseErrorType.CONNECTION_ERROR, error);
+        }
+    }
+    /**
+     * Test database connection without establishing persistent connection
+     *
+     * @example
+     * const result = await ductape.database.testConnection({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   database: 'users-db',
+     * });
+     * if (result.connected) {
+     *   console.log('Connection successful!');
+     * } else {
+     *   console.error('Connection failed:', result.error);
+     * }
+     */
+    async testConnection(config) {
+        const contextKey = this.buildContextKey(config.database, config.env);
+        let adapter = this.adapters.get(contextKey);
+        let context = this.connectionContexts.get(contextKey);
+        if (!adapter || !context) {
+            return {
+                connected: false,
+                error: `Database '${config.database}' not found for environment '${config.env}'`,
+            };
+        }
+        const startTime = Date.now();
+        try {
+            const result = await adapter.testConnection({
+                connectionUrl: context.connectionUrl,
+            });
+            return {
+                connected: result.connected,
+                version: result.version,
+                latency: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                error: error.message,
+                latency: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * Disconnect from the current database
+     */
+    async disconnect() {
+        if (this.currentContext) {
+            const contextKey = this.buildContextKey(this.currentContext.database, this.currentContext.env);
+            const adapter = this.adapters.get(contextKey);
+            if (adapter) {
+                await adapter.disconnect();
+                this.currentContext.connected = false;
+            }
+            this.currentContext = null;
+        }
+    }
+    /**
+     * Close all database connections
+     *
+     * @example
+     * await ductape.database.closeAll();
+     */
+    async closeAll() {
+        const disconnectPromises = [];
+        for (const [key, adapter] of this.adapters) {
+            disconnectPromises.push(adapter.disconnect());
+            const context = this.connectionContexts.get(key);
+            if (context) {
+                context.connected = false;
+            }
+        }
+        await Promise.all(disconnectPromises);
+        this.currentContext = null;
+    }
+    /**
+     * Fetch all registered databases
+     *
+     * @example
+     * const databases = await ductape.database.fetchAll();
+     * databases.forEach((db) => {
+     *   console.log(`${db.name} (${db.tag}): ${db.type}`);
+     * });
+     */
+    async fetchAll(product) {
+        const databases = new Map();
+        for (const [key, context] of this.connectionContexts) {
+            if (!databases.has(context.database)) {
+                databases.set(context.database, {
+                    product,
+                    name: context.name || context.database,
+                    tag: context.database,
+                    type: context.type,
+                    description: context.description,
+                    envs: [],
+                });
+            }
+            databases.get(context.database).envs.push({
+                slug: context.env,
+                connection_url: context.connectionUrl,
+            });
+        }
+        return Array.from(databases.values());
+    }
+    /**
+     * Fetch a specific database configuration
+     *
+     * @example
+     * const usersDb = await ductape.database.fetch('users-db');
+     * console.log('Database:', usersDb.name);
+     * console.log('Type:', usersDb.type);
+     * console.log('Environments:', usersDb.envs);
+     */
+    async fetch(product, database) {
+        const databases = await this.fetchAll(product);
+        return databases.find((db) => db.tag === database) || null;
+    }
+    /**
+     * Update a local database configuration
+     *
+     * @example
+     * await ductape.database.updateLocalConfig('users-db', {
+     *   name: 'User Database v2',
+     *   description: 'Updated user storage',
+     *   envs: [
+     *     { slug: 'dev', connection_url: 'postgresql://new-dev-host:5432/myapp' },
+     *   ],
+     * });
+     */
+    async updateLocalConfig(tag, updates) {
+        for (const [key, context] of this.connectionContexts) {
+            if (context.database === tag) {
+                if (updates.name) {
+                    context.name = updates.name;
+                }
+                if (updates.description) {
+                    context.description = updates.description;
+                }
+                if (updates.envs) {
+                    const envUpdate = updates.envs.find((e) => e.slug === context.env);
+                    if (envUpdate) {
+                        context.connectionUrl = envUpdate.connection_url;
+                    }
+                }
+            }
+        }
+    }
+    // ==================== QUERY OPERATIONS ====================
+    /**
+     * Query records from a table
+     *
+     * @example
+     * // With established connection
+     * const result = await ductape.database.query({
+     *   table: 'users',
+     *   where: { status: 'active' },
+     *   orderBy: { column: 'created_at', order: 'DESC' },
+     *   limit: 10,
+     * });
+     *
+     * // With explicit connection params
+     * const result = await ductape.database.query({
+     *   env: 'prd',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     *   table: 'users',
+     * });
+     */
+    async query(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        this.initializeLogService();
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedOptions = options;
+        // Process session if provided
+        if (options.session && options.product) {
+            const builder = await this.getProductBuilder(options.product);
+            const privateKey = builder.fetchPrivateKey();
+            if (privateKey) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+                const sessionResult = await processSessionForExecution(options.session, privateKey, options, options.env);
+                if (sessionResult.error) {
+                    throw new Error(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedOptions = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
+        }
+        const baseLogs = Object.assign({ product_tag: options.product || '', workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '', env: options.env || '', process_id, type: logs_types_1.LogEventTypes.DATABASE, parent_tag: options.database || '', data: { table: options.table, operation: 'query' } }, sessionLogFields);
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database query - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            // Check cache if cache tag is provided
+            const privateKey = options.product ? this.privateKeys.get(options.product) : undefined;
+            if (options.cache && this.cacheManager && privateKey) {
+                const cacheOptions = {
+                    cache_tag: options.cache,
+                    product_tag: options.product || '',
+                    component_tag: options.database || '',
+                    component_type: 'database',
+                    input: { table: options.table, where: options.where, select: options.select, orderBy: options.orderBy, limit: options.limit, offset: options.offset },
+                    privateKey,
+                };
+                const cached = await this.cacheManager.fetch(cacheOptions);
+                if (cached.hit && cached.data) {
+                    (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: `Database query - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+                    (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+                    return cached.data;
+                }
+            }
+            const adapter = this.getAdapter(resolvedOptions);
+            const queryBuilder = new query_builder_1.QueryBuilder(adapter.getDatabaseType());
+            const builtQuery = queryBuilder.buildQuery(resolvedOptions);
+            const result = await adapter.query(builtQuery);
+            // Store in cache if cache tag is provided
+            if (options.cache && this.cacheManager && privateKey) {
+                const cacheOptions = {
+                    cache_tag: options.cache,
+                    product_tag: options.product || '',
+                    component_tag: options.database || '',
+                    component_type: 'database',
+                    input: { table: options.table, where: options.where, select: options.select, orderBy: options.orderBy, limit: options.limit, offset: options.offset },
+                    privateKey,
+                };
+                await this.cacheManager.store(cacheOptions, result);
+            }
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database query - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish();
+            return result;
+        }
+        catch (error) {
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database query - failed', failed_execution: true, data: { table: options.table, operation: 'query', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_h = this.logService) === null || _h === void 0 ? void 0 : _h.publish());
+            throw error;
+        }
+    }
+    /**
+     * Execute a raw query
+     *
+     * @example
+     * // PostgreSQL
+     * const result = await ductape.database.raw({
+     *   query: 'SELECT * FROM users WHERE created_at > $1 AND status = $2',
+     *   params: [new Date('2024-01-01'), 'active'],
+     * });
+     *
+     * // MySQL
+     * const result = await ductape.database.raw({
+     *   query: 'SELECT * FROM users WHERE created_at > ? AND status = ?',
+     *   params: [new Date('2024-01-01'), 'active'],
+     * });
+     *
+     * // MongoDB
+     * const result = await ductape.database.raw({
+     *   query: { status: 'active', created_at: { $gte: new Date('2024-01-01') } },
+     *   collection: 'users',
+     * });
+     */
+    async raw(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: options.product || '',
+            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            env: options.env || '',
+            process_id,
+            type: logs_types_1.LogEventTypes.DATABASE,
+            parent_tag: options.database || '',
+            data: { operation: 'raw' },
+        };
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database raw query - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            // Check cache if cache tag is provided
+            const privateKey = options.product ? this.privateKeys.get(options.product) : undefined;
+            if (options.cache && this.cacheManager && privateKey) {
+                const cacheOptions = {
+                    cache_tag: options.cache,
+                    product_tag: options.product || '',
+                    component_tag: options.database || '',
+                    component_type: 'database',
+                    input: { query: options.query, params: options.params, collection: options.collection },
+                    privateKey,
+                };
+                const cached = await this.cacheManager.fetch(cacheOptions);
+                if (cached.hit && cached.data) {
+                    (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: `Database raw query - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+                    (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+                    return cached.data;
+                }
+            }
+            const adapter = this.getAdapter(options);
+            const result = await adapter.raw(options);
+            // Store in cache if cache tag is provided
+            if (options.cache && this.cacheManager && privateKey) {
+                const cacheOptions = {
+                    cache_tag: options.cache,
+                    product_tag: options.product || '',
+                    component_tag: options.database || '',
+                    component_type: 'database',
+                    input: { query: options.query, params: options.params, collection: options.collection },
+                    privateKey,
+                };
+                await this.cacheManager.store(cacheOptions, result);
+            }
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database raw query - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish();
+            return result;
+        }
+        catch (error) {
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database raw query - failed', failed_execution: true, data: { operation: 'raw', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_h = this.logService) === null || _h === void 0 ? void 0 : _h.publish());
+            throw error;
+        }
+    }
+    // ==================== WRITE OPERATIONS ====================
+    /**
+     * Insert one or more records
+     *
+     * @example
+     * // Single record
+     * const result = await ductape.database.insert({
+     *   table: 'users',
+     *   data: {
+     *     name: 'Jane Doe',
+     *     email: 'jane@example.com',
+     *     status: 'active',
+     *   },
+     *   returning: true,
+     * });
+     *
+     * // Multiple records
+     * const result = await ductape.database.insert({
+     *   table: 'users',
+     *   data: [
+     *     { name: 'User 1', email: 'user1@example.com' },
+     *     { name: 'User 2', email: 'user2@example.com' },
+     *   ],
+     * });
+     *
+     * // With conflict handling (upsert)
+     * const result = await ductape.database.insert({
+     *   table: 'users',
+     *   data: { email: 'john@example.com', name: 'John' },
+     *   onConflict: {
+     *     columns: ['email'],
+     *     action: 'update',
+     *     update: ['name'],
+     *   },
+     * });
+     */
+    async insert(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        this.initializeLogService();
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedOptions = options;
+        // Process session if provided
+        if (options.session && options.product) {
+            const builder = await this.getProductBuilder(options.product);
+            const privateKey = builder.fetchPrivateKey();
+            if (privateKey) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+                const sessionResult = await processSessionForExecution(options.session, privateKey, options, options.env);
+                if (sessionResult.error) {
+                    throw new Error(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedOptions = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
+        }
+        const baseLogs = Object.assign({ product_tag: options.product || '', workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '', env: options.env || '', process_id, type: logs_types_1.LogEventTypes.DATABASE, parent_tag: options.database || '', data: { table: options.table, operation: 'insert' } }, sessionLogFields);
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database insert - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            // Apply pre-save operations if specified
+            let processedData = resolvedOptions.data;
+            if (resolvedOptions.preSave && resolvedOptions.preSave.length > 0) {
+                const processor = new presave_processor_1.PreSaveProcessor(resolvedOptions.preSaveConfig);
+                const preSaveResult = await processor.process(resolvedOptions.data, resolvedOptions.preSave);
+                processedData = preSaveResult.data;
+            }
+            const adapter = this.getAdapter(resolvedOptions);
+            const result = await adapter.insert(Object.assign(Object.assign({}, resolvedOptions), { data: processedData }));
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database insert - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+            return result;
+        }
+        catch (error) {
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database insert - failed', failed_execution: true, data: { table: options.table, operation: 'insert', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            throw error;
+        }
+    }
+    /**
+     * Update records matching conditions
+     *
+     * @example
+     * // Simple update
+     * const result = await ductape.database.update({
+     *   table: 'users',
+     *   data: { status: 'inactive' },
+     *   where: { last_login: { $LT: new Date('2023-01-01') } },
+     * });
+     *
+     * // With increment/decrement
+     * await ductape.database.update({
+     *   table: 'products',
+     *   data: { stock: { $inc: 10 } },
+     *   where: { id: productId },
+     * });
+     */
+    async update(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        this.initializeLogService();
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedOptions = options;
+        // Process session if provided
+        if (options.session && options.product) {
+            const builder = await this.getProductBuilder(options.product);
+            const privateKey = builder.fetchPrivateKey();
+            if (privateKey) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+                const sessionResult = await processSessionForExecution(options.session, privateKey, options, options.env);
+                if (sessionResult.error) {
+                    throw new Error(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedOptions = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
+        }
+        const baseLogs = Object.assign({ product_tag: options.product || '', workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '', env: options.env || '', process_id, type: logs_types_1.LogEventTypes.DATABASE, parent_tag: options.database || '', data: { table: options.table, operation: 'update' } }, sessionLogFields);
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database update - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            // Apply pre-save operations if specified
+            let processedData = resolvedOptions.data;
+            if (resolvedOptions.preSave && resolvedOptions.preSave.length > 0) {
+                const processor = new presave_processor_1.PreSaveProcessor(resolvedOptions.preSaveConfig);
+                const preSaveResult = await processor.process(resolvedOptions.data, resolvedOptions.preSave);
+                processedData = preSaveResult.data;
+            }
+            const adapter = this.getAdapter(resolvedOptions);
+            const result = await adapter.update(Object.assign(Object.assign({}, resolvedOptions), { data: processedData }));
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database update - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+            return result;
+        }
+        catch (error) {
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database update - failed', failed_execution: true, data: { table: options.table, operation: 'update', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            throw error;
+        }
+    }
+    /**
+     * Delete records matching conditions
+     *
+     * @example
+     * const result = await ductape.database.delete({
+     *   table: 'users',
+     *   where: { status: 'deleted' },
+     * });
+     * console.log('Deleted count:', result.count);
+     */
+    async delete(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        this.initializeLogService();
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedOptions = options;
+        // Process session if provided
+        if (options.session && options.product) {
+            const builder = await this.getProductBuilder(options.product);
+            const privateKey = builder.fetchPrivateKey();
+            if (privateKey) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+                const sessionResult = await processSessionForExecution(options.session, privateKey, options, options.env);
+                if (sessionResult.error) {
+                    throw new Error(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedOptions = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
+        }
+        const baseLogs = Object.assign({ product_tag: options.product || '', workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '', env: options.env || '', process_id, type: logs_types_1.LogEventTypes.DATABASE, parent_tag: options.database || '', data: { table: options.table, operation: 'delete' } }, sessionLogFields);
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database delete - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const adapter = this.getAdapter(resolvedOptions);
+            const result = await adapter.delete(resolvedOptions);
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database delete - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+            return result;
+        }
+        catch (error) {
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database delete - failed', failed_execution: true, data: { table: options.table, operation: 'delete', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            throw error;
+        }
+    }
+    /**
+     * Insert or update a record based on conflict keys
+     *
+     * @example
+     * const result = await ductape.database.upsert({
+     *   table: 'user_preferences',
+     *   data: {
+     *     user_id: 123,
+     *     theme: 'dark',
+     *     language: 'en',
+     *   },
+     *   conflictKeys: ['user_id'],
+     * });
+     * console.log('Operation:', result.operation); // 'inserted' or 'updated'
+     */
+    async upsert(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        this.initializeLogService();
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedOptions = options;
+        // Process session if provided
+        if (options.session && options.product) {
+            const builder = await this.getProductBuilder(options.product);
+            const privateKey = builder.fetchPrivateKey();
+            if (privateKey) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+                const sessionResult = await processSessionForExecution(options.session, privateKey, options, options.env);
+                if (sessionResult.error) {
+                    throw new Error(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedOptions = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
+        }
+        const baseLogs = Object.assign({ product_tag: options.product || '', workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '', env: options.env || '', process_id, type: logs_types_1.LogEventTypes.DATABASE, parent_tag: options.database || '', data: { table: options.table, operation: 'upsert' } }, sessionLogFields);
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database upsert - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const adapter = this.getAdapter(resolvedOptions);
+            const result = await adapter.upsert(resolvedOptions);
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database upsert - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+            return result;
+        }
+        catch (error) {
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database upsert - failed', failed_execution: true, data: { table: options.table, operation: 'upsert', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            throw error;
+        }
+    }
+    // ==================== AGGREGATION OPERATIONS ====================
+    /**
+     * Count records
+     *
+     * @example
+     * const count = await ductape.database.count({
+     *   table: 'users',
+     *   where: { status: 'active' },
+     * });
+     */
+    async count(options) {
+        const adapter = this.getAdapter(options);
+        return adapter.count(options);
+    }
+    /**
+     * Sum values of a column
+     *
+     * @example
+     * const totalRevenue = await ductape.database.sum({
+     *   table: 'orders',
+     *   column: 'total',
+     *   where: { status: 'completed' },
+     * });
+     */
+    async sum(options) {
+        const adapter = this.getAdapter(options);
+        return adapter.sum(options);
+    }
+    /**
+     * Calculate average of a column
+     *
+     * @example
+     * const avgOrderValue = await ductape.database.avg({
+     *   table: 'orders',
+     *   column: 'total',
+     * });
+     */
+    async avg(options) {
+        const adapter = this.getAdapter(options);
+        return adapter.avg(options);
+    }
+    /**
+     * Get minimum value of a column
+     *
+     * @example
+     * const minPrice = await ductape.database.min({
+     *   table: 'products',
+     *   column: 'price',
+     * });
+     */
+    async min(options) {
+        const adapter = this.getAdapter(options);
+        return adapter.min(options);
+    }
+    /**
+     * Get maximum value of a column
+     *
+     * @example
+     * const maxPrice = await ductape.database.max({
+     *   table: 'products',
+     *   column: 'price',
+     * });
+     */
+    async max(options) {
+        const adapter = this.getAdapter(options);
+        return adapter.max(options);
+    }
+    /**
+     * Perform multiple aggregations in one query
+     *
+     * @example
+     * const stats = await ductape.database.aggregate({
+     *   table: 'orders',
+     *   operations: {
+     *     total_revenue: { $SUM: 'total' },
+     *     order_count: { $COUNT: '*' },
+     *     avg_order_value: { $AVG: 'total' },
+     *   },
+     *   where: { status: 'completed' },
+     * });
+     */
+    async aggregate(options) {
+        const adapter = this.getAdapter(options);
+        const aggregationBuilder = new aggregation_builder_1.AggregationBuilder(adapter.getDatabaseType());
+        const builtAggregation = aggregationBuilder.buildAggregation(options);
+        return adapter.aggregate(builtAggregation);
+    }
+    /**
+     * Group records and perform aggregations
+     *
+     * @example
+     * const salesByCategory = await ductape.database.groupBy({
+     *   table: 'products',
+     *   groupBy: ['category'],
+     *   operations: {
+     *     total_sales: { $SUM: 'sales_count' },
+     *     avg_price: { $AVG: 'price' },
+     *   },
+     *   having: {
+     *     total_sales: { $GT: 100 },
+     *   },
+     * });
+     */
+    async groupBy(options) {
+        const adapter = this.getAdapter(options);
+        const aggregationBuilder = new aggregation_builder_1.AggregationBuilder(adapter.getDatabaseType());
+        const builtGroupBy = aggregationBuilder.buildGroupBy(options);
+        return adapter.groupBy(builtGroupBy);
+    }
+    // ==================== TRANSACTION OPERATIONS ====================
+    /**
+     * Execute operations within a transaction (callback API - recommended)
+     *
+     * @example
+     * const order = await ductape.database.transaction({
+     *   env: 'prd',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     * }, async (transaction) => {
+     *   const order = await ductape.database.insert({
+     *     table: 'orders',
+     *     data: { customer_id: 123, total: 99.99 },
+     *     transaction,
+     *   });
+     *
+     *   await ductape.database.insert({
+     *     table: 'order_items',
+     *     data: items.map(item => ({ order_id: order.insertedIds[0], ...item })),
+     *     transaction,
+     *   });
+     *
+     *   return order;
+     * });
+     */
+    async transaction(options, callback) {
+        const adapter = this.getAdapter(options);
+        return this.transactionManager.executeTransaction(adapter, options, callback);
+    }
+    /**
+     * Begin a transaction manually
+     *
+     * @example
+     * const transaction = await ductape.database.beginTransaction({
+     *   env: 'prd',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     *   isolationLevel: 'REPEATABLE_READ',
+     * });
+     *
+     * try {
+     *   await ductape.database.insert({ table: 'accounts', data: {...}, transaction });
+     *   await transaction.commit();
+     * } catch (error) {
+     *   await transaction.rollback();
+     *   throw error;
+     * }
+     */
+    async beginTransaction(options) {
+        const adapter = this.getAdapter(options);
+        return this.transactionManager.beginTransaction(adapter, options);
+    }
+    // ==================== SCHEMA OPERATIONS ====================
+    /**
+     * Create a new table
+     *
+     * @example
+     * import { SchemaHelpers } from '@ductape/sdk';
+     *
+     * await ductape.database.createTable(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   {
+     *     name: 'products',
+     *     columns: [
+     *       SchemaHelpers.id(),
+     *       SchemaHelpers.string('name', 255, false),
+     *       SchemaHelpers.decimal('price', 10, 2),
+     *       ...SchemaHelpers.timestamps(),
+     *     ],
+     *   },
+     *   { ifNotExists: true }
+     * );
+     */
+    async createTable(connectionConfigOrDefinition, tableDefinitionOrOptions, options) {
+        // Check if first arg is a table definition (no connectionConfig provided)
+        if ('columns' in connectionConfigOrDefinition || 'name' in connectionConfigOrDefinition && !('env' in connectionConfigOrDefinition)) {
+            // Using current context - connectionConfigOrDefinition is actually tableDefinition
+            const adapter = this.getAdapter();
+            return adapter.createTable(connectionConfigOrDefinition, tableDefinitionOrOptions);
+        }
+        // Using explicit connection config
+        const adapter = this.getAdapter(connectionConfigOrDefinition);
+        return adapter.createTable(tableDefinitionOrOptions, options);
+    }
+    /**
+     * Alter an existing table
+     *
+     * @example
+     * import { ColumnAlterationType, ColumnType } from '@ductape/sdk';
+     *
+     * // Add column
+     * await ductape.database.alterTable(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   'products',
+     *   [{ type: ColumnAlterationType.ADD, column: { name: 'sku', type: ColumnType.STRING, length: 50 } }]
+     * );
+     *
+     * // Drop column
+     * await ductape.database.alterTable(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   'products',
+     *   [{ type: ColumnAlterationType.DROP, columnName: 'old_field' }]
+     * );
+     *
+     * // Rename column
+     * await ductape.database.alterTable(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   'products',
+     *   [{ type: ColumnAlterationType.RENAME, oldName: 'old_name', newName: 'new_name' }]
+     * );
+     */
+    async alterTable(connectionConfigOrTableName, tableNameOrAlterations, alterations) {
+        // Check if first arg is a string (tableName - no connectionConfig provided)
+        if (typeof connectionConfigOrTableName === 'string') {
+            const adapter = this.getAdapter();
+            return adapter.alterTable(connectionConfigOrTableName, tableNameOrAlterations);
+        }
+        // Using explicit connection config
+        const adapter = this.getAdapter(connectionConfigOrTableName);
+        return adapter.alterTable(tableNameOrAlterations, alterations);
+    }
+    /**
+     * Drop a table
+     *
+     * @example
+     * await ductape.database.dropTable(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   'old_table'
+     * );
+     */
+    async dropTable(connectionConfigOrTableName, tableName) {
+        // Check if first arg is a string (tableName - no connectionConfig provided)
+        if (typeof connectionConfigOrTableName === 'string') {
+            const adapter = this.getAdapter();
+            return adapter.dropTable(connectionConfigOrTableName, true);
+        }
+        // Using explicit connection config
+        const adapter = this.getAdapter(connectionConfigOrTableName);
+        return adapter.dropTable(tableName, true);
+    }
+    /**
+     * List all tables in the database
+     *
+     * @example
+     * const tables = await ductape.database.listTables({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     * });
+     */
+    async listTables(connectionConfig) {
+        const adapter = this.getAdapter(connectionConfig);
+        return adapter.listTables();
+    }
+    /**
+     * Check if a table exists
+     *
+     * @example
+     * const exists = await ductape.database.tableExists(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   'users'
+     * );
+     */
+    async tableExists(connectionConfigOrTableName, tableName) {
+        // Check if first arg is a string (tableName - no connectionConfig provided)
+        if (typeof connectionConfigOrTableName === 'string') {
+            const adapter = this.getAdapter();
+            return adapter.tableExists(connectionConfigOrTableName);
+        }
+        // Using explicit connection config
+        const adapter = this.getAdapter(connectionConfigOrTableName);
+        return adapter.tableExists(tableName);
+    }
+    /**
+     * Get the schema of a table
+     *
+     * @example
+     * const schema = await ductape.database.getTableSchema(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   'users'
+     * );
+     * console.log('Table:', schema.name);
+     * console.log('Columns:', schema.columns);
+     * console.log('Indexes:', schema.indexes);
+     */
+    async getTableSchema(connectionConfigOrTableName, tableName) {
+        // Check if first arg is a string (tableName - no connectionConfig provided)
+        if (typeof connectionConfigOrTableName === 'string') {
+            const adapter = this.getAdapter();
+            return adapter.getTableSchema(connectionConfigOrTableName);
+        }
+        // Using explicit connection config
+        const adapter = this.getAdapter(connectionConfigOrTableName);
+        return adapter.getTableSchema(tableName);
+    }
+    /**
+     * Create an index
+     *
+     * @example
+     * await ductape.database.createIndex({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     *   table: 'users',
+     *   index: {
+     *     name: 'idx_users_email',
+     *     table: 'users',
+     *     columns: [{ name: 'email' }],
+     *     unique: true,
+     *   },
+     *   ifNotExists: true,
+     *   concurrent: true, // PostgreSQL: create without locking
+     * });
+     */
+    async createIndex(options) {
+        const adapter = this.getAdapter(options);
+        return adapter.createIndex(options.index, options.ifNotExists, options.concurrent);
+    }
+    /**
+     * Drop an index
+     *
+     * @example
+     * await ductape.database.dropIndex({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     *   table: 'users',
+     *   indexName: 'idx_users_old',
+     *   ifExists: true,
+     *   concurrent: true,
+     * });
+     */
+    async dropIndex(options) {
+        const adapter = this.getAdapter(options);
+        return adapter.dropIndex(options.table, options.indexName, options.ifExists, options.concurrent, options.cascade);
+    }
+    /**
+     * List all indexes on a table
+     *
+     * @example
+     * const indexes = await ductape.database.listIndexes({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     *   table: 'users',
+     *   includeSystem: false,
+     * });
+     */
+    async listIndexes(options) {
+        const adapter = this.getAdapter(options);
+        return adapter.listIndexes(options.table, options.includeSystem);
+    }
+    /**
+     * Get index statistics
+     *
+     * @example
+     * // All indexes on a table
+     * const stats = await ductape.database.getIndexStatistics(
+     *   { env: 'prd', product: 'my-app', database: 'main-db' },
+     *   'users'
+     * );
+     *
+     * // Specific index
+     * const emailStats = await ductape.database.getIndexStatistics(
+     *   { env: 'prd', product: 'my-app', database: 'main-db' },
+     *   'users',
+     *   'idx_users_email'
+     * );
+     */
+    async getIndexStatistics(connectionConfig, tableName, indexName) {
+        const adapter = this.getAdapter(connectionConfig);
+        return adapter.getIndexStatistics(tableName, indexName);
+    }
+    // ==================== MIGRATION OPERATIONS ====================
+    /**
+     * Run a migration
+     *
+     * @example
+     * const result = await ductape.database.runMigration([migration]);
+     * console.log('Migrated:', result.size);
+     */
+    async runMigration(migrations, options) {
+        const engine = this.getMigrationEngine();
+        return engine.migrate(migrations, options);
+    }
+    /**
+     * Rollback migrations
+     *
+     * @example
+     * const result = await ductape.database.rollbackMigration([migration], 1);
+     * console.log('Rolled back:', result.size);
+     */
+    async rollbackMigration(migrations, count = 1) {
+        const engine = this.getMigrationEngine();
+        return engine.rollback(migrations, count);
+    }
+    /**
+     * Get migration history (applied migrations)
+     *
+     * @example
+     * const history = await ductape.database.getMigrationHistory();
+     * history.forEach((entry) => {
+     *   console.log('Tag:', entry.tag);
+     *   console.log('Applied at:', entry.appliedAt);
+     * });
+     */
+    async getMigrationHistory() {
+        const engine = this.getMigrationEngine();
+        return engine.getAppliedMigrations();
+    }
+    /**
+     * Get status of all migrations
+     *
+     * @example
+     * const status = await ductape.database.getMigrationStatus(allMigrations);
+     * console.log('Pending:', status.pending);
+     */
+    async getMigrationStatus(migrations) {
+        const engine = this.getMigrationEngine();
+        return engine.getStatus(migrations);
+    }
+    // ==================== MIGRATION CRUD OPERATIONS ====================
+    /**
+     * Migration management sub-object
+     * Provides CRUD operations for database migrations via ProductBuilder
+     */
+    get migration() {
+        return {
+            /**
+             * Create a new database migration
+             *
+             * @example
+             * await ductape.database.migration.create({
+             *   product: 'my-product',
+             *   database: 'main-db',
+             *   data: {
+             *     name: 'Add users table',
+             *     tag: 'main-db:add-users-table',
+             *     value: {
+             *       up: ['CREATE TABLE users (id SERIAL PRIMARY KEY, email VARCHAR(255))'],
+             *       down: ['DROP TABLE users'],
+             *     },
+             *   },
+             * });
+             */
+            create: async (options) => {
+                const builder = await this.getProductBuilder(options.product);
+                // Format tag as database:migration if not already formatted
+                const tag = options.data.tag.includes(':')
+                    ? options.data.tag
+                    : `${options.database}:${options.data.tag}`;
+                await builder.createDatabaseMigration({
+                    name: options.data.name,
+                    tag,
+                    description: options.data.description,
+                    value: options.data.value,
+                });
+            },
+            /**
+             * Update an existing database migration
+             *
+             * @example
+             * await ductape.database.migration.update({
+             *   product: 'my-product',
+             *   tag: 'main-db:add-users-table',
+             *   data: {
+             *     description: 'Updated description',
+             *   },
+             * });
+             */
+            update: async (options) => {
+                const builder = await this.getProductBuilder(options.product);
+                await builder.updateDatabaseMigration(Object.assign({ tag: options.tag }, options.data));
+            },
+            /**
+             * Fetch a specific database migration
+             *
+             * @example
+             * const migration = await ductape.database.migration.fetch({
+             *   product: 'my-product',
+             *   tag: 'main-db:add-users-table',
+             * });
+             */
+            fetch: async (options) => {
+                const builder = await this.getProductBuilder(options.product);
+                return builder.fetchDatabaseMigration(options.tag);
+            },
+            /**
+             * Fetch all database migrations for a database
+             *
+             * @example
+             * const migrations = await ductape.database.migration.fetchAll({
+             *   product: 'my-product',
+             *   database: 'main-db',
+             * });
+             */
+            fetchAll: async (options) => {
+                const builder = await this.getProductBuilder(options.product);
+                return builder.fetchDatabaseMigrations(options.database);
+            },
+            /**
+             * Delete a database migration
+             *
+             * @example
+             * await ductape.database.migration.delete({
+             *   product: 'my-product',
+             *   tag: 'main-db:add-users-table',
+             * });
+             */
+            delete: async (options) => {
+                const builder = await this.getProductBuilder(options.product);
+                return builder.deleteDatabaseMigration(options.tag);
+            },
+            /**
+             * Run a database migration (up)
+             * @deprecated Migration execution has been deprecated
+             */
+            run: async (_options) => {
+                throw new Error('Migration execution has been deprecated');
+            },
+            /**
+             * Rollback a database migration (down)
+             * @deprecated Migration execution has been deprecated
+             */
+            rollback: async (_options) => {
+                throw new Error('Migration execution has been deprecated');
+            },
+        };
+    }
+    // ==================== ACTION OPERATIONS ====================
+    /**
+     * Action management sub-object
+     */
+    get action() {
+        return {
+            /**
+             * Create a new database action
+             *
+             * @example
+             * await ductape.database.action.create({
+             *   name: 'Get Users Paginated',
+             *   tag: 'postgresdb:get-users-paginated',
+             *   tableName: 'users',
+             *   operation: DatabaseActionTypes.QUERY,
+             *   template: {
+             *     where: { is_active: true },
+             *     limit: '{{limit}}',
+             *     offset: '{{offset}}',
+             *   },
+             * });
+             */
+            create: async (options) => {
+                return this.actionManager.create(options);
+            },
+            /**
+             * Update an existing action
+             *
+             * @example
+             * await ductape.database.action.update({
+             *   tag: 'postgresdb:get-users',
+             *   template: { where: { status: '{{status}}' } },
+             * });
+             */
+            update: async (options) => {
+                return this.actionManager.update(options);
+            },
+            /**
+             * Fetch a specific action
+             *
+             * @example
+             * const action = await ductape.database.action.fetch('postgresdb:get-users');
+             */
+            fetch: async (tag) => {
+                return this.actionManager.fetch(tag);
+            },
+            /**
+             * Fetch all actions for a database
+             *
+             * @example
+             * const actions = await ductape.database.action.fetchAll('postgresdb');
+             */
+            fetchAll: async (databaseTag) => {
+                return this.actionManager.fetchAll(databaseTag);
+            },
+            /**
+             * Delete a database action
+             *
+             * @example
+             * await ductape.database.action.delete('postgresdb:get-users');
+             */
+            delete: async (tag) => {
+                return this.actionManager.delete(tag);
+            },
+            /**
+             * Dispatches a database action to run as a scheduled job.
+             * @param {IDBActionDispatchInput} data - The database action dispatch input.
+             * @returns {Promise<IDispatchResult>} The dispatch result with job ID and status.
+             * @example
+             * // Schedule a database action to run in 1 hour
+             * await ductape.databases.action.dispatch({
+             *   product: 'my-product',
+             *   env: 'production',
+             *   database: 'users-db',
+             *   event: 'cleanup-inactive',
+             *   input: { query: { inactive: true } },
+             *   schedule: { start_at: Date.now() + 3600000 }
+             * });
+             *
+             * // Run on a cron schedule
+             * await ductape.databases.action.dispatch({
+             *   product: 'my-product',
+             *   env: 'production',
+             *   database: 'analytics-db',
+             *   event: 'aggregate-daily',
+             *   input: { query: {} },
+             *   schedule: { cron: '0 0 * * *' } // Daily at midnight
+             * });
+             */
+            dispatch: async (data) => {
+                const processorService = this.createNewProcessor();
+                const productBuilder = await this.getProductBuilder(data.product);
+                const schedule = data.schedule || {};
+                const startAt = typeof schedule.start_at === 'string'
+                    ? new Date(schedule.start_at).getTime()
+                    : schedule.start_at || Date.now();
+                // Generate job tag based on type, database, and event
+                const jobTag = `database:${data.database}:${data.event}`;
+                // Check if job exists, if not create it
+                const existingJob = await productBuilder.fetchJob(jobTag);
+                if (!existingJob) {
+                    await productBuilder.createJob({
+                        tag: jobTag,
+                        name: `Database: ${data.database}/${data.event}`,
+                        description: `Auto-created job for database action ${data.event} on database ${data.database}`,
+                        type: types_1.JobEventTypes.DATABASE_ACTION,
+                        app: data.database,
+                        event: data.event,
+                        executions: 0,
+                        intervals: schedule.every || 0,
+                        start_at: startAt,
+                    });
+                }
+                const jobInput = {
+                    product: data.product,
+                    env: data.env,
+                    event: jobTag,
+                    input: data.input,
+                    retries: data.retries || 0,
+                    start_at: startAt,
+                    session: data.session,
+                    cache: data.cache,
+                    repeat: schedule.cron || schedule.every ? {
+                        cron: schedule.cron,
+                        every: schedule.every,
+                        limit: schedule.limit,
+                        endDate: schedule.endDate,
+                        tz: schedule.tz,
+                    } : undefined,
+                };
+                await processorService.processJob(jobInput);
+                const isRecurring = !!(schedule.cron || schedule.every);
+                let nextRunAt;
+                if (isRecurring && schedule.every) {
+                    nextRunAt = startAt + schedule.every;
+                }
+                return {
+                    job_id: (0, crypto_1.randomUUID)(),
+                    status: startAt > Date.now() ? 'scheduled' : 'queued',
+                    scheduled_at: startAt,
+                    recurring: isRecurring,
+                    next_run_at: nextRunAt,
+                };
+            },
+        };
+    }
+    /**
+     * Execute a database action
+     *
+     * @example
+     * const users = await ductape.database.execute({
+     *   product: 'my-product',
+     *   env: 'prd',
+     *   database: 'postgresdb',
+     *   action: 'get-users-paginated',
+     *   input: {
+     *     limit: 25,
+     *     offset: 0,
+     *   },
+     * });
+     */
+    async execute(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedOptions = options;
+        // Initialize product builder and logging
+        if (options.product) {
+            const builder = await this.getProductBuilder(options.product);
+            // Process session if provided
+            if (options.session) {
+                const privateKey = builder.fetchPrivateKey();
+                if (privateKey) {
+                    const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+                    const sessionResult = await processSessionForExecution(options.session, privateKey, options, options.env);
+                    if (sessionResult.error) {
+                        throw new Error(`Session validation failed: ${sessionResult.error}`);
+                    }
+                    resolvedOptions = sessionResult.input;
+                    sessionLogFields = sessionResult.logFields;
+                }
+            }
+        }
+        this.initializeLogService();
+        const baseLogs = Object.assign({ product_tag: options.product || '', workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '', env: options.env, process_id, type: logs_types_1.LogEventTypes.DB_ACTION, parent_tag: options.database, child_tag: options.action, data: { database: options.database, action: options.action } }, sessionLogFields);
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database action execute - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const result = await this.actionManager.execute(resolvedOptions);
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database action execute - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+            return result;
+        }
+        catch (error) {
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database action execute - failed', failed_execution: true, data: { database: options.database, action: options.action, error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            throw error;
+        }
+    }
+    /**
+     * Dispatches a database operation to run as a scheduled job.
+     * Use this for direct database operations (query, insert, update, delete, etc.).
+     * @param {IDBOperationDispatchInput} data - The database operation dispatch input.
+     * @returns {Promise<IDispatchResult>} The dispatch result with job ID and status.
+     * @example
+     * // Schedule a database operation to run in 1 hour
+     * await ductape.databases.dispatch({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   database: 'users-db',
+     *   operation: 'deleteMany',
+     *   input: { filter: { inactive: true, lastLogin: { $lt: '2024-01-01' } } },
+     *   schedule: { start_at: Date.now() + 3600000 }
+     * });
+     *
+     * // Run daily database cleanup
+     * await ductape.databases.dispatch({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   database: 'logs-db',
+     *   operation: 'deleteMany',
+     *   input: { filter: { createdAt: { $lt: '$DateAdd($Now(), -30, "days")' } } },
+     *   schedule: { cron: '0 3 * * *' } // Daily at 3 AM
+     * });
+     */
+    async dispatch(data) {
+        var _a, _b, _c, _d, _e, _f;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        const processorService = this.createNewProcessor();
+        const productBuilder = await this.getProductBuilder(data.product);
+        const schedule = data.schedule || {};
+        const startAt = typeof schedule.start_at === 'string'
+            ? new Date(schedule.start_at).getTime()
+            : schedule.start_at || Date.now();
+        // Generate job tag based on type, database, and operation
+        const jobTag = `database-operation:${data.database}:${data.operation}`;
+        // Initialize logging
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: data.product,
+            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            env: data.env,
+            process_id,
+            type: logs_types_1.LogEventTypes.DATABASE,
+            parent_tag: data.database,
+            child_tag: data.operation,
+            data: { database: data.database, operation: data.operation },
+        };
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database dispatch - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            // Check if job exists, if not create it
+            const existingJob = await productBuilder.fetchJob(jobTag);
+            if (!existingJob) {
+                await productBuilder.createJob({
+                    tag: jobTag,
+                    name: `Database Operation: ${data.database}/${data.operation}`,
+                    description: `Auto-created job for database operation ${data.operation} on database ${data.database}`,
+                    type: types_1.JobEventTypes.DATABASE_OPERATION,
+                    app: data.database,
+                    event: data.operation,
+                    executions: 0,
+                    intervals: schedule.every || 0,
+                    start_at: startAt,
+                });
+            }
+            const jobInput = {
+                product: data.product,
+                env: data.env,
+                event: jobTag,
+                input: data.input,
+                retries: data.retries || 0,
+                start_at: startAt,
+                session: data.session,
+                cache: data.cache,
+                repeat: schedule.cron || schedule.every ? {
+                    cron: schedule.cron,
+                    every: schedule.every,
+                    limit: schedule.limit,
+                    endDate: schedule.endDate,
+                    tz: schedule.tz,
+                } : undefined,
+            };
+            await processorService.processJob(jobInput);
+            const isRecurring = !!(schedule.cron || schedule.every);
+            let nextRunAt;
+            if (isRecurring && schedule.every) {
+                nextRunAt = startAt + schedule.every;
+            }
+            const job_id = (0, crypto_1.randomUUID)();
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database dispatch - success', successful_execution: true, data: { database: data.database, operation: data.operation, job_id }, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+            return {
+                job_id,
+                status: startAt > Date.now() ? 'scheduled' : 'queued',
+                scheduled_at: startAt,
+                recurring: isRecurring,
+                next_run_at: nextRunAt,
+            };
+        }
+        catch (error) {
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Database dispatch - failed', failed_execution: true, data: { database: data.database, operation: data.operation, error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            throw error;
+        }
+    }
+    // ==================== HELPER METHODS ====================
+    /**
+     * Get the appropriate adapter for the operation
+     */
+    getAdapter(options) {
+        // If options specify env and database, use those
+        if ((options === null || options === void 0 ? void 0 : options.env) && (options === null || options === void 0 ? void 0 : options.database)) {
+            const contextKey = this.buildContextKey(options.database, options.env);
+            const adapter = this.adapters.get(contextKey);
+            if (!adapter) {
+                throw new database_error_1.DatabaseError(`No adapter found for database '${options.database}' in environment '${options.env}'`, enums_1.DatabaseErrorType.NOT_FOUND);
+            }
+            return adapter;
+        }
+        // Otherwise use current context
+        if (!this.currentContext) {
+            throw new database_error_1.DatabaseError('No database connection established. Call connect() first or provide env and database options.', enums_1.DatabaseErrorType.CONNECTION_ERROR);
+        }
+        const contextKey = this.buildContextKey(this.currentContext.database, this.currentContext.env);
+        const adapter = this.adapters.get(contextKey);
+        if (!adapter) {
+            throw new database_error_1.DatabaseError('No adapter found for current connection context', enums_1.DatabaseErrorType.CONNECTION_ERROR);
+        }
+        return adapter;
+    }
+    /**
+     * Get the current connection context
+     */
+    getCurrentContext() {
+        return this.currentContext;
+    }
+    /**
+     * Get a connection-scoped interface for a specific database/environment.
+     * This ensures schema operations are isolated to a specific connection.
+     *
+     * @example
+     * const usersDb = db.connection('users-db', 'dev');
+     * await usersDb.schema.create('users', { ... });
+     *
+     * const ordersDb = db.connection('orders-db', 'dev');
+     * await ordersDb.schema.create('orders', { ... }); // Different connection
+     */
+    connection(database, env, product = '') {
+        return new DatabaseConnection(this, database, env, product);
+    }
+    /**
+     * Build a context key from database and environment
+     */
+    buildContextKey(database, env) {
+        return `${database}:${env}`;
+    }
+    /**
+     * Convert DatabaseTypes (from product API) to DatabaseType (ORM internal)
+     */
+    convertDatabaseType(type) {
+        // Map from DatabaseTypes enum values to DatabaseType enum
+        const typeMap = {
+            'postgresql': enums_1.DatabaseType.POSTGRESQL,
+            'mongodb': enums_1.DatabaseType.MONGODB,
+            'mysql': enums_1.DatabaseType.MYSQL,
+            'dynamodb': enums_1.DatabaseType.DYNAMODB,
+            'mariadb': enums_1.DatabaseType.MARIADB,
+            'cassandra': enums_1.DatabaseType.CASSANDRA,
+        };
+        const normalizedType = String(type).toLowerCase();
+        const mappedType = typeMap[normalizedType];
+        if (!mappedType) {
+            throw new database_error_1.DatabaseError(`Unsupported database type: ${type}. Supported types: ${Object.keys(typeMap).join(', ')}`, enums_1.DatabaseErrorType.VALIDATION_ERROR);
+        }
+        return mappedType;
+    }
+    // ==================== SIMPLIFIED SCHEMA API ====================
+    /**
+     * Simplified schema operations API (Mongoose-style)
+     *
+     * @example
+     * await db.connect({ env: 'dev', product: 'my-app', database: 'users-db' });
+     *
+     * // Create a table with Mongoose-style schema
+     * await db.schema.create('users', {
+     *   id: { type: 'uuid', primaryKey: true },
+     *   email: { type: 'string', length: 255, required: true, unique: true },
+     *   name: { type: 'string', length: 100 },
+     *   age: 'integer',  // Shorthand
+     *   status: { type: 'enum', enum: ['active', 'inactive'], default: 'active' },
+     * }, { timestamps: true });
+     */
+    get schema() {
+        return {
+            /**
+             * Create a collection/table with Mongoose-style schema definition
+             */
+            create: (name, definition, options) => this.schemaCreate(name, definition, options),
+            /**
+             * Drop a collection/table
+             */
+            drop: (name, options) => this.schemaDrop(name, options),
+            /**
+             * Add a field to a collection
+             */
+            addField: (collection, fieldName, definition) => this.schemaAddField(collection, fieldName, definition),
+            /**
+             * Drop a field from a collection
+             */
+            dropField: (collection, fieldName) => this.schemaDropField(collection, fieldName),
+            /**
+             * Rename a field in a collection
+             */
+            renameField: (collection, oldName, newName) => this.schemaRenameField(collection, oldName, newName),
+            /**
+             * Modify a field's definition
+             */
+            modifyField: (collection, fieldName, changes) => this.schemaModifyField(collection, fieldName, changes),
+            /**
+             * Create an index on a collection
+             */
+            createIndex: (collection, fields, options) => this.schemaCreateIndex(collection, fields, options),
+            /**
+             * Drop an index from a collection
+             */
+            dropIndex: (collection, indexName) => this.schemaDropIndex(collection, indexName),
+            /**
+             * Add a constraint (SQL databases only)
+             */
+            addConstraint: (collection, constraint) => this.schemaAddConstraint(collection, constraint),
+            /**
+             * Drop a constraint (SQL databases only)
+             */
+            dropConstraint: (collection, constraintName) => this.schemaDropConstraint(collection, constraintName),
+            /**
+             * Rename a collection/table
+             */
+            rename: (oldName, newName) => this.schemaRename(oldName, newName),
+            /**
+             * Check if a collection/table exists
+             */
+            exists: (name) => this.schemaExists(name),
+            /**
+             * List all collections/tables
+             */
+            list: (schemaName) => this.schemaList(schemaName),
+            /**
+             * Get detailed schema information for a collection
+             */
+            describe: (name) => this.schemaDescribe(name),
+            /**
+             * List indexes on a collection
+             */
+            indexes: (collection) => this.schemaListIndexes(collection),
+        };
+    }
+    // ==================== PRIVATE SCHEMA IMPLEMENTATION ====================
+    /**
+     * Create a collection with Mongoose-style definition
+     */
+    async schemaCreate(name, definition, options) {
+        var _a;
+        const schemaManager = this.getSchemaManager();
+        const fields = this.convertToFieldDefinitions(definition, options === null || options === void 0 ? void 0 : options.timestamps);
+        // Convert simple index definitions to the expected format
+        const indexes = (_a = options === null || options === void 0 ? void 0 : options.indexes) === null || _a === void 0 ? void 0 : _a.map(idx => ({
+            name: idx.name || `idx_${name}_${Array.isArray(idx.fields) ? (typeof idx.fields[0] === 'string' ? idx.fields.join('_') : idx.fields.map((f) => f.name).join('_')) : idx.fields}`,
+            fields: this.normalizeIndexFields(idx.fields),
+            unique: idx.unique,
+        }));
+        return schemaManager.createCollection(name, fields, {
+            autoApply: true,
+            indexes,
+            sqlOptions: options === null || options === void 0 ? void 0 : options.sqlOptions,
+            mongoOptions: options === null || options === void 0 ? void 0 : options.mongoOptions,
+            dynamoOptions: options === null || options === void 0 ? void 0 : options.dynamoOptions,
+            cassandraOptions: options === null || options === void 0 ? void 0 : options.cassandraOptions,
+        });
+    }
+    /**
+     * Drop a collection
+     */
+    async schemaDrop(name, options) {
+        const schemaManager = this.getSchemaManager();
+        return schemaManager.dropCollection(name, {
+            autoApply: true,
+            ifExists: options === null || options === void 0 ? void 0 : options.ifExists,
+            cascade: options === null || options === void 0 ? void 0 : options.cascade,
+        });
+    }
+    /**
+     * Add a field to a collection
+     */
+    async schemaAddField(collection, fieldName, definition) {
+        const schemaManager = this.getSchemaManager();
+        const field = this.convertFieldDefinition(fieldName, definition);
+        return schemaManager.addField(collection, field, { autoApply: true });
+    }
+    /**
+     * Drop a field from a collection
+     */
+    async schemaDropField(collection, fieldName) {
+        const schemaManager = this.getSchemaManager();
+        return schemaManager.dropField(collection, fieldName, { autoApply: true });
+    }
+    /**
+     * Rename a field
+     */
+    async schemaRenameField(collection, oldName, newName) {
+        const schemaManager = this.getSchemaManager();
+        return schemaManager.renameField(collection, oldName, newName, { autoApply: true });
+    }
+    /**
+     * Modify a field's definition
+     */
+    async schemaModifyField(collection, fieldName, changes) {
+        const schemaManager = this.getSchemaManager();
+        const fieldChanges = {};
+        if (changes.type) {
+            fieldChanges.type = this.normalizeFieldType(changes.type);
+        }
+        if (changes.minLength !== undefined) {
+            fieldChanges.minLength = changes.minLength;
+        }
+        if (changes.maxLength !== undefined) {
+            fieldChanges.maxLength = changes.maxLength;
+        }
+        if (changes.precision !== undefined) {
+            fieldChanges.precision = changes.precision;
+        }
+        if (changes.scale !== undefined) {
+            fieldChanges.scale = changes.scale;
+        }
+        if (changes.required !== undefined) {
+            fieldChanges.nullable = !changes.required;
+        }
+        if (changes.unique !== undefined) {
+            fieldChanges.unique = changes.unique;
+        }
+        if (changes.default !== undefined) {
+            fieldChanges.defaultValue = changes.default;
+        }
+        if (changes.enum !== undefined) {
+            fieldChanges.enumValues = changes.enum;
+        }
+        return schemaManager.modifyField(collection, fieldName, fieldChanges, { autoApply: true });
+    }
+    /**
+     * Create an index
+     */
+    async schemaCreateIndex(collection, fields, options) {
+        const schemaManager = this.getSchemaManager();
+        const normalizedFields = this.normalizeIndexFields(fields);
+        const indexName = (options === null || options === void 0 ? void 0 : options.name) || `idx_${collection}_${normalizedFields.map(f => f.name).join('_')}`;
+        return schemaManager.createIndex(collection, indexName, normalizedFields, {
+            autoApply: true,
+            unique: options === null || options === void 0 ? void 0 : options.unique,
+            sparse: options === null || options === void 0 ? void 0 : options.sparse,
+            sqlOptions: (options === null || options === void 0 ? void 0 : options.where) ? { where: options.where } : undefined,
+            mongoOptions: (options === null || options === void 0 ? void 0 : options.expireAfterSeconds) ? { expireAfterSeconds: options.expireAfterSeconds } : undefined,
+        });
+    }
+    /**
+     * Drop an index
+     */
+    async schemaDropIndex(collection, indexName) {
+        const schemaManager = this.getSchemaManager();
+        return schemaManager.dropIndex(collection, indexName, { autoApply: true, ifExists: true });
+    }
+    /**
+     * Add a constraint (SQL only)
+     */
+    async schemaAddConstraint(collection, constraint) {
+        const schemaManager = this.getSchemaManager();
+        return schemaManager.addConstraint(collection, constraint, { autoApply: true });
+    }
+    /**
+     * Drop a constraint (SQL only)
+     */
+    async schemaDropConstraint(collection, constraintName) {
+        const schemaManager = this.getSchemaManager();
+        return schemaManager.dropConstraint(collection, constraintName, { autoApply: true });
+    }
+    /**
+     * Rename a collection
+     */
+    async schemaRename(oldName, newName) {
+        const schemaManager = this.getSchemaManager();
+        return schemaManager.renameCollection(oldName, newName, { autoApply: true });
+    }
+    /**
+     * Check if collection exists
+     */
+    async schemaExists(name) {
+        const schemaManager = this.getSchemaManager();
+        return schemaManager.collectionExists(name);
+    }
+    /**
+     * List all collections
+     */
+    async schemaList(schemaName) {
+        const schemaManager = this.getSchemaManager();
+        return schemaManager.listCollections(schemaName);
+    }
+    /**
+     * Describe a collection's schema
+     */
+    async schemaDescribe(name) {
+        const schemaManager = this.getSchemaManager();
+        return schemaManager.getCollectionSchema(name);
+    }
+    /**
+     * List indexes on a collection
+     */
+    async schemaListIndexes(collection) {
+        const schemaManager = this.getSchemaManager();
+        return schemaManager.listIndexes(collection);
+    }
+    // ==================== SCHEMA CONVERSION HELPERS ====================
+    /**
+     * Convert Mongoose-style schema definition to IFieldDefinition array
+     */
+    convertToFieldDefinitions(definition, timestamps) {
+        const fields = [];
+        for (const [name, config] of Object.entries(definition)) {
+            fields.push(this.convertFieldDefinition(name, config));
+        }
+        if (timestamps) {
+            fields.push({ name: 'created_at', type: 'timestamp', defaultValue: 'NOW()', nullable: false }, { name: 'updated_at', type: 'timestamp', defaultValue: 'NOW()', nullable: false });
+        }
+        return fields;
+    }
+    /**
+     * Convert a single field definition
+     */
+    convertFieldDefinition(name, config) {
+        // Handle shorthand: { name: 'string' }
+        if (typeof config === 'string') {
+            return { name, type: this.normalizeFieldType(config) };
+        }
+        // Validate autoIncrement only works with numeric types
+        if (config.autoIncrement) {
+            const normalizedType = this.normalizeFieldType(config.type);
+            const numericTypes = ['integer', 'int', 'bigint', 'smallint', 'number', 'float', 'double', 'decimal'];
+            if (!numericTypes.includes(normalizedType.toLowerCase())) {
+                throw new database_error_1.DatabaseError(`autoIncrement can only be used with numeric types (integer, bigint, number, etc.), but field '${name}' has type '${config.type}'`, enums_1.DatabaseErrorType.VALIDATION_ERROR);
+            }
+        }
+        // Handle full definition
+        return {
+            name,
+            type: this.normalizeFieldType(config.type),
+            nullable: config.required === undefined ? true : !config.required,
+            unique: config.unique,
+            primaryKey: config.primaryKey,
+            autoGenerate: config.autoIncrement,
+            defaultValue: config.default,
+            minLength: config.minLength,
+            maxLength: config.maxLength,
+            precision: config.precision,
+            scale: config.scale,
+            enumValues: config.enum,
+            comment: config.comment,
+        };
+    }
+    /**
+     * Normalize Mongoose-style type names to FieldType
+     */
+    normalizeFieldType(type) {
+        const typeMap = {
+            'String': 'string',
+            'Number': 'integer',
+            'Boolean': 'boolean',
+            'Date': 'datetime',
+            'ObjectId': 'uuid',
+            'Array': 'array',
+            'Object': 'json',
+            'Mixed': 'json',
+        };
+        return typeMap[type] || type;
+    }
+    /**
+     * Normalize index fields to IIndexFieldDefinition array
+     */
+    normalizeIndexFields(fields) {
+        if (fields.length === 0) {
+            return [];
+        }
+        // Check if first element is a string
+        if (typeof fields[0] === 'string') {
+            return fields.map(name => ({ name }));
+        }
+        return fields;
+    }
+    /**
+     * Get adapter by context key (used by DatabaseConnection)
+     * @internal
+     */
+    getAdapterByContextKey(contextKey) {
+        const adapter = this.adapters.get(contextKey);
+        if (!adapter) {
+            throw new database_error_1.DatabaseError(`No adapter found for context '${contextKey}'. Call connect() first.`, enums_1.DatabaseErrorType.CONNECTION_ERROR);
+        }
+        return adapter;
+    }
+}
+exports.DatabaseService = DatabaseService;
+/**
+ * Connection-scoped database interface.
+ * Provides isolated schema, query, and aggregation operations for a specific database/environment.
+ */
+class DatabaseConnection {
+    constructor(service, database, env, product) {
+        this.service = service;
+        this._database = database;
+        this._env = env;
+        this._product = product;
+        this.contextKey = `${database}:${env}`;
+        this.triggerProcessor = new trigger_processor_1.TriggerProcessor({}, null);
+    }
+    /** Database tag */
+    get database() {
+        return this._database;
+    }
+    /** Environment slug */
+    get env() {
+        return this._env;
+    }
+    /** Product tag */
+    get product() {
+        return this._product;
+    }
+    /** Get the adapter for this connection */
+    getAdapter() {
+        return this.service.getAdapterByContextKey(this.contextKey);
+    }
+    /**
+     * Schema operations scoped to this connection
+     */
+    get schema() {
+        const adapter = () => this.getAdapter();
+        const service = this.service;
+        return {
+            create: async (name, definition, options) => {
+                var _a;
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                const fields = service.convertToFieldDefinitions(definition, options === null || options === void 0 ? void 0 : options.timestamps);
+                const indexes = (_a = options === null || options === void 0 ? void 0 : options.indexes) === null || _a === void 0 ? void 0 : _a.map(idx => ({
+                    name: idx.name || `idx_${name}_${Array.isArray(idx.fields) ? (typeof idx.fields[0] === 'string' ? idx.fields.join('_') : idx.fields.map((f) => f.name).join('_')) : idx.fields}`,
+                    fields: service.normalizeIndexFields(idx.fields),
+                    unique: idx.unique,
+                }));
+                return schemaManager.createCollection(name, fields, {
+                    autoApply: true,
+                    indexes,
+                    sqlOptions: options === null || options === void 0 ? void 0 : options.sqlOptions,
+                    mongoOptions: options === null || options === void 0 ? void 0 : options.mongoOptions,
+                    dynamoOptions: options === null || options === void 0 ? void 0 : options.dynamoOptions,
+                    cassandraOptions: options === null || options === void 0 ? void 0 : options.cassandraOptions,
+                });
+            },
+            drop: async (name, options) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                return schemaManager.dropCollection(name, {
+                    autoApply: true,
+                    ifExists: options === null || options === void 0 ? void 0 : options.ifExists,
+                    cascade: options === null || options === void 0 ? void 0 : options.cascade,
+                });
+            },
+            addField: async (collection, fieldName, definition) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                const field = service.convertFieldDefinition(fieldName, definition);
+                return schemaManager.addField(collection, field, { autoApply: true });
+            },
+            dropField: async (collection, fieldName) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                return schemaManager.dropField(collection, fieldName, { autoApply: true });
+            },
+            renameField: async (collection, oldName, newName) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                return schemaManager.renameField(collection, oldName, newName, { autoApply: true });
+            },
+            modifyField: async (collection, fieldName, changes) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                const fieldChanges = {};
+                if (changes.type)
+                    fieldChanges.type = service.normalizeFieldType(changes.type);
+                if (changes.minLength !== undefined)
+                    fieldChanges.minLength = changes.minLength;
+                if (changes.maxLength !== undefined)
+                    fieldChanges.maxLength = changes.maxLength;
+                if (changes.precision !== undefined)
+                    fieldChanges.precision = changes.precision;
+                if (changes.scale !== undefined)
+                    fieldChanges.scale = changes.scale;
+                if (changes.required !== undefined)
+                    fieldChanges.nullable = !changes.required;
+                if (changes.unique !== undefined)
+                    fieldChanges.unique = changes.unique;
+                if (changes.default !== undefined)
+                    fieldChanges.defaultValue = changes.default;
+                if (changes.enum !== undefined)
+                    fieldChanges.enumValues = changes.enum;
+                return schemaManager.modifyField(collection, fieldName, fieldChanges, { autoApply: true });
+            },
+            createIndex: async (collection, fields, options) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                const normalizedFields = service.normalizeIndexFields(fields);
+                const indexName = (options === null || options === void 0 ? void 0 : options.name) || `idx_${collection}_${normalizedFields.map((f) => f.name).join('_')}`;
+                return schemaManager.createIndex(collection, indexName, normalizedFields, {
+                    autoApply: true,
+                    unique: options === null || options === void 0 ? void 0 : options.unique,
+                    sparse: options === null || options === void 0 ? void 0 : options.sparse,
+                    sqlOptions: (options === null || options === void 0 ? void 0 : options.where) ? { where: options.where } : undefined,
+                    mongoOptions: (options === null || options === void 0 ? void 0 : options.expireAfterSeconds) ? { expireAfterSeconds: options.expireAfterSeconds } : undefined,
+                });
+            },
+            dropIndex: async (collection, indexName) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                return schemaManager.dropIndex(collection, indexName, { autoApply: true, ifExists: true });
+            },
+            addConstraint: async (collection, constraint) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                return schemaManager.addConstraint(collection, constraint, { autoApply: true });
+            },
+            dropConstraint: async (collection, constraintName) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                return schemaManager.dropConstraint(collection, constraintName, { autoApply: true });
+            },
+            rename: async (oldName, newName) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                return schemaManager.renameCollection(oldName, newName, { autoApply: true });
+            },
+            exists: async (name) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                return schemaManager.collectionExists(name);
+            },
+            list: async (schemaName) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                return schemaManager.listCollections(schemaName);
+            },
+            describe: async (name) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                return schemaManager.getCollectionSchema(name);
+            },
+            indexes: async (collection) => {
+                const schemaManager = new schema_manager_1.SchemaManager(adapter());
+                return schemaManager.listIndexes(collection);
+            },
+        };
+    }
+    // Query operations scoped to this connection
+    query(options) {
+        return this.service.query(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    insert(options) {
+        return this.service.insert(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    update(options) {
+        return this.service.update(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    delete(options) {
+        return this.service.delete(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    upsert(options) {
+        return this.service.upsert(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    raw(options) {
+        return this.service.raw(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    // Aggregation operations scoped to this connection
+    count(options) {
+        return this.service.count(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    sum(options) {
+        return this.service.sum(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    avg(options) {
+        return this.service.avg(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    min(options) {
+        return this.service.min(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    max(options) {
+        return this.service.max(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    aggregate(options) {
+        return this.service.aggregate(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    groupBy(options) {
+        return this.service.groupBy(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
+    }
+    /**
+     * Trigger operations scoped to this connection
+     */
+    get triggers() {
+        const connection = this;
+        return {
+            /**
+             * Create a trigger and store it on the backend
+             * @param data - Trigger configuration (tag should be just the trigger name, database tag is added automatically)
+             */
+            create: async (data) => {
+                var _a;
+                if (!connection._product) {
+                    throw new Error('Product tag is required to create triggers. Use connect() with product parameter.');
+                }
+                // Auto-prefix with database tag if not already prefixed
+                const tag = ((_a = data.tag) === null || _a === void 0 ? void 0 : _a.includes(':')) ? data.tag : `${connection._database}:${data.tag}`;
+                return connection.service.createTrigger(connection._product, Object.assign(Object.assign({}, data), { tag }));
+            },
+            /**
+             * Update an existing trigger on the backend
+             * @param data - Trigger configuration
+             */
+            update: async (data) => {
+                var _a;
+                if (!connection._product) {
+                    throw new Error('Product tag is required to update triggers. Use connect() with product parameter.');
+                }
+                const tag = ((_a = data.tag) === null || _a === void 0 ? void 0 : _a.includes(':')) ? data.tag : `${connection._database}:${data.tag}`;
+                return connection.service.updateTrigger(connection._product, Object.assign(Object.assign({}, data), { tag }));
+            },
+            /**
+             * Fetch a specific trigger from the backend
+             * @param triggerTag - The trigger tag (without database prefix)
+             */
+            fetch: async (triggerTag) => {
+                if (!connection._product) {
+                    throw new Error('Product tag is required to fetch triggers. Use connect() with product parameter.');
+                }
+                const tag = triggerTag.includes(':') ? triggerTag : `${connection._database}:${triggerTag}`;
+                return connection.service.fetchTrigger(connection._product, tag);
+            },
+            /**
+             * Fetch all triggers for this database from the backend
+             * @deprecated Use list() instead
+             */
+            fetchAll: async () => {
+                if (!connection._product) {
+                    throw new Error('Product tag is required to fetch triggers. Use connect() with product parameter.');
+                }
+                return connection.service.fetchTriggers(connection._product, connection._database);
+            },
+            /**
+             * List all triggers for this database from the backend
+             * @param options - Optional filters (table, event, enabled)
+             */
+            list: async (options) => {
+                if (!connection._product) {
+                    throw new Error('Product tag is required to list triggers. Use connect() with product parameter.');
+                }
+                let triggers = await connection.service.fetchTriggers(connection._product, connection._database);
+                // Apply filters if provided
+                if (options === null || options === void 0 ? void 0 : options.table) {
+                    triggers = triggers.filter(t => { var _a; return (_a = t.tables) === null || _a === void 0 ? void 0 : _a.includes(options.table); });
+                }
+                if (options === null || options === void 0 ? void 0 : options.event) {
+                    triggers = triggers.filter(t => { var _a; return (_a = t.events) === null || _a === void 0 ? void 0 : _a.includes(options.event); });
+                }
+                if ((options === null || options === void 0 ? void 0 : options.enabled) !== undefined) {
+                    triggers = triggers.filter(t => t.enabled === options.enabled);
+                }
+                return triggers;
+            },
+            /**
+             * Delete a trigger from the backend
+             * @param triggerTag - The trigger tag (without database prefix)
+             */
+            delete: async (triggerTag) => {
+                if (!connection._product) {
+                    throw new Error('Product tag is required to delete triggers. Use connect() with product parameter.');
+                }
+                const tag = triggerTag.includes(':') ? triggerTag : `${connection._database}:${triggerTag}`;
+                await connection.service.deleteTrigger(connection._product, tag);
+                return true;
+            },
+            /**
+             * Register a trigger in memory for the current session (does not persist to backend)
+             * @deprecated Use create() for persistent triggers
+             */
+            register: (table, trigger) => {
+                connection.triggerProcessor.register(table, trigger);
+            },
+            /**
+             * Register multiple triggers in memory (does not persist to backend)
+             * @deprecated Use create() for persistent triggers
+             */
+            registerAll: (triggers) => {
+                connection.triggerProcessor.registerAll(triggers);
+            },
+            /**
+             * Unregister a trigger from memory
+             */
+            unregister: (table, triggerName) => {
+                return connection.triggerProcessor.unregister(table, triggerName);
+            },
+            /**
+             * Get all triggers for a table and event
+             */
+            getTriggersForEvent: (table, event) => {
+                return connection.triggerProcessor.getTriggersForEvent(table, event);
+            },
+            /**
+             * Execute all triggers for an event
+             */
+            execute: async (event, context) => {
+                return connection.triggerProcessor.executeTriggers(event, Object.assign(Object.assign({}, context), { database: connection._database, env: connection._env }));
+            },
+            /**
+             * Load triggers from the backend and register them in memory
+             */
+            load: async () => {
+                if (!connection._product) {
+                    throw new Error('Product tag is required to load triggers. Use connect() with product parameter.');
+                }
+                const backendTriggers = await connection.service.fetchTriggers(connection._product, connection._database);
+                for (const trigger of backendTriggers) {
+                    // Convert backend trigger format to ITriggerDefinition
+                    const definition = {
+                        name: trigger.tag,
+                        description: trigger.description,
+                        events: trigger.events, // TriggerEventType maps to TriggerEvent
+                        tables: trigger.tables,
+                        condition: trigger.condition,
+                        actions: trigger.actions.map(action => (Object.assign(Object.assign({}, action.config), { type: action.type, name: action.name, condition: action.condition, timing: action.timing, retry: action.retry, timeout: action.timeout, continueOnError: action.continueOnError }))),
+                        enabled: trigger.enabled,
+                        priority: trigger.priority,
+                        tags: trigger.tags,
+                    };
+                    // Register for all tables specified, or use '*' for all
+                    const tables = trigger.tables && trigger.tables.length > 0 ? trigger.tables : ['*'];
+                    for (const table of tables) {
+                        connection.triggerProcessor.register(table, definition);
+                    }
+                }
+            },
+            /**
+             * Set the Ductape instance for trigger actions
+             */
+            setDuctapeInstance: (instance) => {
+                connection.triggerProcessor.setDuctapeInstance(instance);
+            },
+            /**
+             * Get the trigger processor instance
+             */
+            getProcessor: () => {
+                return connection.triggerProcessor;
+            },
+            /**
+             * Trigger action builders
+             */
+            Trigger: trigger_processor_1.Trigger,
+            /**
+             * Trigger events enum
+             */
+            TriggerEvent: trigger_interface_1.TriggerEvent,
+            /**
+             * Trigger timing enum
+             */
+            TriggerTiming: trigger_interface_1.TriggerTiming,
+            /**
+             * Trigger action types enum
+             */
+            TriggerActionType: trigger_interface_1.TriggerActionType,
+        };
+    }
+}
+exports.DatabaseConnection = DatabaseConnection;
+// Export singleton instance for convenience
+exports.databaseService = new DatabaseService();
+//# sourceMappingURL=databases.service.js.map