@adminide-stack/marketplace-module-server 12.0.4-alpha.95 → 13.0.1-alpha.0

package/lib/services/installed-extension-service-ext.js

@@ -1,10 +1,61 @@
-import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import'@cdm-logger/core';import {SERVER_TYPES,ConfigurationSchemaId,ContributionRegistryServiceEvent,MoleculerServiceName,SystemContributionExtensionNames,ExtensionServiceAction}from'common/server';import {InstalledExtensionService}from'./installed-extension-service.js';/**
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import'@cdm-logger/core';import {SERVER_TYPES,ContributionFragmentName,ConfigurationSchemaId,SystemContributionExtensionNames,ExtensionServiceAction,MoleculerServiceName}from'common/server';import {InstalledExtensionService}from'./installed-extension-service.js';/**
+ * Convert scope string values from package.json to ConfigurationScope enum numbers
+ * Maps: "application" -> 1, "machine" -> 2, "window" -> 3, "resource" -> 4
+ */
+function convertScopeStringToNumber(scope) {
+  if (typeof scope === 'number') {
+    return scope; // Already a number
+  }
+  if (typeof scope === 'string') {
+    const scopeMap = {
+      application: 1 /* ConfigurationScope.APPLICATION */,
+      machine: 2 /* ConfigurationScope.MACHINE */,
+      window: 3 /* ConfigurationScope.WINDOW */,
+      resource: 4 /* ConfigurationScope.RESOURCE */
+    };
+    const normalizedScope = scope.toLowerCase();
+    if (normalizedScope in scopeMap) {
+      return scopeMap[normalizedScope];
+    }
+    console.warn(`Unknown scope string: "${scope}", defaulting to WINDOW`);
+  }
+  // Default to WINDOW scope if undefined or unknown
+  return 3 /* ConfigurationScope.WINDOW */;
+}
+/**
+ * Recursively process configuration properties to convert scope strings to numbers
+ */
+function processConfigurationProperties(properties) {
+  if (!properties || typeof properties !== 'object') {
+    return properties;
+  }
+  const processedProperties = {
+    ...properties
+  };
+  for (const [key, value] of Object.entries(processedProperties)) {
+    if (value && typeof value === 'object') {
+      const objectValue = value;
+      // If this property has a scope, convert it
+      if ('scope' in objectValue) {
+        objectValue.scope = convertScopeStringToNumber(objectValue.scope);
+      }
+      // Recursively process nested properties
+      processedProperties[key] = processConfigurationProperties(objectValue);
+    }
+  }
+  return processedProperties;
+}
+/**
  * Extended InstalledExtensionService that handles Moleculer event broadcasting
  * Follows the pattern of AccountService/AccountServiceExt
  */
 let InstalledExtensionServiceExt = class InstalledExtensionServiceExt extends InstalledExtensionService {
-  constructor(repository, registryService, broker, logger) {
-    super(repository, registryService, broker, logger);
+  slugService;
+  redisCacheManager;
+  constructor(repository, registryService, slugService, redisCacheManager, broker, logger) {
+    super(repository, registryService, slugService, broker, logger);
+    this.slugService = slugService;
+    this.redisCacheManager = redisCacheManager;
     this.setupEventListeners();
   }
   setupEventListeners() {
@@ -16,24 +67,20 @@ let InstalledExtensionServiceExt = class InstalledExtensionServiceExt extends In
         const registryExtension = await this.registryExtensionService.findExtension(event.extensionSlug);
         let configurationNodes = [];
         let configurationDefaults = [];
-        if (registryExtension && registryExtension.manifest) {
-          console.log('Extension found with manifest:', event.extensionSlug);
-          console.log('Manifest object keys:', Object.keys(registryExtension.manifest));
-          // The manifest is now properly parsed by the model's virtual property
-          let contributes = null;
-          // Check if manifest has contributes directly (cast to access contributes property)
-          const manifestAny = registryExtension.manifest;
-          if (manifestAny.contributes) {
-            contributes = manifestAny.contributes;
-            console.log('Found parsed contributes:', Object.keys(contributes));
-          }
-          // Fallback: try to parse raw if contributes not found but raw exists
-          else if (registryExtension.manifest.raw) {
+        if (registryExtension) {
+          console.log('Extension found:', event.extensionSlug);
+          // Get the current release to access the manifest
+          // The manifest is stored in the release, not directly in the registry extension
+          const currentRelease = registryExtension.releases?.find(release => release.version === registryExtension.version);
+          if (currentRelease && currentRelease.manifest) {
+            console.log('Found current release with manifest:', registryExtension.version);
+            let contributes = null;
+            let parsedManifest = null;
             try {
-              const parsedManifest = JSON.parse(registryExtension.manifest.raw);
+              // Parse the manifest from the release (stored as JSON string)
+              parsedManifest = typeof currentRelease.manifest === 'string' ? JSON.parse(currentRelease.manifest) : currentRelease.manifest;
               console.log('Parsed manifest keys:', Object.keys(parsedManifest));
               contributes = parsedManifest.contributes;
-              console.log('Parsed contributes from manifest.raw:', contributes ? 'found' : 'not found');
               if (contributes) {
                 console.log('Contributes keys:', Object.keys(contributes));
                 console.log('Configuration exists:', !!contributes.configuration);
@@ -42,68 +89,78 @@ let InstalledExtensionServiceExt = class InstalledExtensionServiceExt extends In
                 }
               }
             } catch (error) {
-              console.warn('Failed to parse extension manifest.raw:', error);
+              console.warn('Failed to parse release manifest:', error);
             }
-          } else {
-            console.log('No manifest.raw found');
-          }
-          // Extract configuration contributions if they exist
-          if (contributes && contributes.configuration) {
-            console.log('Configuration contributions found, processing...');
-            const configurations = Array.isArray(contributes.configuration) ? contributes.configuration : [contributes.configuration];
-            // Format contributions for configuration registry
-            configurationNodes = configurations.map(config => ({
-              id: `${event.extensionSlug}`,
-              title: config.title || registryExtension.name,
-              description: config.description || registryExtension.manifest.description,
-              properties: config.properties || {},
-              type: config.type || ['object'],
-              scope: 'WINDOW',
-              // Default scope
-              extensionInfo: {
-                id: event.extensionSlug,
-                displayName: registryExtension.name
+            // Extract configuration contributions if they exist
+            if (contributes && contributes.configuration) {
+              console.log('Configuration contributions found, processing...');
+              const configurations = Array.isArray(contributes.configuration) ? contributes.configuration : [contributes.configuration];
+              // Format contributions for configuration registry
+              configurationNodes = configurations.map(config => {
+                // Process properties to convert scope strings to numbers
+                const processedProperties = processConfigurationProperties(config.properties || {});
+                return {
+                  id: ContributionFragmentName.Settings,
+                  title: config.title || registryExtension.name,
+                  description: config.description,
+                  properties: processedProperties,
+                  type: config.type || ['object']
+                };
+              });
+              // Create configuration defaults
+              configurationDefaults = [{
+                source: {
+                  id: event.extensionSlug,
+                  displayName: registryExtension.name
+                },
+                overrides: {} // Default empty overrides
+              }];
+              console.log(`Processed ${configurationNodes.length} configuration nodes`);
+            } else {
+              console.log('No configuration contributions found in manifest');
+            }
+            console.log('CONTRIBUTES========>', JSON.stringify(contributes));
+            // Extract UILayout contributions if they exist (same structure as configuration)
+            if (contributes && contributes.uiLayout) {
+              console.log('UILayout contributions found, processing...');
+              const uiLayoutContributions = Array.isArray(contributes.uiLayout) ? contributes.uiLayout : [contributes.uiLayout];
+              console.log(`Found ${uiLayoutContributions.length} UILayout contribution(s) in manifest`);
+              // Format UILayout contributions (same structure as configuration)
+              const uiLayoutNodes = uiLayoutContributions.map(uiLayout => {
+                // Process properties to convert scope strings to numbers (same as configuration)
+                const processedProperties = processConfigurationProperties(uiLayout.properties || {});
+                return {
+                  id: ContributionFragmentName.Settings,
+                  title: uiLayout.title || registryExtension.name,
+                  description: uiLayout.description,
+                  properties: processedProperties,
+                  type: uiLayout.type || ['object']
+                };
+              });
+              if (uiLayoutNodes.length > 0) {
+                console.log(`Registering ${uiLayoutNodes.length} UILayout configuration nodes`);
+                try {
+                  // Register UILayout contributions (exact same as configuration, just different schema)
+                  await this.broker.call('ConfigurationRegistryService.registerUILayoutContributions', {
+                    tenantId: event.tenantId,
+                    extensionID: event.extensionSlug,
+                    uiLayoutNodes
+                  });
+                  console.log(`✅ UILayout contributions registered successfully for ${event.extensionSlug}`);
+                } catch (uiLayoutError) {
+                  console.error('❌ Failed to register UILayout contributions:', uiLayoutError);
+                  // This is not fatal, log and continue
+                }
               }
-            }));
-            // Create configuration defaults
-            configurationDefaults = [{
-              source: {
-                id: event.extensionSlug,
-                displayName: registryExtension.name
-              },
-              overrides: {} // Default empty overrides
-            }];
-            console.log(`Processed ${configurationNodes.length} configuration nodes`);
+            } else {
+              console.log('No UILayout contributions found in manifest');
+            }
           } else {
-            console.log('No configuration contributions found in manifest');
+            console.log('No current release or manifest found for version:', registryExtension.version);
           }
         } else {
-          console.log('No extension or manifest found for:', event.extensionSlug);
+          console.log('No extension found for:', event.extensionSlug);
         }
-        // Add the extension's enabled/disabled state to configuration nodes
-        // This tracks the extension status regardless of whether it has configuration contributions
-        const extensionStatusNode = {
-          id: `${event.extensionSlug}.status`,
-          title: `${registryExtension?.name || event.extensionSlug} Status`,
-          description: `Extension enabled/disabled status for ${event.extensionSlug}`,
-          properties: {
-            [`extensions.${event.extensionSlug}`]: {
-              type: 'boolean',
-              default: true,
-              // Default to enabled when installed
-              description: `Enable/disable ${event.extensionSlug} extension`,
-              scope: 'window'
-            }
-          },
-          type: ['object'],
-          scope: 3 /* ConfigurationScope.WINDOW */,
-          extensionInfo: {
-            id: event.extensionSlug,
-            displayName: registryExtension?.name || event.extensionSlug
-          }
-        };
-        // Add the extension status node to configurationNodes
-        // configurationNodes.push(extensionStatusNode);
         // Create the configuration node data that configuration registry expects
         const configurationNode = {
           schemaId: ConfigurationSchemaId.Configuration,
@@ -127,67 +184,224 @@ let InstalledExtensionServiceExt = class InstalledExtensionServiceExt extends In
           },
           context
         });
-        this.broker.broadcast(ContributionRegistryServiceEvent.ContributionNodeRegistryAdd, {
-          configurationNode,
-          context,
-          timestamp: new Date()
-        }, [MoleculerServiceName.ConfigurationRegistryService
-        // MoleculerServiceName.MailService, // Using MailService instead of NotificationService
-        ]);
-        // Create separate configuration node for system extension status
-        const systemExtensionNode = {
-          schemaId: ConfigurationSchemaId.Configuration,
-          tenantId: event.tenantId,
-          extensionName: SystemContributionExtensionNames.SystemExtension,
-          policyConfigs: null,
-          configurationNodes: [extensionStatusNode]
-        };
+        // STEP 1: MANDATORY - Register extension in system_extension FIRST (REQUIRED FOR ALL EXTENSIONS)
+        console.log('\n🔧 STEP 1: Registering extension in SYSTEM_EXTENSION (MANDATORY)');
         const systemContext = {
           schemaId: ConfigurationSchemaId.Configuration,
           tenantId: event.tenantId,
           extensionName: SystemContributionExtensionNames.SystemExtension,
           accountId: event.installedBy
         };
-        this.broker.broadcast(ContributionRegistryServiceEvent.ContributionNodeRegistryAdd, {
-          configurationNode: systemExtensionNode,
-          context: systemContext,
-          timestamp: new Date()
-        }, [MoleculerServiceName.ConfigurationRegistryService
-        // MoleculerServiceName.MailService, // Using MailService instead of NotificationService
-        ]);
+        let systemExtensionRegistered = false;
+        try {
+          console.log('Fetching current system_extension document...');
+          // Get existing system_extension document
+          const existingSystemDoc = await this.broker.call('ConfigurationRegistryService.getConfigurationNodeRegistry', {
+            context: systemContext
+          });
+          // Prepare the merged configuration node
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const mergedNode = {
+            id: ContributionFragmentName.Settings,
+            type: ['object'],
+            properties: {},
+            restrictedProperties: []
+          };
+          // If document exists, merge existing properties
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          if (existingSystemDoc && existingSystemDoc.configurationNodes) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const existingNodes = existingSystemDoc.configurationNodes || [];
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const existingSettingsNode = existingNodes.find(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            node => node.id === ContributionFragmentName.Settings);
+            if (existingSettingsNode?.properties) {
+              mergedNode.properties = {
+                ...existingSettingsNode.properties
+              };
+              const existingCount = Object.keys(existingSettingsNode.properties).length;
+              console.log(`📝 Merging with ${existingCount} existing properties`);
+            }
+          } else {
+            console.log('📝 Creating new system_extension document');
+          }
+          // Add/update the property for this extension
+          mergedNode.properties[`extensions.${event.extensionSlug}`] = {
+            type: 'boolean',
+            default: true,
+            description: `Enable/disable ${event.extensionSlug} extension`,
+            scope: 3 /* ConfigurationScope.WINDOW */
+          };
+          // Prepare final data
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const finalSystemExtensionNode = {
+            schemaId: ConfigurationSchemaId.Configuration,
+            tenantId: event.tenantId,
+            extensionName: SystemContributionExtensionNames.SystemExtension,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            policyConfigs: existingSystemDoc?.policyConfigs || null,
+            configurationNodes: [mergedNode],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            configurationDefaults: existingSystemDoc?.configurationDefaults || []
+          };
+          // Use update if exists, create if new
+          const serviceMethod = existingSystemDoc ? 'ConfigurationRegistryService.updateConfigurationNodeRegistry' : 'ConfigurationRegistryService.createConfigurationNodeRegistry';
+          await this.broker.call(serviceMethod, {
+            data: finalSystemExtensionNode,
+            context: systemContext
+          });
+          systemExtensionRegistered = true;
+          const totalExtensions = Object.keys(mergedNode.properties).length;
+          console.log(`✅ STEP 1 SUCCESS: Extension registered (total: ${totalExtensions} extensions)`);
+        } catch (systemError) {
+          console.error('❌ STEP 1 FAILED: System extension registration failed:', systemError);
+          throw new Error(`Extension installation failed: Could not register in system (${systemError.message})`);
+        }
+        // STEP 2: CONDITIONAL - Create extension configuration ONLY IF CONTRIBUTIONS EXIST
+        let extensionConfigCreated = false;
+        if (configurationNodes.length > 0) {
+          console.log('\n📝 STEP 2: Creating extension configuration (contributions exist)');
+          try {
+            console.log('Broadcasting extension configuration registry...');
+            await this.broker.call('ConfigurationRegistryService.createConfigurationNodeRegistry', {
+              data: configurationNode,
+              context
+            });
+            extensionConfigCreated = true;
+            console.log('✅ STEP 2 SUCCESS: Extension configuration created');
+          } catch (configError) {
+            console.error('❌ STEP 2 FAILED: Extension configuration creation failed:', configError);
+            // This is not fatal since system extension is already registered
+            console.warn('⚠️ Extension is registered in system but configuration creation failed');
+          }
+        } else {
+          console.log('\nℹ️ STEP 2: Skipping extension configuration (no contributions found)');
+        }
+        await this.dropCache();
+        console.log('\n=== EXTENSION INSTALLATION COMPLETED ===');
+        console.log('System Extension Registered:', systemExtensionRegistered ? '✅' : '❌');
+        console.log('Extension Config Created:', extensionConfigCreated ? '✅' : 'ℹ️ Not needed');
+        console.log('Overall Installation:', systemExtensionRegistered ? '✅ SUCCESS' : '❌ FAILED');
       } catch (error) {
         console.error('Error processing extension installed event:', error);
       }
     });
     // Listen to extension uninstalled events
     this.onExtensionUninstalled.event(async event => {
+      console.log('=== EXTENSION UNINSTALLATION STARTED ===');
+      console.log('Extension slug:', event.extensionSlug);
+      console.log('Tenant:', event.tenantId);
+      let uninstallationSuccessful = false;
+      let extensionConfigRemoved = false;
+      let systemExtensionUpdated = false;
       try {
-        // Remove extension status from configuration registry
+        // STEP 1: Remove the extension's own configuration registry entry (if it exists)
+        console.log('\n🗑️ STEP 1: Removing extension configuration registry');
         const context = {
           schemaId: ConfigurationSchemaId.Configuration,
           tenantId: event.tenantId,
           extensionName: event.extensionSlug,
           accountId: event.uninstalledBy
         };
-        // Remove the extension's own configuration registry entry
-        this.broker.broadcast(ContributionRegistryServiceEvent.ContributionNodeRegistryRemove, {
-          context,
-          timestamp: new Date()
-        }, [MoleculerServiceName.ConfigurationRegistryService]);
-        // Remove the extension status from system extensions
-        const systemContext = {
-          schemaId: ConfigurationSchemaId.Configuration,
-          tenantId: event.tenantId,
-          extensionName: SystemContributionExtensionNames.SystemExtension,
-          accountId: event.uninstalledBy
-        };
-        this.broker.broadcast(ContributionRegistryServiceEvent.ContributionNodeRegistryRemove, {
-          context: systemContext,
-          timestamp: new Date()
-        }, [MoleculerServiceName.ConfigurationRegistryService]);
+        try {
+          console.log('Removing extension configuration document...');
+          await this.broker.call('ConfigurationRegistryService.removeConfigurationNodeRegistry', {
+            context
+          });
+          extensionConfigRemoved = true;
+          console.log('✅ STEP 1 SUCCESS: Extension configuration removed');
+        } catch (configError) {
+          console.warn('⚠️ STEP 1 WARNING: Extension configuration removal failed (may not exist):', configError);
+          // This is not fatal - extension might not have had configuration
+        }
+        // STEP 1.5: Remove UILayout contributions (if any exist)
+        console.log('\n🗑️ STEP 1.5: Removing UILayout contributions (if exist)');
+        try {
+          console.log('Attempting to remove UILayout contributions...');
+          await this.broker.call('ConfigurationRegistryService.removeUILayoutContributions', {
+            tenantId: event.tenantId,
+            extensionID: event.extensionSlug
+          });
+          console.log('✅ STEP 1.5 SUCCESS: UILayout contributions removed');
+        } catch (uiLayoutError) {
+          console.warn('⚠️ STEP 1.5 WARNING: UILayout contributions removal failed (may not exist):', uiLayoutError);
+          // This is not fatal - extension might not have had UILayout contributions
+        }
+        // STEP 2: MANDATORY - Remove extension node from system_extension document
+        console.log('\n🔧 STEP 2: Unregistering extension from SYSTEM_EXTENSION (MANDATORY)');
+        try {
+          // First, get the current system_extension document
+          const systemContext = {
+            schemaId: ConfigurationSchemaId.Configuration,
+            tenantId: event.tenantId,
+            extensionName: SystemContributionExtensionNames.SystemExtension,
+            accountId: event.uninstalledBy
+          };
+          console.log('Fetching current system_extension document...');
+          const currentSystemDoc = await this.broker.call('ConfigurationRegistryService.getConfigurationNodeRegistry', {
+            context: systemContext
+          });
+          if (currentSystemDoc && currentSystemDoc.configurationNodes) {
+            const systemDoc = currentSystemDoc;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const configurationNodes = systemDoc.configurationNodes;
+            // Find the settings node and remove the extension property
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const settingsNode = configurationNodes.find(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            node => node.id === ContributionFragmentName.Settings);
+            if (settingsNode?.properties) {
+              const propertyKey = `extensions.${event.extensionSlug}`;
+              delete settingsNode.properties[propertyKey];
+              console.log(`Removing extension property: ${propertyKey}`);
+              console.log(`Remaining properties: ${Object.keys(settingsNode.properties).length}`);
+            }
+            const updatedConfigurationNodes = configurationNodes;
+            // Update the system_extension document with the updated nodes
+            const updatedSystemExtensionNode = {
+              schemaId: ConfigurationSchemaId.Configuration,
+              tenantId: event.tenantId,
+              extensionName: SystemContributionExtensionNames.SystemExtension,
+              policyConfigs: systemDoc.policyConfigs || null,
+              configurationNodes: updatedConfigurationNodes,
+              configurationDefaults: systemDoc.configurationDefaults || []
+            };
+            console.log('Updating system_extension document...');
+            await this.broker.call('ConfigurationRegistryService.updateConfigurationNodeRegistry', {
+              data: updatedSystemExtensionNode,
+              context: systemContext
+            });
+            systemExtensionUpdated = true;
+            console.log('✅ STEP 2 SUCCESS: Extension unregistered from system_extension');
+          } else {
+            console.warn('⚠️ STEP 2 WARNING: No system_extension document found or no configuration nodes');
+            systemExtensionUpdated = true; // Consider it successful if document doesn't exist
+          }
+        } catch (systemError) {
+          console.error('❌ STEP 2 FAILED: System extension unregistration failed:', systemError);
+          throw new Error(`Extension uninstallation failed: Could not unregister from system (${systemError.message})`);
+        }
+        // Uninstallation is successful if system extension is updated
+        uninstallationSuccessful = systemExtensionUpdated;
+        await this.dropCache();
+        console.log('\n=== EXTENSION UNINSTALLATION COMPLETED ===');
+        console.log('Extension Config Removed:', extensionConfigRemoved ? '✅' : 'ℹ️ Not found');
+        console.log('System Extension Updated:', systemExtensionUpdated ? '✅' : '❌');
+        console.log('Overall Uninstallation:', uninstallationSuccessful ? '✅ SUCCESS' : '❌ FAILED');
       } catch (error) {
-        console.error('Error processing extension uninstalled event:', error);
+        console.error('❌ EXTENSION UNINSTALLATION FAILED:', error);
+        console.error('Error details:', {
+          message: error.message,
+          stack: error.stack,
+          extensionSlug: event.extensionSlug,
+          tenantId: event.tenantId,
+          extensionConfigRemoved,
+          systemExtensionUpdated
+        });
+        throw error; // Re-throw to ensure calling code knows uninstallation failed
       }
+      // Notify other services about the uninstallation
       this.broker.broadcast(ExtensionServiceAction.OnExtensionUninstalled, {
         event
       }, [MoleculerServiceName.ConfigurationService, 'WorkbenchService',
@@ -239,9 +453,9 @@ let InstalledExtensionServiceExt = class InstalledExtensionServiceExt extends In
       ]);
     });
     // Listen to extension cleanup completed events
