@ductape/sdk 0.0.4-v59 → 0.0.4-v60

package/dist/graph/graphs.service.js

@@ -91,6 +91,7 @@ class GraphService {
         this.adapterFactory = new adapter_factory_1.GraphAdapterFactory();
         if (config) {
             this.config = config;
+            this._privateKey = config.private_key || '';
             // Initialize CacheManager if Redis client is provided
             if (config.redis_client) {
                 this.cacheManager = new cache_manager_1.CacheManager({
@@ -131,6 +132,7 @@ class GraphService {
             user_id: this.config.user_id,
             token: this.config.token,
             env_type: this.config.env_type,
+            access_key: this.config.access_key,
         });
     }
     /**
@@ -180,6 +182,7 @@ class GraphService {
             user_id: this.config.user_id,
             token: this.config.token,
             env_type: this.config.env_type,
+            private_key: this._privateKey,
         });
     }
     // ==================== GRAPH REGISTRATION ====================
@@ -202,42 +205,106 @@ class GraphService {
      * ```
      */
     async create(graphConfig, productTag) {
-        var _a;
+        var _a, _b, _c;
+        console.log('[GraphService.create] Starting with config:', JSON.stringify({
+            name: graphConfig.name,
+            tag: graphConfig.tag,
+            type: graphConfig.type,
+            envs: (_a = graphConfig.envs) === null || _a === void 0 ? void 0 : _a.map(e => {
+                var _a;
+                return ({
+                    slug: e.slug,
+                    connection_url: ((_a = e.connection_url) === null || _a === void 0 ? void 0 : _a.substring(0, 30)) + '...',
+                    hasUsername: !!e.username,
+                    hasPassword: !!e.password,
+                    database: e.database,
+                    graphName: e.graphName,
+                });
+            }),
+        }, null, 2));
         // Validate required fields
-        if (!graphConfig.name || !graphConfig.tag || !graphConfig.type || !((_a = graphConfig.envs) === null || _a === void 0 ? void 0 : _a.length)) {
+        if (!graphConfig.name || !graphConfig.tag || !graphConfig.type || !((_b = graphConfig.envs) === null || _b === void 0 ? void 0 : _b.length)) {
             throw graph_error_1.GraphError.validationError('Graph configuration requires name, tag, type, and at least one environment');
         }
+        const exists = await this.fetchGraphFromProduct(productTag, graphConfig.tag);
+        if (exists) {
+            return;
+        }
         // Validate graph type
         if (!this.adapterFactory.isSupported(graphConfig.type)) {
             throw graph_error_1.GraphError.validationError(`Unsupported graph type: ${graphConfig.type}. ` +
                 `Supported types: ${this.adapterFactory.getSupportedTypes().join(', ')}`);
         }
+        // Process sensitive fields - store as secrets if not already secret references
+        const processedEnvs = [];
+        console.log('[GraphService.create] Secrets service available:', !!(0, secrets_1.getSecretsService)());
+        console.log('[GraphService.create] ProductTag:', productTag);
+        for (const env of graphConfig.envs) {
+            console.log(`[GraphService.create] Processing env '${env.slug}':`, {
+                hasConnectionUrl: !!env.connection_url,
+                hasGraphName: !!env.graphName,
+                hasRegion: !!env.region,
+                hasUsername: !!env.username,
+                hasPassword: !!env.password,
+            });
+            // Store all sensitive fields as secrets
+            const connectionUrl = productTag
+                ? await this.storeAsSecretIfNeeded(env.connection_url, productTag, graphConfig.tag, env.slug, 'url', `Graph connection URL for ${graphConfig.tag} in ${env.slug}`)
+                : env.connection_url;
+            const graphName = productTag
+                ? await this.storeAsSecretIfNeeded(env.graphName, productTag, graphConfig.tag, env.slug, 'graphName', `Graph name for ${graphConfig.tag} in ${env.slug}`)
+                : env.graphName;
+            const region = productTag
+                ? await this.storeAsSecretIfNeeded(env.region, productTag, graphConfig.tag, env.slug, 'region', `AWS region for ${graphConfig.tag} in ${env.slug}`)
+                : env.region;
+            const username = productTag
+                ? await this.storeAsSecretIfNeeded(env.username, productTag, graphConfig.tag, env.slug, 'username', `Username for ${graphConfig.tag} in ${env.slug}`)
+                : env.username;
+            const password = productTag
+                ? await this.storeAsSecretIfNeeded(env.password, productTag, graphConfig.tag, env.slug, 'password', `Password for ${graphConfig.tag} in ${env.slug}`)
+                : env.password;
+            processedEnvs.push(Object.assign(Object.assign({}, env), { connection_url: connectionUrl || env.connection_url, graphName,
+                region,
+                username,
+                password }));
+            console.log(`[GraphService.create] Processed env '${env.slug}' - secrets stored`);
+        }
         // If productTag is provided, use ProductBuilder to persist to backend
         if (productTag) {
+            console.log('[GraphService.create] Persisting to backend with productTag:', productTag);
             const builder = await this.getProductBuilder(productTag);
             const productGraph = {
                 name: graphConfig.name,
                 tag: graphConfig.tag,
                 description: graphConfig.description,
                 type: graphConfig.type,
-                envs: graphConfig.envs.map((env) => ({
+                envs: processedEnvs.map((env) => ({
                     slug: env.slug,
                     connection_url: env.connection_url,
                     description: env.description,
                     database: env.database,
                     graphName: env.graphName,
                     region: env.region,
+                    username: env.username,
+                    password: env.password,
                 })),
             };
             await builder.createGraph(productGraph);
         }
-        // Store locally
-        this.localConfigs.set(graphConfig.tag, graphConfig);
+        // Store locally with processed envs
+        const processedConfig = Object.assign(Object.assign({}, graphConfig), { envs: processedEnvs });
+        this.localConfigs.set(graphConfig.tag, processedConfig);
+        console.log('[GraphService.create] Stored in localConfigs');
         // Create adapters for each environment
-        for (const envConfig of graphConfig.envs) {
+        for (const envConfig of processedEnvs) {
             const contextKey = `${graphConfig.tag}:${envConfig.slug}`;
             const adapter = this.adapterFactory.create(graphConfig.type);
             this.adapters.set(contextKey, adapter);
+            console.log(`[GraphService.create] Creating context for ${contextKey}:`, {
+                hasUsername: !!envConfig.username,
+                hasPassword: !!envConfig.password,
+                connectionUrl: ((_c = envConfig.connection_url) === null || _c === void 0 ? void 0 : _c.substring(0, 30)) + '...',
+            });
             // Store connection context (not connected yet)
             this.connectionContexts.set(contextKey, {
                 graph: graphConfig.tag,
@@ -249,8 +316,83 @@ class GraphService {
                 description: graphConfig.description,
                 database: envConfig.database,
                 graphName: envConfig.graphName,
+                username: envConfig.username,
+                password: envConfig.password,
             });
         }
+        console.log('[GraphService.create] Completed successfully');
+    }
+    /**
+     * Generate a secret key for graph configuration field
+     * Format: GRAPH_{PRODUCT}_{ASSET_TAG}_{ENV}_{KEY}
+     *
+     * Where:
+     * - PRODUCT = productTag.split('.')[1] (second part after workspace)
+     * - ASSET_TAG = if graphTag starts with same workspace prefix, use second part; otherwise sanitize full tag
+     * - All parts are automatically capitalized
+     */
+    generateGraphSecretKey(productTag, graphTag, envSlug, field) {
+        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 = productTag.includes(':') ? productTag.split(':') : productTag.split('.');
+        const product = productParts[1] || productParts[0]; // Use product name (index 1), fallback to index 0
+        const workspace = productParts[0];
+        // Support both ':' and '.' delimiters for graph tags
+        const graphParts = graphTag.includes(':') ? graphTag.split(':') : graphTag.split('.');
+        let assetTag;
+        if (graphParts.length > 1 && graphParts[0] === workspace) {
+            // Same workspace prefix, use second part
+            assetTag = graphParts[1];
+        }
+        else {
+            // Different or no prefix, use full tag
+            assetTag = graphTag;
+        }
+        return `GRAPH_${sanitize(product)}_${sanitize(assetTag)}_${sanitize(envSlug)}_${sanitize(field)}`;
+    }
+    /**
+     * Store a value as a secret if it exists and is not already a secret reference
+     * @returns The secret reference if stored, or the original value
+     */
+    async storeAsSecretIfNeeded(value, productTag, graphTag, envSlug, fieldName, description) {
+        if (!value) {
+            return undefined;
+        }
+        const secretsService = (0, secrets_1.getSecretsService)();
+        const secretCheck = (0, secrets_1.isSecretReference)(value);
+        console.log(`[GraphService.storeAsSecretIfNeeded] Processing '${fieldName}' for env '${envSlug}':`, {
+            isSecretReference: secretCheck.isSecret,
+            hasValue: !!value,
+        });
+        // If not already a secret reference and we have a secrets service, store it as a secret
+        if (!secretCheck.isSecret && secretsService && productTag) {
+            const secretKey = this.generateGraphSecretKey(productTag, graphTag, envSlug, fieldName);
+            try {
+                const exists = await secretsService.exists(secretKey);
+                console.log(`[GraphService.storeAsSecretIfNeeded] Secret '${secretKey}' exists:`, exists);
+                if (exists) {
+                    await secretsService.update(secretKey, { value });
+                    console.log(`[GraphService.storeAsSecretIfNeeded] Updated existing secret '${secretKey}'`);
+                }
+                else {
+                    await secretsService.create({
+                        key: secretKey,
+                        value,
+                        description,
+                        scope: [productTag, graphTag],
+                        envs: [envSlug],
+                    });
+                    console.log(`[GraphService.storeAsSecretIfNeeded] Created new secret '${secretKey}'`);
+                }
+                return `$Secret{${secretKey}}`;
+            }
+            catch (error) {
+                console.warn(`[GraphService.storeAsSecretIfNeeded] Failed to store '${fieldName}' as secret: ${secretKey}`, error);
+                // Continue with the original value
+                return value;
+            }
+        }
+        return value;
     }
     /**
      * Fetch all registered graphs for a product
@@ -315,6 +457,8 @@ class GraphService {
                     database: env.database,
                     graphName: env.graphName,
                     region: env.region,
+                    username: env.username,
+                    password: env.password,
                 })),
             };
             await builder.updateGraph(graphTag, productGraphUpdates);
@@ -331,7 +475,7 @@ class GraphService {
                 const contextKey = `${graphTag}:${envConfig.slug}`;
                 const existingContext = this.connectionContexts.get(contextKey);
                 if (existingContext) {
-                    this.connectionContexts.set(contextKey, Object.assign(Object.assign({}, existingContext), { connectionUrl: envConfig.connection_url, database: envConfig.database, graphName: envConfig.graphName }));
+                    this.connectionContexts.set(contextKey, Object.assign(Object.assign({}, existingContext), { connectionUrl: envConfig.connection_url, database: envConfig.database, graphName: envConfig.graphName, username: envConfig.username, password: envConfig.password }));
                 }
             }
         }
@@ -394,6 +538,8 @@ class GraphService {
                 database: env.database,
                 graphName: env.graphName,
                 region: env.region,
+                username: env.username,
+                password: env.password,
             })),
         };
     }
@@ -412,19 +558,40 @@ class GraphService {
      * ```
      */
     async connect(config) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const process_id = (0, processor_utils_1.generateObjectId)();
         const contextKey = `${config.graph}:${config.env}`;
+        console.log('[GraphService.connect] Starting connection:', {
+            graph: config.graph,
+            env: config.env,
+            product: config.product,
+            contextKey,
+        });
         // Get adapter
         let adapter = this.adapters.get(contextKey);
         let context = this.connectionContexts.get(contextKey);
+        console.log('[GraphService.connect] Initial lookup:', {
+            hasAdapter: !!adapter,
+            hasContext: !!context,
+        });
         // If not locally registered, try to fetch from API
         if (!adapter || !context) {
+            console.log('[GraphService.connect] Not locally registered, fetching from API...');
             // Initialize product builder to get productId for logging
             if (config.product) {
                 await this.getProductBuilder(config.product);
             }
             const graphConfig = await this.fetchGraphFromProduct(config.product, config.graph);
+            console.log('[GraphService.connect] Fetched graph config:', graphConfig ? {
+                tag: graphConfig.tag,
+                type: graphConfig.type,
+                envsCount: (_a = graphConfig.envs) === null || _a === void 0 ? void 0 : _a.length,
+                envs: (_b = graphConfig.envs) === null || _b === void 0 ? void 0 : _b.map(e => ({
+                    slug: e.slug,
+                    hasUsername: !!e.username,
+                    hasPassword: !!e.password,
+                })),
+            } : null);
             if (!graphConfig) {
                 throw graph_error_1.GraphError.notFoundError(`Graph '${config.graph}' not found in product '${config.product}'`);
             }
@@ -436,40 +603,80 @@ class GraphService {
         if (!adapter || !context) {
             throw graph_error_1.GraphError.configurationError(`Failed to initialize adapter for ${contextKey}`);
         }
+        console.log('[GraphService.connect] Context loaded:', {
+            graph: context.graph,
+            env: context.env,
+            type: context.type,
+            hasUsername: !!context.username,
+            hasPassword: !!context.password,
+            connectionUrl: ((_c = context.connectionUrl) === null || _c === void 0 ? void 0 : _c.substring(0, 30)) + '...',
+        });
         // Initialize logging
         this.initializeLogService();
         const baseLogs = {
             product_tag: config.product || '',
-            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            workspace_id: ((_d = this.config) === null || _d === void 0 ? void 0 : _d.workspace_id) || '',
             env: config.env,
             process_id,
             type: logs_types_1.LogEventTypes.GRAPH,
             parent_tag: config.graph,
             data: { graph: config.graph, env: config.env },
         };
-        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph connect - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph connect - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
         try {
-            // Resolve secret references in connection URL
-            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 graph_error_1.GraphError.configurationError(`Connection URL contains secret reference '${connectionUrl}' but secrets service is not initialized. ` +
-                        `Please ensure the Ductape client is properly initialized.`);
+            // Resolve all secret references in the context
+            const secretsService = (0, secrets_1.getSecretsService)();
+            console.log('[GraphService.connect] Secrets service available:', !!secretsService);
+            // Helper function to resolve a value if it's a secret reference
+            const resolveSecret = async (value, fieldName) => {
+                if (!value)
+                    return undefined;
+                const secretCheck = (0, secrets_1.isSecretReference)(value);
+                console.log(`[GraphService.connect] Secret check for ${fieldName}:`, {
+                    isSecret: secretCheck.isSecret,
+                    secretKey: secretCheck.isSecret ? secretCheck.key : null,
+                });
+                if (secretCheck.isSecret) {
+                    if (secretsService) {
+                        console.log(`[GraphService.connect] Resolving secret for ${fieldName}:`, secretCheck.key);
+                        const resolved = await secretsService.resolve(value, { env: config.env });
+                        console.log(`[GraphService.connect] Secret resolved successfully for ${fieldName}`);
+                        return resolved.value;
+                    }
+                    else {
+                        throw graph_error_1.GraphError.configurationError(`${fieldName} contains secret reference '${value}' but secrets service is not initialized. ` +
+                            `Please ensure the Ductape client is properly initialized.`);
+                    }
                 }
+                return value;
+            };
+            // Resolve all sensitive fields
+            const connectionUrl = await resolveSecret(context.connectionUrl, 'connectionUrl');
+            const graphName = await resolveSecret(context.graphName, 'graphName');
+            const username = await resolveSecret(context.username, 'username');
+            const password = await resolveSecret(context.password, 'password');
+            if (!connectionUrl) {
+                throw graph_error_1.GraphError.configurationError('Connection URL is required');
             }
-            // Connect
+            // Connect with auth credentials if provided
+            const authConfig = username && password
+                ? { username, password }
+                : undefined;
+            console.log('[GraphService.connect] Calling adapter.connect with:', {
+                hasConnectionUrl: !!connectionUrl,
+                database: context.database,
+                graphName: graphName || context.graphName,
+                hasAuth: !!authConfig,
+                authUsername: (authConfig === null || authConfig === void 0 ? void 0 : authConfig.username) ? '***' : undefined,
+            });
             const result = await adapter.connect({
                 connectionUrl,
                 database: context.database,
-                graphName: context.graphName,
+                graphName: graphName || context.graphName,
                 options: config.options,
+                auth: authConfig,
             });
+            console.log('[GraphService.connect] Connection result:', result);
             // Update context
             context.connected = result.connected;
             context.product = config.product;
@@ -478,13 +685,13 @@ class GraphService {
             this.currentContext = context;
             // Initialize transaction manager
             this.transactionManager = new transaction_manager_1.GraphTransactionManager(adapter);
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph connect - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph connect - 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) {
-            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph connect - failed', failed_execution: true, data: { graph: config.graph, env: config.env, error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph connect - failed', failed_execution: true, data: { graph: config.graph, env: config.env, error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish());
             throw error;
         }
     }
@@ -503,6 +710,9 @@ class GraphService {
             database: context.database,
             graphName: context.graphName,
             options: config.options,
+            auth: context.username && context.password
+                ? { username: context.username, password: context.password }
+                : undefined,
         });
     }
     /**