@ductape/sdk 0.1.6 → 0.1.8

package/dist/database/databases.service.js

@@ -1,3294 +0,0 @@
-"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");
-/** Module-level: last time we logged connect initiated/success/failed per key, to avoid duplicate logs across multiple DatabaseService instances */
-const lastConnectLogAt = new Map();
-const CONNECT_LOG_DEBOUNCE_MS = 15000;
-function getConnectLogKey(product, database, env) {
-    return `${product !== null && product !== void 0 ? product : ''}:${database}:${env}`;
-}
-const sharedConnectionRegistry = new Map();
-const sharedConnectInFlight = new Map();
-function getSharedConnectionKey(workspaceId, product, database, env) {
-    return `${workspaceId}:${product}:${database}:${env}`;
-}
-/**
- * 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();
-        /** Local cache for cache configurations to avoid repeated API calls (5 minute TTL) */
-        this.cacheConfigCache = new Map();
-        /** In-flight connect() promises per contextKey to deduplicate concurrent connects and avoid duplicate logs */
-        this.connectPromises = 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 (Redis is optional - Tier 1 internal cache and Tier 3 remote cache always work)
-        if ((config === null || config === void 0 ? void 0 : config.workspace_id) && (config === null || config === void 0 ? void 0 : config.public_key) && (config === null || config === void 0 ? void 0 : config.user_id) && (config === null || config === void 0 ? void 0 : config.token)) {
-            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, // Optional - Tier 2 cache
-            });
-        }
-    }
-    /**
-     * 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() {
-        var _a;
-        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,
-                workspace_private_key: (_a = this._privateKey) !== null && _a !== void 0 ? _a : undefined,
-            });
-        }
-    }
-    /**
-     * 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;
-    }
-    /**
-     * Validate cache tag exists in product and return cache configuration
-     * Uses local in-memory cache to avoid repeated API calls (5 minute TTL)
-     */
-    async validateCache(productTag, cacheTag) {
-        const cacheKey = `${productTag}:${cacheTag}`;
-        const cached = this.cacheConfigCache.get(cacheKey);
-        const now = Date.now();
-        const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-        // Return cached config if still valid
-        if (cached && (now - cached.fetchedAt) < CACHE_TTL) {
-            return { expiry: cached.expiry };
-        }
-        // Fetch from API and cache the result
-        const builder = await this.getProductBuilder(productTag);
-        const cache = await builder.fetchCache(cacheTag);
-        if (!cache) {
-            throw new database_error_1.DatabaseError(`Cache configuration '${cacheTag}' does not exist`, enums_1.DatabaseErrorType.NOT_FOUND);
-        }
-        this.cacheConfigCache.set(cacheKey, { expiry: cache.expiry, fetchedAt: now });
-        return { expiry: cache.expiry };
-    }
-    /**
-     * 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);
-        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 });
-                    }
-                    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],
-                        });
-                    }
-                    // Update the connection URL to use the secret reference
-                    connectionUrl = `$Secret{${secretKey}}`;
-                }
-                catch (error) {
-                    // Continue with the original connection URL on failure
-                }
-            }
-            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,
-                })),
-            });
-        }
-        // Create local adapters and connection contexts
-        this.createAdapter({
-            tag: config.tag,
-            name: config.name,
-            type: config.type,
-            description: config.description,
-            envs: processedEnvs,
-        });
-    }
-    /**
-     * Create local adapter and connection context for a database configuration.
-     * This is a lightweight operation that only sets up local state without API calls.
-     * Use this when the database config is already fetched/decrypted from the API.
-     *
-     * @param config - The database configuration (already decrypted if from API)
-     */
-    createAdapter(config) {
-        var _a;
-        // Validate required fields
-        if (!config.tag || !config.type || !((_a = config.envs) === null || _a === void 0 ? void 0 : _a.length)) {
-            throw new database_error_1.DatabaseError('Database configuration requires tag, type, and at least one environment', enums_1.DatabaseErrorType.VALIDATION_ERROR);
-        }
-        const databaseType = typeof config.type === 'string'
-            ? this.convertDatabaseType(config.type)
-            : config.type;
-        // Validate database type
-        if (!Object.values(enums_1.DatabaseType).includes(databaseType)) {
-            throw new database_error_1.DatabaseError(`Unsupported database type: ${config.type}. Supported types: ${Object.values(enums_1.DatabaseType).join(', ')}`, enums_1.DatabaseErrorType.VALIDATION_ERROR);
-        }
-        // Create adapters and contexts for each environment
-        for (const envConfig of config.envs) {
-            const contextKey = this.buildContextKey(config.tag, envConfig.slug);
-            // Skip if already exists
-            if (this.adapters.has(contextKey) && this.connectionContexts.has(contextKey)) {
-                continue;
-            }
-            const adapter = this.adapterFactory.create(databaseType);
-            this.adapters.set(contextKey, adapter);
-            this.connectionContexts.set(contextKey, {
-                database: config.tag,
-                env: envConfig.slug,
-                type: databaseType,
-                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;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        const contextKey = this.buildContextKey(config.database, config.env);
-        const workspaceId = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) !== null && _b !== void 0 ? _b : '';
-        const product = (_c = config.product) !== null && _c !== void 0 ? _c : '';
-        // Use shared registry only when we have an authenticated scope (workspace + product).
-        // Connections are never shared across workspaces or products.
-        const useShared = workspaceId !== '' && product !== '';
-        if (useShared) {
-            const sharedKey = getSharedConnectionKey(workspaceId, product, config.database, config.env);
-            const existing = sharedConnectionRegistry.get(sharedKey);
-            if (existing === null || existing === void 0 ? void 0 : existing.context.connected) {
-                this.adapters.set(contextKey, existing.adapter);
-                this.connectionContexts.set(contextKey, existing.context);
-                return new DatabaseConnection(this, config.database, config.env, config.product || '');
-            }
-            const inFlight = sharedConnectInFlight.get(sharedKey);
-            if (inFlight) {
-                const entry = await inFlight;
-                this.adapters.set(contextKey, entry.adapter);
-                this.connectionContexts.set(contextKey, entry.context);
-                return new DatabaseConnection(this, config.database, config.env, config.product || '');
-            }
-            const createPromise = this.connectAndRegisterShared(sharedKey, config, contextKey, process_id, start);
-            sharedConnectInFlight.set(sharedKey, createPromise);
-            try {
-                const entry = await createPromise;
-                this.adapters.set(contextKey, entry.adapter);
-                this.connectionContexts.set(contextKey, entry.context);
-                return new DatabaseConnection(this, config.database, config.env, config.product || '');
-            }
-            finally {
-                sharedConnectInFlight.delete(sharedKey);
-            }
-        }
-        // Per-instance path when shared registry is not used (no workspace/product scope)
-        let adapter = this.adapters.get(contextKey);
-        let context = this.connectionContexts.get(contextKey);
-        if (!adapter || !context) {
-            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);
-            }
-            await this.getProductBuilder(config.product);
-            const dbConfig = await this.fetchDatabase(config.product, config.database);
-            if (!dbConfig) {
-                throw new database_error_1.DatabaseError(`Database '${config.database}' not found for product '${config.product}'.`, enums_1.DatabaseErrorType.NOT_FOUND);
-            }
-            this.createAdapter({
-                tag: config.database,
-                name: dbConfig.name,
-                type: dbConfig.type,
-                description: dbConfig.description,
-                envs: dbConfig.envs.map(e => ({
-                    slug: e.slug,
-                    connection_url: e.connection_url,
-                    description: e.description,
-                })),
-            });
-            adapter = this.adapters.get(contextKey);
-            context = this.connectionContexts.get(contextKey);
-        }
-        if (!adapter || !context) {
-            throw new database_error_1.DatabaseError(`Failed to initialize adapter for ${contextKey}`, enums_1.DatabaseErrorType.CONNECTION_ERROR);
-        }
-        if (context.connected) {
-            return new DatabaseConnection(this, config.database, config.env, config.product || '');
-        }
-        const inFlight = this.connectPromises.get(contextKey);
-        if (inFlight) {
-            return inFlight;
-        }
-        const connectPromise = this.runConnect(config, contextKey, adapter, context, process_id, start);
-        this.connectPromises.set(contextKey, connectPromise);
-        try {
-            return await connectPromise;
-        }
-        finally {
-            this.connectPromises.delete(contextKey);
-        }
-    }
-    /**
-     * Disconnect any existing connection to this resource from the SDK (shared registry and this instance) before creating a fresh one.
-     */
-    async disconnectExistingForResource(sharedKey, contextKey, workspaceId, product, database, env) {
-        const existingInRegistry = sharedConnectionRegistry.get(sharedKey);
-        if (existingInRegistry) {
-            try {
-                await existingInRegistry.adapter.disconnect();
-                existingInRegistry.context.connected = false;
-            }
-            catch (_a) {
-                // Non-fatal
-            }
-            sharedConnectionRegistry.delete(sharedKey);
-        }
-        const context = this.connectionContexts.get(contextKey);
-        if (context === null || context === void 0 ? void 0 : context.connected) {
-            const adapter = this.adapters.get(contextKey);
-            if (adapter) {
-                try {
-                    await adapter.disconnect();
-                }
-                catch (_b) {
-                    // Non-fatal
-                }
-                context.connected = false;
-                if (workspaceId && product) {
-                    sharedConnectionRegistry.delete(getSharedConnectionKey(workspaceId, product, database, env));
-                }
-            }
-        }
-    }
-    /**
-     * Get or create adapter/context, connect, and register in shared registry.
-     * Only used when connect() is scoped with workspace_id and product (no cross-tenant sharing).
-     */
-    async connectAndRegisterShared(sharedKey, config, contextKey, process_id, start) {
-        var _a, _b, _c;
-        const workspaceId = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) !== null && _b !== void 0 ? _b : '';
-        const product = (_c = config.product) !== null && _c !== void 0 ? _c : '';
-        await this.disconnectExistingForResource(sharedKey, contextKey, workspaceId, product, config.database, config.env);
-        let adapter = this.adapters.get(contextKey);
-        let context = this.connectionContexts.get(contextKey);
-        if (!adapter || !context) {
-            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);
-            }
-            await this.getProductBuilder(config.product);
-            const dbConfig = await this.fetchDatabase(config.product, config.database);
-            if (!dbConfig) {
-                throw new database_error_1.DatabaseError(`Database '${config.database}' not found for product '${config.product}'.`, enums_1.DatabaseErrorType.NOT_FOUND);
-            }
-            this.createAdapter({
-                tag: config.database,
-                name: dbConfig.name,
-                type: dbConfig.type,
-                description: dbConfig.description,
-                envs: dbConfig.envs.map(e => ({
-                    slug: e.slug,
-                    connection_url: e.connection_url,
-                    description: e.description,
-                })),
-            });
-            adapter = this.adapters.get(contextKey);
-            context = this.connectionContexts.get(contextKey);
-        }
-        await this.runConnect(config, contextKey, adapter, context, process_id, start);
-        const entry = { adapter, context };
-        const raceExisting = sharedConnectionRegistry.get(sharedKey);
-        if (raceExisting) {
-            try {
-                await raceExisting.adapter.disconnect();
-                raceExisting.context.connected = false;
-            }
-            catch (_d) {
-                // Non-fatal
-            }
-            sharedConnectionRegistry.delete(sharedKey);
-        }
-        sharedConnectionRegistry.set(sharedKey, entry);
-        return entry;
-    }
-    /**
-     * Performs the actual connect (resolve URL, adapter.connect(), log). Called once per contextKey when not already connected.
-     */
-    async runConnect(config, contextKey, adapter, context, process_id, start) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        this.initializeLogService();
-        const envValue = config.env || '';
-        const baseLogs = {
-            product_tag: config.product || '',
-            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
-            env: envValue,
-            app_env: envValue,
-            process_id,
-            type: logs_types_1.LogEventTypes.DATABASE,
-            parent_tag: config.database,
-            child_tag: 'connect',
-            data: { database: config.database, env: envValue, operation: 'connect' },
-        };
-        const logKey = getConnectLogKey(config.product, config.database, config.env);
-        const now = Date.now();
-        const last = (_b = lastConnectLogAt.get(logKey)) !== null && _b !== void 0 ? _b : {};
-        if (this.logService && (!last.initiated || now - last.initiated >= CONNECT_LOG_DEBOUNCE_MS)) {
-            lastConnectLogAt.set(logKey, Object.assign(Object.assign({}, last), { initiated: now }));
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Database connect - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        }
-        try {
-            // Resolve secret reference in connection URL if needed
-            let connectionUrl = context.connectionUrl;
-            const secretCheck = (0, secrets_1.isSecretReference)(connectionUrl);
-            if (secretCheck.isSecret) {
-                const secretsService = (0, secrets_1.getSecretsService)();
-                if (secretsService) {
-                    const resolved = await secretsService.resolve(connectionUrl, { env: config.env });
-                    connectionUrl = resolved.value;
-                }
-                else {
-                    throw new database_error_1.DatabaseError(`Connection URL contains secret reference but secrets service is not initialized.`, enums_1.DatabaseErrorType.CONNECTION_ERROR);
-                }
-            }
-            await adapter.connect({
-                connectionUrl,
-            });
-            context.connected = true;
-            context.product = config.product;
-            this.currentContext = context;
-            const end = Date.now();
-            const lastSuccess = (_c = lastConnectLogAt.get(logKey)) !== null && _c !== void 0 ? _c : {};
-            if (this.logService && (!lastSuccess.success || end - lastSuccess.success >= CONNECT_LOG_DEBOUNCE_MS)) {
-                lastConnectLogAt.set(logKey, Object.assign(Object.assign({}, lastSuccess), { success: end }));
-                this.logService.add(Object.assign(Object.assign({}, baseLogs), { start,
-                    end, message: 'Database connect - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-                this.logService.publish();
-            }
-            return new DatabaseConnection(this, config.database, config.env, config.product || '');
-        }
-        catch (error) {
-            const end = Date.now();
-            const lastFail = (_d = lastConnectLogAt.get(logKey)) !== null && _d !== void 0 ? _d : {};
-            if (this.logService && (!lastFail.failed || end - lastFail.failed >= CONNECT_LOG_DEBOUNCE_MS)) {
-                lastConnectLogAt.set(logKey, Object.assign(Object.assign({}, lastFail), { failed: end }));
-                this.logService.add(Object.assign(Object.assign({}, baseLogs), { start,
-                    end, message: 'Database connect - failed', failed_execution: true, data: { database: config.database, env: config.env, error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-                await this.logService.publish();
-            }
-            const err = error;
-            const baseMsg = (_e = err === null || err === void 0 ? void 0 : err.message) !== null && _e !== void 0 ? _e : String(error);
-            let detail = baseMsg;
-            if (err === null || err === void 0 ? void 0 : err.response) {
-                const status = (_f = err.response) === null || _f === void 0 ? void 0 : _f.status;
-                const body = (_g = err.response) === null || _g === void 0 ? void 0 : _g.data;
-                const bodyStr = typeof body === 'object' ? JSON.stringify(body) : body;
-                detail = bodyStr ? `${baseMsg} (HTTP ${status}): ${bodyStr}` : `${baseMsg} (HTTP ${status})`;
-            }
-            throw new database_error_1.DatabaseError(`Failed to connect to database: ${detail}`, 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() {
-        var _a, _b, _c;
-        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;
-                const workspaceId = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) !== null && _b !== void 0 ? _b : '';
-                const product = (_c = this.currentContext.product) !== null && _c !== void 0 ? _c : '';
-                if (workspaceId && product) {
-                    sharedConnectionRegistry.delete(getSharedConnectionKey(workspaceId, product, this.currentContext.database, this.currentContext.env));
-                }
-            }
-            this.currentContext = null;
-        }
-    }
-    /**
-     * Close all database connections
-     *
-     * @example
-     * await ductape.database.closeAll();
-     */
-    async closeAll() {
-        var _a, _b, _c;
-        const disconnectPromises = [];
-        const workspaceId = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) !== null && _b !== void 0 ? _b : '';
-        for (const [key, adapter] of this.adapters) {
-            disconnectPromises.push(adapter.disconnect());
-            const context = this.connectionContexts.get(key);
-            if (context) {
-                context.connected = false;
-                const product = (_c = context.product) !== null && _c !== void 0 ? _c : '';
-                if (workspaceId && product) {
-                    sharedConnectionRegistry.delete(getSharedConnectionKey(workspaceId, product, context.database, context.env));
-                }
-            }
-        }
-        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, _j, _k, _l, _m, _o, _p, _q;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        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, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await builder.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new Error(`Session validation failed: ${sessionResult.error}`);
-                }
-                resolvedOptions = sessionResult.input;
-                sessionLogFields = sessionResult.logFields;
-            }
-        }
-        const envValue = options.env || ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.env) || '';
-        const baseLogs = Object.assign({ product_tag: options.product || ((_b = this.currentContext) === null || _b === void 0 ? void 0 : _b.product) || '', workspace_id: ((_c = this.config) === null || _c === void 0 ? void 0 : _c.workspace_id) || '', env: envValue, app_env: envValue, process_id, type: logs_types_1.LogEventTypes.DATABASE, parent_tag: options.database || ((_d = this.currentContext) === null || _d === void 0 ? void 0 : _d.database) || '', child_tag: 'query', data: {
-                table: options.table,
-                operation: 'query',
-                database: options.database || ((_e = this.currentContext) === null || _e === void 0 ? void 0 : _e.database) || '',
-                env: envValue,
-                where: options.where,
-                select: options.select,
-                orderBy: options.orderBy,
-                limit: options.limit,
-                offset: options.offset,
-                include: options.include,
-            } }, sessionLogFields);
-        (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Database query - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        // Check cache if cache tag is provided
-        // Use product from options or from current context (set during connect)
-        const productTag = options.product || ((_g = this.currentContext) === null || _g === void 0 ? void 0 : _g.product);
-        const privateKey = productTag ? this.privateKeys.get(productTag) : undefined;
-        let queryCacheKey;
-        try {
-            if (options.cache && this.cacheManager && privateKey) {
-                const cacheOptions = {
-                    cache_tag: options.cache,
-                    product_tag: productTag || '',
-                    component_tag: options.database || ((_h = this.currentContext) === null || _h === void 0 ? void 0 : _h.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);
-                queryCacheKey = cached.key;
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    (_j = this.logService) === null || _j === void 0 ? void 0 : _j.add(Object.assign(Object.assign({}, baseLogs), { start,
-                        end, message: `Database query - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, cache_tag: options.cache, cache_key: cached.key, cache_status: true }));
-                    (_k = this.logService) === null || _k === void 0 ? void 0 : _k.publish();
-                    return cached.data;
-                }
-            }
-            await this.ensureAdapterFor(resolvedOptions);
-            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 && productTag) {
-                const cacheConfig = await this.validateCache(productTag, options.cache);
-                const cacheOptions = {
-                    cache_tag: options.cache,
-                    product_tag: productTag,
-                    component_tag: options.database || ((_l = this.currentContext) === null || _l === void 0 ? void 0 : _l.database) || '',
-                    component_type: 'database',
-                    input: { table: options.table, where: options.where, select: options.select, orderBy: options.orderBy, limit: options.limit, offset: options.offset },
-                    privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                this.cacheManager.store(cacheOptions, result); // Fire-and-forget
-            }
-            const end = Date.now();
-            (_m = this.logService) === null || _m === void 0 ? void 0 : _m.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: options.cache ? 'Database query - cache miss' : 'Database query - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, cache_tag: options.cache, cache_key: queryCacheKey }));
-            (_o = this.logService) === null || _o === void 0 ? void 0 : _o.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            (_p = this.logService) === null || _p === void 0 ? void 0 : _p.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Database query - failed', failed_execution: true, data: { table: options.table, operation: 'query', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL, cache_tag: options.cache, cache_key: queryCacheKey }));
-            await ((_q = this.logService) === null || _q === void 0 ? void 0 : _q.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, _j, _k, _l;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        this.initializeLogService();
-        const envValue = options.env || ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.env) || '';
-        const databaseValue = options.database || ((_b = this.currentContext) === null || _b === void 0 ? void 0 : _b.database) || '';
-        const baseLogs = {
-            product_tag: options.product || ((_c = this.currentContext) === null || _c === void 0 ? void 0 : _c.product) || '',
-            workspace_id: ((_d = this.config) === null || _d === void 0 ? void 0 : _d.workspace_id) || '',
-            env: envValue,
-            app_env: envValue,
-            process_id,
-            type: logs_types_1.LogEventTypes.DATABASE,
-            parent_tag: databaseValue,
-            child_tag: 'raw',
-            data: {
-                operation: 'raw',
-                database: databaseValue,
-                env: envValue,
-                collection: options.collection,
-                query: options.query,
-                params: options.params,
-            },
-        };
-        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Database raw query - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        // Check cache if cache tag is provided
-        const privateKey = options.product ? this.privateKeys.get(options.product) : undefined;
-        let rawQueryCacheKey;
-        try {
-            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);
-                rawQueryCacheKey = cached.key;
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { start,
-                        end, message: `Database raw query - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, cache_tag: options.cache, cache_key: cached.key, cache_status: true }));
-                    (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
-                    return cached.data;
-                }
-            }
-            await this.ensureAdapterFor(options);
-            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 && options.product) {
-                const cacheConfig = await this.validateCache(options.product, options.cache);
-                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,
-                    expiry: cacheConfig.expiry,
-                };
-                this.cacheManager.store(cacheOptions, result); // Fire-and-forget
-            }
-            const end = Date.now();
-            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: options.cache ? 'Database raw query - cache miss' : 'Database raw query - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, cache_tag: options.cache, cache_key: rawQueryCacheKey }));
-            (_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            (_k = this.logService) === null || _k === void 0 ? void 0 : _k.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Database raw query - failed', failed_execution: true, data: { operation: 'raw', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL, cache_tag: options.cache, cache_key: rawQueryCacheKey }));
-            await ((_l = this.logService) === null || _l === void 0 ? void 0 : _l.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, _g, _h, _j;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        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, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await builder.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new Error(`Session validation failed: ${sessionResult.error}`);
-                }
-                resolvedOptions = sessionResult.input;
-                sessionLogFields = sessionResult.logFields;
-            }
-        }
-        const envValue = options.env || ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.env) || '';
-        const databaseValue = options.database || ((_b = this.currentContext) === null || _b === void 0 ? void 0 : _b.database) || '';
-        const baseLogs = Object.assign({ product_tag: options.product || ((_c = this.currentContext) === null || _c === void 0 ? void 0 : _c.product) || '', workspace_id: ((_d = this.config) === null || _d === void 0 ? void 0 : _d.workspace_id) || '', env: envValue, app_env: envValue, process_id, type: logs_types_1.LogEventTypes.DATABASE, parent_tag: databaseValue, child_tag: 'insert', data: {
-                table: options.table,
-                operation: 'insert',
-                database: databaseValue,
-                env: envValue,
-                data: options.data,
-                returning: options.returning,
-                onConflict: options.onConflict,
-            } }, sessionLogFields);
-        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { start, 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;
-            }
-            await this.ensureAdapterFor(resolvedOptions);
-            const adapter = this.getAdapter(resolvedOptions);
-            const result = await adapter.insert(Object.assign(Object.assign({}, resolvedOptions), { data: processedData }));
-            const end = Date.now();
-            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Database insert - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Database insert - failed', failed_execution: true, data: { table: options.table, operation: 'insert', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.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, _g, _h, _j;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        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, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await builder.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new Error(`Session validation failed: ${sessionResult.error}`);
-                }
-                resolvedOptions = sessionResult.input;
-                sessionLogFields = sessionResult.logFields;
-            }
-        }
-        const envValue = options.env || ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.env) || '';
-        const databaseValue = options.database || ((_b = this.currentContext) === null || _b === void 0 ? void 0 : _b.database) || '';
-        const baseLogs = Object.assign({ product_tag: options.product || ((_c = this.currentContext) === null || _c === void 0 ? void 0 : _c.product) || '', workspace_id: ((_d = this.config) === null || _d === void 0 ? void 0 : _d.workspace_id) || '', env: envValue, app_env: envValue, process_id, type: logs_types_1.LogEventTypes.DATABASE, parent_tag: databaseValue, child_tag: 'update', data: {
-                table: options.table,
-                operation: 'update',
-                database: databaseValue,
-                env: envValue,
-                where: options.where,
-                data: options.data,
-                returning: options.returning,
-            } }, sessionLogFields);
-        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { start, 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;
-            }
-            await this.ensureAdapterFor(resolvedOptions);
-            const adapter = this.getAdapter(resolvedOptions);
-            const result = await adapter.update(Object.assign(Object.assign({}, resolvedOptions), { data: processedData }));
-            const end = Date.now();
-            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Database update - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Database update - failed', failed_execution: true, data: { table: options.table, operation: 'update', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.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, _g, _h, _j;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        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, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await builder.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new Error(`Session validation failed: ${sessionResult.error}`);
-                }
-                resolvedOptions = sessionResult.input;
-                sessionLogFields = sessionResult.logFields;
-            }
-        }
-        const envValue = options.env || ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.env) || '';
-        const databaseValue = options.database || ((_b = this.currentContext) === null || _b === void 0 ? void 0 : _b.database) || '';
-        const baseLogs = Object.assign({ product_tag: options.product || ((_c = this.currentContext) === null || _c === void 0 ? void 0 : _c.product) || '', workspace_id: ((_d = this.config) === null || _d === void 0 ? void 0 : _d.workspace_id) || '', env: envValue, app_env: envValue, process_id, type: logs_types_1.LogEventTypes.DATABASE, parent_tag: databaseValue, child_tag: 'delete', data: {
-                table: options.table,
-                operation: 'delete',
-                database: databaseValue,
-                env: envValue,
-                where: options.where,
-            } }, sessionLogFields);
-        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Database delete - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        try {
-            await this.ensureAdapterFor(resolvedOptions);
-            const adapter = this.getAdapter(resolvedOptions);
-            const result = await adapter.delete(resolvedOptions);
-            const end = Date.now();
-            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Database delete - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Database delete - failed', failed_execution: true, data: { table: options.table, operation: 'delete', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.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, _g, _h, _j;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        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, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await builder.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new Error(`Session validation failed: ${sessionResult.error}`);
-                }
-                resolvedOptions = sessionResult.input;
-                sessionLogFields = sessionResult.logFields;
-            }
-        }
-        const envValue = options.env || ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.env) || '';
-        const databaseValue = options.database || ((_b = this.currentContext) === null || _b === void 0 ? void 0 : _b.database) || '';
-        const baseLogs = Object.assign({ product_tag: options.product || ((_c = this.currentContext) === null || _c === void 0 ? void 0 : _c.product) || '', workspace_id: ((_d = this.config) === null || _d === void 0 ? void 0 : _d.workspace_id) || '', env: envValue, app_env: envValue, process_id, type: logs_types_1.LogEventTypes.DATABASE, parent_tag: databaseValue, child_tag: 'upsert', data: {
-                table: options.table,
-                operation: 'upsert',
-                database: databaseValue,
-                env: envValue,
-                data: options.data,
-                conflictKeys: options.conflictKeys,
-                updateColumns: options.updateColumns,
-                returning: options.returning,
-            } }, sessionLogFields);
-        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Database upsert - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        try {
-            await this.ensureAdapterFor(resolvedOptions);
-            const adapter = this.getAdapter(resolvedOptions);
-            const result = await adapter.upsert(resolvedOptions);
-            const end = Date.now();
-            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Database upsert - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Database upsert - failed', failed_execution: true, data: { table: options.table, operation: 'upsert', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish());
-            throw error;
-        }
-    }
-    // ==================== AGGREGATION OPERATIONS ====================
-    /**
-     * Count records
-     *
-     * @example
-     * const count = await ductape.database.count({
-     *   table: 'users',
-     *   where: { status: 'active' },
-     * });
-     */
-    async count(options) {
-        await this.ensureAdapterFor(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) {
-        await this.ensureAdapterFor(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) {
-        await this.ensureAdapterFor(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) {
-        await this.ensureAdapterFor(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) {
-        await this.ensureAdapterFor(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) {
-        await this.ensureAdapterFor(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) {
-        await this.ensureAdapterFor(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) {
-        await this.ensureAdapterFor(options);
-        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) {
-        await this.ensureAdapterFor(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 connConfig = connectionConfigOrDefinition;
-        await this.ensureAdapterFor(connConfig);
-        const adapter = this.getAdapter(connConfig);
-        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 connConfig = connectionConfigOrTableName;
-        await this.ensureAdapterFor(connConfig);
-        const adapter = this.getAdapter(connConfig);
-        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 connConfig = connectionConfigOrTableName;
-        await this.ensureAdapterFor(connConfig);
-        const adapter = this.getAdapter(connConfig);
-        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) {
-        if (connectionConfig)
-            await this.ensureAdapterFor(connectionConfig);
-        const adapter = this.getAdapter(connectionConfig);
-        return adapter.listTables();
-    }
-    /**
-     * List all tables with basic information including estimated row counts
-     *
-     * @example
-     * const tables = await ductape.database.listTablesWithInfo({
-     *   env: 'dev',
-     *   product: 'my-app',
-     *   database: 'main-db',
-     * });
-     * // Returns: [{ name: 'users', estimatedRowCount: 1247, schema: 'public' }, ...]
-     */
-    async listTablesWithInfo(connectionConfig) {
-        if (connectionConfig)
-            await this.ensureAdapterFor(connectionConfig);
-        const adapter = this.getAdapter(connectionConfig);
-        return adapter.listTablesWithInfo();
-    }
-    /**
-     * 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 connConfig = connectionConfigOrTableName;
-        await this.ensureAdapterFor(connConfig);
-        const adapter = this.getAdapter(connConfig);
-        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 connConfig = connectionConfigOrTableName;
-        await this.ensureAdapterFor(connConfig);
-        const adapter = this.getAdapter(connConfig);
-        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) {
-        await this.ensureAdapterFor(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) {
-        await this.ensureAdapterFor(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) {
-        await this.ensureAdapterFor(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) {
-        await this.ensureAdapterFor(connectionConfig);
-        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)();
-        const start = Date.now();
-        // 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, {
-                        fetchSessionSelector: async (sessionTag) => {
-                            const sessionConfig = await builder.fetchSession(sessionTag);
-                            return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                        },
-                    });
-                    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), { start, message: 'Database action execute - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        try {
-            const result = await this.actionManager.execute(resolvedOptions);
-            const end = Date.now();
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, 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) {
-            const end = Date.now();
-            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, 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 start = Date.now();
-        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), { start, 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)();
-            const end = Date.now();
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, 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) {
-            const end = Date.now();
-            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, 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;
-    }
-    /**
-     * Ensure an adapter exists for the given database/env/product (connect on demand).
-     * Use before getAdapter() when options include database+env+product (e.g. from proxy).
-     */
-    async ensureAdapterFor(options) {
-        if (!(options === null || options === void 0 ? void 0 : options.database) || !(options === null || options === void 0 ? void 0 : options.env) || !(options === null || options === void 0 ? void 0 : options.product))
-            return;
-        const contextKey = this.buildContextKey(options.database, options.env);
-        const existing = this.adapters.get(contextKey);
-        if (existing && typeof existing.isConnected === 'function' && existing.isConnected())
-            return;
-        await this.connect({ database: options.database, env: options.env, product: options.product });
-    }
-    /**
-     * 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 types
-            'String': 'string',
-            // Numeric types
-            'Number': 'double', // JS number is 64-bit float
-            'Integer': 'integer', // 32-bit signed integer
-            'BigInt': 'bigint', // 64-bit signed integer
-            'Float': 'float', // 32-bit floating point
-            'Double': 'double', // 64-bit floating point
-            'Decimal': 'decimal', // Exact precision (for money)
-            // Other types
-            '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;
-    }
-    // ==================== DASHBOARD ====================
-    /**
-     * Fetch database dashboard metrics from logs
-     *
-     * @example
-     * ```ts
-     * const dashboard = await databases.fetchDashboard({
-     *   product: 'my-product',
-     *   database: 'my-database',
-     *   env: 'production',
-     * });
-     * console.log(dashboard.dau, dashboard.activityTimeline);
-     * ```
-     */
-    async fetchDashboard(options) {
-        if (!this.config) {
-            throw new database_error_1.DatabaseError('DatabaseService not configured. Please provide config when initializing.', enums_1.DatabaseErrorType.CONFIGURATION_ERROR);
-        }
-        const { product, database, env } = options;
-        const { LogApiService } = await Promise.resolve().then(() => __importStar(require('../api/services/logsApi.service')));
-        const logsApi = new LogApiService(this.config.env_type);
-        try {
-            const dashboard = await logsApi.fetchDatabaseDashboard({
-                product_tag: product,
-                database_tag: database,
-                env,
-            }, {
-                workspace_id: this.config.workspace_id,
-                user_id: this.config.user_id,
-                public_key: this.config.public_key,
-                token: this.config.token,
-            });
-            return {
-                dau: dashboard.dau || { current: 0, previous: 0, change: 0 },
-                wau: dashboard.wau || { current: 0, previous: 0, change: 0 },
-                mau: dashboard.mau || { current: 0, previous: 0, change: 0 },
-                totalOperations: dashboard.totalOperations || 0,
-                successfulOperations: dashboard.successfulOperations || 0,
-                failedOperations: dashboard.failedOperations || 0,
-                newOperationsThisWeek: dashboard.newOperationsThisWeek || 0,
-                avgExecutionTime: dashboard.avgExecutionTime || { current: '0ms', previous: '0ms', change: 0 },
-                activityTimeline: dashboard.activityTimeline || [],
-                peakHours: dashboard.peakHours || [],
-                environmentBreakdown: dashboard.environmentBreakdown || [],
-                methodBreakdown: dashboard.methodBreakdown || [],
-            };
-        }
-        catch (error) {
-            throw new database_error_1.DatabaseError(`Failed to fetch database dashboard: ${error}`, enums_1.DatabaseErrorType.QUERY_ERROR);
-        }
-    }
-}
-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