-    this.onExtensionCleanupCompleted.event(event => {
+    this.onExtensionCleanupCompleted.event(e => {
       this.broker.broadcast(ExtensionServiceAction.OnExtensionCleanupCompleted, {
-        event
+        event: e
       }, [MoleculerServiceName.MailService // Using MailService instead of NotificationService
       ]);
     });
@@ -267,5 +481,38 @@ let InstalledExtensionServiceExt = class InstalledExtensionServiceExt extends In
       ]);
     });
   }
+  async dropCache() {
+    console.log('Start dropping GraphQL query cache keys');
+    try {
+      // Get Redis client from redisCacheManager
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const {
+        redisClient
+      } = this.redisCacheManager;
+      if (!redisClient) {
+        console.error('❌ Redis client not found in redisCacheManager');
+        return;
+      }
+      const appName = process.env.APP_NAME || 'adminide-stack';
+      // Only delete GraphQL query caches, not session/auth data
+      // These are the specific queries we want to invalidate
+      const queryPatterns = [`${appName}*pageSettings*`, `${appName}*GetPageSettings*`, `${appName}*CurrentPagePermissions*`, `${appName}*IntegrationConfigurations*`, `${appName}*ContributionRoles*`];
+      let totalDeleted = 0;
+      for (const pattern of queryPatterns) {
+        console.log(`🔍 Searching for keys matching: ${pattern}`);
+        const keys = await redisClient.keys(pattern);
+        if (keys.length > 0) {
+          console.log(`📋 Found ${keys.length} keys for pattern: ${pattern}`);
+          console.log(`📝 Sample keys:`, keys.slice(0, 3));
+          await redisClient.del(...keys);
+          totalDeleted += keys.length;
+        }
+      }
+      console.log(`✅ Successfully deleted ${totalDeleted} query cache keys`);
+    } catch (error) {
+      console.error('❌ Failed to drop cache:', error);
+      // Don't throw - cache clearing failure shouldn't break extension installation
+    }
+  }
 };
