@ductape/sdk 0.0.6 → 0.0.7

package/dist/database/databases.service.js

@@ -67,6 +67,17 @@ 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
@@ -96,6 +107,8 @@ class DatabaseService {
         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();
@@ -597,25 +610,54 @@ class DatabaseService {
      * await db.triggers.create({ tag: 'my-trigger', ... });
      */
     async connect(config) {
-        var _a, _b, _c, _d, _e, _f;
+        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 not found locally, fetch from the remote API
         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);
             }
-            // Initialize product builder
             await this.getProductBuilder(config.product);
-            // Fetch the database config from the API (already decrypted)
             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);
             }
-            // Register the database locally (config is already decrypted from API)
             this.createAdapter({
                 tag: config.database,
                 name: dbConfig.name,
@@ -633,7 +675,109 @@ class DatabaseService {
         if (!adapter || !context) {
             throw new database_error_1.DatabaseError(`Failed to initialize adapter for ${contextKey}`, enums_1.DatabaseErrorType.CONNECTION_ERROR);
         }
-        // Initialize logging
+        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;
         this.initializeLogService();
         const envValue = config.env || '';
         const baseLogs = {
@@ -647,7 +791,13 @@ class DatabaseService {
             child_tag: 'connect',
             data: { database: config.database, env: envValue, operation: 'connect' },
         };
-        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Database connect - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        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;
@@ -669,17 +819,24 @@ class DatabaseService {
             context.product = config.product;
             this.currentContext = context;
             const end = Date.now();
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Database connect - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
-            // Return a DatabaseConnection object for scoped operations
+            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();
-            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.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 ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            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();
+            }
             throw new database_error_1.DatabaseError(`Failed to connect to database: ${error.message}`, enums_1.DatabaseErrorType.CONNECTION_ERROR, error);
         }
     }
@@ -731,12 +888,18 @@ class DatabaseService {
      * 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;
         }
@@ -748,12 +911,18 @@ class DatabaseService {
      * 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);