@adminide-stack/marketplace-module-server 12.0.4-alpha.44 → 12.0.4-alpha.441

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

@@ -0,0 +1,518 @@
+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 {
+  slugService;
+  redisCacheManager;
+  constructor(repository, registryService, slugService, redisCacheManager, broker, logger) {
+    super(repository, registryService, slugService, broker, logger);
+    this.slugService = slugService;
+    this.redisCacheManager = redisCacheManager;
+    this.setupEventListeners();
+  }
+  setupEventListeners() {
+    // Listen to extension installed events
+    this.onExtensionInstalled.event(async event => {
+      console.log('_____>>>>>>> EXTENSION INSTALLLED EVENT IS GETTIN CALLED');
+      try {
+        // Get full extension data with metadata to extract contributions
+        const registryExtension = await this.registryExtensionService.findExtension(event.extensionSlug);
+        let configurationNodes = [];
+        let configurationDefaults = [];
+        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 {
+              // 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;
+              if (contributes) {
+                console.log('Contributes keys:', Object.keys(contributes));
+                console.log('Configuration exists:', !!contributes.configuration);
+                if (contributes.configuration) {
+                  console.log('Configuration data:', JSON.stringify(contributes.configuration, null, 2));
+                }
+              }
+            } catch (error) {
+              console.warn('Failed to parse release manifest:', error);
+            }
+            // 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
+                }
+              }
+            } else {
+              console.log('No UILayout contributions found in manifest');
+            }
+          } else {
+            console.log('No current release or manifest found for version:', registryExtension.version);
+          }
+        } else {
+          console.log('No extension found for:', event.extensionSlug);
+        }
+        // Create the configuration node data that configuration registry expects
+        const configurationNode = {
+          schemaId: ConfigurationSchemaId.Configuration,
+          tenantId: event.tenantId,
+          extensionName: event.extensionSlug,
+          policyConfigs: event.policies || null,
+          configurationNodes,
+          configurationDefaults
+        };
+        const context = {
+          schemaId: ConfigurationSchemaId.Configuration,
+          tenantId: event.tenantId,
+          extensionName: event.extensionSlug,
+          accountId: event.installedBy
+          // Add other context fields as needed
+        };
+        console.log('Broadcasting configuration registry event with data:', {
+          configurationNode: {
+            ...configurationNode,
+            configurationNodes: `${configurationNodes.length} nodes`
+          },
+          context
+        });
+        // 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
+        };
+        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 {
+        // 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
+        };
+        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('❌ 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',
+      // Using string literal as MoleculerServiceName.WorkbenchService doesn't exist
+      MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+    // Listen to extension enabled events
+    this.onExtensionEnabled.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionEnabled, {
+        event
+      }, [MoleculerServiceName.ConfigurationService, 'WorkbenchService' // Using string literal as MoleculerServiceName.WorkbenchService doesn't exist
+      ]);
+    });
+    // Listen to extension disabled events
+    this.onExtensionDisabled.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionDisabled, {
+        event
+      }, [MoleculerServiceName.ConfigurationService, 'WorkbenchService' // Using string literal as MoleculerServiceName.WorkbenchService doesn't exist
+      ]);
+    });
+    // Listen to extension updated events
+    this.onExtensionUpdated.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionUpdated, {
+        event
+      }, [MoleculerServiceName.ConfigurationService]);
+    });
+    // Listen to extension version updated events
+    this.onExtensionVersionUpdated.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionVersionUpdated, {
+        event
+      }, [MoleculerServiceName.ConfigurationService, 'WorkbenchService',
+      // Using string literal as MoleculerServiceName.WorkbenchService doesn't exist
+      MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+    // Listen to extension configuration updated events
+    this.onExtensionConfigurationUpdated.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionConfigurationUpdated, {
+        event
+      }, [MoleculerServiceName.ConfigurationService, 'WorkbenchService' // Using string literal as MoleculerServiceName.WorkbenchService doesn't exist
+      ]);
+    });
+    // Listen to extension sync completed events
+    this.onExtensionSyncCompleted.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionSyncCompleted, {
+        event
+      }, [MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+    // Listen to extension cleanup completed events
+    this.onExtensionCleanupCompleted.event(e => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionCleanupCompleted, {
+        event: e
+      }, [MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+    // Listen to extension activation failed events
+    this.onExtensionActivationFailed.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionActivationFailed, {
+        event
+      }, [MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+    // Listen to extension deprecated events
+    this.onExtensionDeprecated.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionDeprecated, {
+        event
+      }, [MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+    // Listen to extension orphaned events
+    this.onExtensionOrphaned.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionOrphaned, {
+        event
+      }, [MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+  }
+  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(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

@@ -0,0 +1 @@
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/services/installed-extension-service.d.ts

@@ -0,0 +1,105 @@
+import { CdmLogger } from '@cdm-logger/core';
+import { ServiceBroker } from 'moleculer';
+import { Disposable, DisposableCollection, Emitter } from '@adminide-stack/core';
+import { BaseService2 } from '@common-stack/store-mongo';
+import { IInstalledExtensionModel, ICreateInstalledExtensionInput, IUpdateInstalledExtensionInput, IRegistryExtensionService, IInstalledExtensionFilter, IInstalledExtensionService, IInstalledExtensionRepository, IExtensionInstalledEvent, IExtensionUninstalledEvent, IExtensionEnabledEvent, IExtensionDisabledEvent, IExtensionUpdatedEvent, IExtensionVersionUpdatedEvent, IExtensionStatusChangedEvent, IExtensionActivationFailedEvent, IExtensionDeprecatedEvent, IExtensionOrphanedEvent, IExtensionConfigurationUpdatedEvent, IExtensionSyncCompletedEvent, IExtensionCleanupCompletedEvent, AsDomainType, ISlugService } from 'common/server';
+export declare class InstalledExtensionService extends BaseService2<IInstalledExtensionModel> implements IInstalledExtensionService, Disposable {
+    private installedExtensionRepository;
+    protected registryExtensionService: IRegistryExtensionService;
+    protected slugService: ISlugService;
+    protected broker: ServiceBroker;
+    protected readonly onExtensionInstalled: Emitter<IExtensionInstalledEvent>;
+    protected readonly onExtensionUninstalled: Emitter<IExtensionUninstalledEvent>;
+    protected readonly onExtensionEnabled: Emitter<IExtensionEnabledEvent>;
+    protected readonly onExtensionDisabled: Emitter<IExtensionDisabledEvent>;
+    protected readonly onExtensionUpdated: Emitter<IExtensionUpdatedEvent>;
+    protected readonly onExtensionVersionUpdated: Emitter<IExtensionVersionUpdatedEvent>;
+    protected readonly onExtensionConfigurationUpdated: Emitter<IExtensionConfigurationUpdatedEvent>;
+    protected readonly onExtensionSyncCompleted: Emitter<IExtensionSyncCompletedEvent>;
+    protected readonly onExtensionCleanupCompleted: Emitter<IExtensionCleanupCompletedEvent>;
+    protected readonly onExtensionStatusChanged: Emitter<IExtensionStatusChangedEvent>;
+    protected readonly onExtensionActivationFailed: Emitter<IExtensionActivationFailedEvent>;
+    protected readonly onExtensionDeprecated: Emitter<IExtensionDeprecatedEvent>;
+    protected readonly onExtensionOrphaned: Emitter<IExtensionOrphanedEvent>;
+    protected readonly toDispose: DisposableCollection;
+    private logger;
+    constructor(installedExtensionRepository: IInstalledExtensionRepository, registryExtensionService: IRegistryExtensionService, slugService: ISlugService, broker: ServiceBroker, logger: CdmLogger.ILogger);
+    dispose(): void;
+    private resolveExtensionSlug;
+    /**
+     * Install a new extension from the registry
+     */
+    installExtension(input: ICreateInstalledExtensionInput, tenantId: string): Promise<AsDomainType<IInstalledExtensionModel>>;
+    /**
+     * Internal method to perform the actual installation after validation
+     */
+    private doInstallExtension;
+    /**
+     * Uninstall an extension
+     */
+    uninstallExtension(orgId: string, extensionSlug: string, uninstalledBy: string, tenantId: any): Promise<boolean>;
+    /**
+     * Update an installed extension's configuration or status
+     */
+    updateInstalledExtension(orgId: string, extensionSlug: string, update: IUpdateInstalledExtensionInput, tenantId: string): Promise<AsDomainType<IInstalledExtensionModel>>;
+    /**
+     * Get a specific installed extension
+     */
+    getInstalledExtension(orgId: string, extensionSlug: string): Promise<AsDomainType<IInstalledExtensionModel> | null>;
+    /**
+     * Get all installed extensions for a tenant with optional filtering
+     */
+    getInstalledExtensions(filter: IInstalledExtensionFilter): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+    /**
+     * Enable/disable an installed extension
+     */
+    toggleExtension(orgId: string, extensionSlug: string, enabled: boolean, toggledBy: string, tenantId: string): Promise<AsDomainType<IInstalledExtensionModel>>;
+    /**
+     * Update extension settings/configuration
+     */
+    updateExtensionSettings(orgId: string, extensionSlug: string, userConfig: Record<string, unknown>, updatedBy: string, tenantId: string): Promise<AsDomainType<IInstalledExtensionModel>>;
+    /**
+     * Check for extension updates and return available updates
+     */
+    checkForUpdates(orgId: string, extensionSlug?: string): Promise<Array<{
+        extensionId: string;
+        extensionSlug: string;
+        currentVersion: string;
+        availableVersion: string;
+        isSecurityUpdate: boolean;
+    }>>;
+    /**
+     * Update an extension to a newer version
+     */
+    updateExtensionVersion(orgId: string, extensionSlug: string, targetVersion: string, updatedBy: string, tenantId: any): Promise<AsDomainType<IInstalledExtensionModel>>;
+    /**
+     * Sync installed extensions with registry status
+     */
+    syncWithRegistry(orgId: string, tenantId: string): Promise<void>;
+    /**
+     * Get extensions that need attention
+     */
+    getExtensionsNeedingAttention(orgId: string): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+    /**
+     * Clean up deprecated or removed extensions based on policies
+     */
+    cleanupExtensions(orgId: string, tenantId: string, dryRun?: boolean): Promise<{
+        removed: string[];
+        deprecated: string[];
+        warnings: string[];
+    }>;
+    /**
+     * Sync installed_extensions with system_extension registry
+     * Removes extensions from installed_extensions and configuration_registries
+     * if they are not present in system_extension registry
+     */
+    cleanupOrphanedExtensions(orgId: string, tenantId: string, dryRun?: boolean): Promise<{
+        removed: string[];
+        warnings: string[];
+    }>;
+    /**
+     * Check if update is a security update (simplified logic)
+     */
+    private isSecurityUpdate;
+}
+//# sourceMappingURL=installed-extension-service.d.ts.map

package/lib/services/installed-extension-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-service.d.ts","sourceRoot":"","sources":["../../src/services/installed-extension-service.ts"],"names":[],"mappings":"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"}