-InstalledExtensionServiceExt = __decorate([injectable(), __param(0, inject(SERVER_TYPES.IInstalledExtensionRepository)), __param(1, inject(SERVER_TYPES.IRegistryExtensionService)), __param(2, inject(CommonType.MOLECULER_BROKER)), __param(3, inject(CommonType.LOGGER)), __metadata("design:paramtypes", [Object, Object, ServiceBroker, Object])], InstalledExtensionServiceExt);export{InstalledExtensionServiceExt};//# sourceMappingURL=installed-extension-service-ext.js.map
+InstalledExtensionServiceExt = __decorate([injectable(), __param(0, inject(SERVER_TYPES.IInstalledExtensionRepository)), __param(1, inject(SERVER_TYPES.IRegistryExtensionService)), __param(2, inject(SERVER_TYPES.SlugService)), __param(3, inject(SERVER_TYPES.IRedisCacheManager)), __param(4, inject(CommonType.MOLECULER_BROKER)), __param(5, inject(CommonType.LOGGER)), __metadata("design:paramtypes", [Object, Object, Object, Object, ServiceBroker, Object])], InstalledExtensionServiceExt);export{InstalledExtensionServiceExt};//# sourceMappingURL=installed-extension-service-ext.js.map

package/lib/services/installed-extension-service-ext.js.map

@@ -1 +1 @@
-{"version":3,"file":"installed-extension-service-ext.js","sources":["../../src/services/installed-extension-service-ext.ts"],"sourcesContent":[null],"names":[],"mappings":"6bAkCG;AACH;AAG4D;AASxD;AAsTH,IAAA,4BAAA,GAAA,MAAA,4BAAA,SAAA,yBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"installed-extension-service-ext.js","sources":["../../src/services/installed-extension-service-ext.ts"],"sourcesContent":[null],"names":[],"mappings":"qbA4FG;AACH;;AAQQ;;AAQJ,EAAA,IAAA,OAAQ,KAAA,KAAA,QAAmB,EAAA;gBA6gBb,CAAA;AA8CjB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}