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

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

@@ -1,7 +1,8 @@
-import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import'@cdm-logger/core';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import {Emitter,DisposableCollection}from'@adminide-stack/core';import {SERVER_TYPES,ExtensionActivationState}from'common/server';import {BaseService2}from'@common-stack/store-mongo';var InstalledExtensionService_1;
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import'@cdm-logger/core';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import {Emitter,DisposableCollection}from'@adminide-stack/core';import {BaseService2}from'@common-stack/store-mongo';import {SERVER_TYPES,DB_COLL_NAMES,ExtensionActivationState}from'common/server';var InstalledExtensionService_1;
 let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExtensionService extends BaseService2 {
   installedExtensionRepository;
   registryExtensionService;
+  slugService;
   broker;
   onExtensionInstalled = new Emitter();
   onExtensionUninstalled = new Emitter();
@@ -18,10 +19,11 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
   onExtensionOrphaned = new Emitter();
   toDispose = new DisposableCollection(this.onExtensionInstalled, this.onExtensionUninstalled, this.onExtensionEnabled, this.onExtensionDisabled, this.onExtensionUpdated, this.onExtensionVersionUpdated, this.onExtensionConfigurationUpdated, this.onExtensionSyncCompleted, this.onExtensionCleanupCompleted, this.onExtensionStatusChanged, this.onExtensionActivationFailed, this.onExtensionDeprecated, this.onExtensionOrphaned);
   logger;
-  constructor(installedExtensionRepository, registryExtensionService, broker, logger) {
+  constructor(installedExtensionRepository, registryExtensionService, slugService, broker, logger) {
     super(installedExtensionRepository);
     this.installedExtensionRepository = installedExtensionRepository;
     this.registryExtensionService = registryExtensionService;
+    this.slugService = slugService;
     this.broker = broker;
     this.logger = logger.child({
       className: InstalledExtensionService_1.name
@@ -30,34 +32,63 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
   dispose() {
     this.toDispose.dispose();
   }
+  resolveExtensionSlug(extensionSlug) {
+    return this.slugService.resolveSlugWithProvider(DB_COLL_NAMES.ExtensionRegistries, 'extensionSlug', extensionSlug);
+  }
   /**
    * Install a new extension from the registry
    */
-  async installExtension(input) {
-    this.logger.info(`Installing extension ${input.extensionSlug} for tenant ${input.tenantId}`);
-    // Check if extension already exists
-    const existing = await this.installedExtensionRepository.exists(input.tenantId, input.extensionSlug);
+  async installExtension(input, tenantId) {
+    this.logger.debug('Installing extension [%s] for organization [%s] with input [%j]', input.extensionSlug, input.orgId, input);
+    if (!input.orgId) {
+      this.logger.error('Organization ID missing for extension installation [%s]', input.extensionSlug);
+      throw new Error('Organization ID (orgId) is required for extension installation');
+    }
+    this.logger.info('Installing extension [%s] for organization [%s]', input.extensionSlug, input.orgId);
+    // Check if extension already exists for this organization
+    this.logger.debug('Resolving extension slug [%s] to extension ID', input.extensionSlug);
+    const extensionId = await this.resolveExtensionSlug(input.extensionSlug);
+    this.logger.debug('Extension slug [%s] resolved to ID [%s]', input.extensionSlug, extensionId);
+    this.logger.debug('Checking if extension [%s] already exists for organization [%s]', extensionId, input.orgId);
+    const existing = await this.installedExtensionRepository.exists(input.orgId, extensionId);
     if (existing) {
-      throw new Error(`Extension ${input.extensionSlug} is already installed for tenant ${input.tenantId}`);
+      this.logger.warn('Extension [%s] already installed for organization [%s]', input.extensionSlug, input.orgId);
+      throw new Error(`Extension ${input.extensionSlug} is already installed for organization ${input.orgId}`);
     }
     // Get extension from registry to validate
+    this.logger.debug('Fetching extension [%s] from registry', input.extensionSlug);
     const registryExtension = await this.registryExtensionService.findExtension(input.extensionSlug);
     if (!registryExtension) {
+      this.logger.error('Extension [%s] not found in registry', input.extensionSlug);
       throw new Error(`Extension ${input.extensionSlug} not found in registry`);
     }
+    this.logger.debug('Registry extension found [%j]', {
+      id: registryExtension.id,
+      version: registryExtension.version,
+      name: registryExtension.name
+    });
     // Delegate to the internal install method (validation already done)
-    return this.doInstallExtension(input, registryExtension);
+    this.logger.debug('Delegating to doInstallExtension for [%s]', input.extensionSlug);
+    return this.doInstallExtension(input, registryExtension, tenantId);
   }
   /**
    * Internal method to perform the actual installation after validation
    */
-  async doInstallExtension(input, registryExtension) {
+  async doInstallExtension(input, registryExtension, tenantId) {
+    this.logger.debug('doInstallExtension input [%j]', input);
+    this.logger.debug('doInstallExtension registryExtension [%j]', {
+      id: registryExtension.id,
+      version: registryExtension.version,
+      name: registryExtension.name
+    });
+    const versionToUse = input.version || registryExtension.version;
+    this.logger.debug('Version resolution: input.version=[%s], registryExtension.version=[%s], using=[%s]', input.version, registryExtension.version, versionToUse);
     // Create the installed extension record with proper defaults
     const installedExtension = await this.installedExtensionRepository.create({
-      tenantId: input.tenantId,
+      organization: input.orgId,
       extensionSlug: input.extensionSlug,
       extension: registryExtension.id,
-      version: input.version || registryExtension.version,
+      version: versionToUse,
       installedVersion: registryExtension.version,
       installedBy: input.installedBy,
       policies: {
@@ -76,13 +107,14 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
     // Fire installation event
     const event = {
       extensionSlug: input.extensionSlug,
-      tenantId: input.tenantId,
       installedBy: input.installedBy,
       installedVersion: installedExtension.installedVersion,
       registryRef: registryExtension.id,
       installedAt: new Date().toISOString(),
       policies: input.policies,
-      settings: input.settings
+      settings: input.settings,
+      orgId: input.orgId,
+      tenantId
     };
     this.onExtensionInstalled.fire(event);
     this.logger.info(`Successfully installed extension ${input.extensionSlug}`);
@@ -91,46 +123,117 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
   /**
    * Uninstall an extension
    */
-  async uninstallExtension(tenantId, extensionSlug, uninstalledBy) {
-    this.logger.info(`Uninstalling extension ${extensionSlug} for tenant ${tenantId}`);
-    const extension = await this.installedExtensionRepository.findByTenantAndId(tenantId, extensionSlug);
+  async uninstallExtension(orgId, extensionSlug, uninstalledBy, tenantId) {
+    this.logger.debug('Uninstalling extension [%s] for org [%s] by user [%s] with tenantId [%s]', extensionSlug, orgId, uninstalledBy, tenantId);
+    this.logger.info('Uninstalling extension [%s] in org [%s]', extensionSlug, orgId);
+    this.logger.debug('Resolving extension slug [%s] to extension ID', extensionSlug);
+    const extensionId = await this.resolveExtensionSlug(extensionSlug);
+    this.logger.debug('Extension slug [%s] resolved to ID [%s]', extensionSlug, extensionId);
+    if (!extensionId) {
+      this.logger.error('Failed to resolve extension slug [%s] - not found in registry', extensionSlug);
+      throw new Error(`Extension ${extensionSlug} not found in registry`);
+    }
+    let extension = null;
+    if (extensionId) {
+      this.logger.debug('Finding extension by org [%s] and extension ID [%s]', orgId, extensionId);
+      // Try to find by extension ID first
+      extension = await this.installedExtensionRepository.findByOrgAndExtensionId(orgId, extensionId);
+      this.logger.debug('Extension found by ID lookup: [%s]', !!extension);
+    }
+    // If not found by extension ID, try alternative methods
     if (!extension) {
-      throw new Error(`Extension ${extensionSlug} not found for tenant ${tenantId}`);
+      this.logger.debug('Extension not found by ID, trying alternative lookup methods');
+      // Instead of complex lookups, let's search all installed extensions
+      // and match by checking if the registry extension has the matching slug
+      const allInstalled = await this.getInstalledExtensions({
+        orgId
+      });
+      this.logger.debug('Found [%d] installed extensions for org [%s]', allInstalled.length, orgId);
+      // For each installed extension, check if it matches our slug
+      for (const installed of allInstalled) {
+        this.logger.debug('Checking installed extension [%j]', {
+          id: installed.id,
+          extensionId: installed.extension
+        });
+        // Since we can't easily look up registry by ID, let's try a different approach
+        // Use the slug service to find if this matches
+        try {
+          // Get the extension slug from the registry extension directly if possible
+          if (installed.extension) {
+            // Try to resolve the extension ID back to slug for comparison
+            const extensionIdString = String(installed.extension);
+            // Check if this extension ID matches what we'd expect for this slug
+            const resolvedExtensionId = await this.resolveExtensionSlug(extensionSlug);
+            this.logger.debug('Comparing extension IDs: installed [%s] vs resolved [%s]', extensionIdString, resolvedExtensionId);
+            if (resolvedExtensionId && resolvedExtensionId === extensionIdString) {
+              this.logger.debug('Found matching extension via alternative lookup');
+              extension = installed;
+              break;
+            }
+          }
+        } catch (error) {
+          this.logger.warn('Error in alternative lookup for extension [%s]: [%s]', installed.id, error.message);
+        }
+      }
     }
+    if (!extension) {
+      this.logger.error('Extension [%s] not found in org [%s] after all lookup attempts', extensionSlug, orgId);
+      throw new Error(`Extension ${extensionSlug} not found in org ${orgId}`);
+    }
+    this.logger.debug('Found extension to uninstall [%j]', {
+      id: extension.id,
+      extensionId: extension.extension,
+      slug: extension.extensionSlug
+    });
+    // Use the extension ID from the found extension record
+    const actualExtensionId = String(extension.extension);
+    this.logger.debug('Using actual extension ID [%s] for uninstall operations', actualExtensionId);
     // Check dependencies - prevent uninstalling if other extensions depend on this
-    const dependencyGraph = await this.installedExtensionRepository.getDependencyGraph(tenantId);
-    const extensionDeps = dependencyGraph.dependencies.find(dep => dep.extensionSlug === extensionSlug);
+    this.logger.debug('Checking dependency graph for org [%s]', orgId);
+    const dependencyGraph = await this.installedExtensionRepository.getDependencyGraph(orgId);
+    const extensionDeps = dependencyGraph.dependencies.find(dep => dep.extensionId === actualExtensionId);
     if (extensionDeps && extensionDeps.dependents.length > 0) {
+      this.logger.warn('Cannot uninstall extension [%s]: required by dependents [%j]', extensionSlug, extensionDeps.dependents);
       throw new Error(`Cannot uninstall ${extensionSlug}: Required by ${extensionDeps.dependents.join(', ')}`);
     }
-    // Delete the extension
-    const deleted = await this.installedExtensionRepository.deleteExtension(tenantId, extensionSlug);
+    // Delete the extension using the installed extension's ID
+    this.logger.debug('Attempting to delete extension [%s] from org [%s]', actualExtensionId, orgId);
+    const deleted = await this.installedExtensionRepository.deleteExtension(orgId, actualExtensionId);
+    this.logger.debug('Extension deletion result: [%s]', deleted);
     if (deleted) {
+      this.logger.debug('Creating uninstall event for extension [%s]', extensionSlug);
       // Fire uninstallation event
       const event = {
         extensionSlug,
+        orgId,
         tenantId,
+        // Using accountId as tenantId for backward compatibility in events
         uninstalledBy,
         uninstalledAt: new Date().toISOString(),
         wasEnabled: extension.settings?.userEnabled || false,
         dependencies: extension.dependencies || []
       };
+      this.logger.debug('Firing uninstall event [%j]', event);
       this.onExtensionUninstalled.fire(event);
-      this.logger.info(`Successfully uninstalled extension ${extensionSlug}`);
+      this.logger.info('Successfully uninstalled extension [%s] ([%s])', extensionSlug, actualExtensionId);
+    } else {
+      this.logger.error('Failed to delete extension [%s] from database', actualExtensionId);
     }
     return deleted;
   }
   /**
    * Update an installed extension's configuration or status
    */
-  async updateInstalledExtension(tenantId, extensionSlug, update) {
-    this.logger.info(`Updating installed extension ${extensionSlug} for tenant ${tenantId}`);
-    const updatedExtension = await this.installedExtensionRepository.updateExtension(tenantId, extensionSlug, {
+  async updateInstalledExtension(orgId, extensionSlug, update, tenantId) {
+    // For now, use orgId as tenantId for backward compatibility until repository is updated
+    this.logger.info(`Updating installed extension ${extensionSlug} for org ${orgId}`);
+    const extensionId = await this.resolveExtensionSlug(extensionSlug);
+    const updatedExtension = await this.installedExtensionRepository.updateExtension(orgId, extensionId, {
       ...update,
       lastUpdatedBy: update.lastUpdatedBy
     });
     if (!updatedExtension) {
-      throw new Error(`Extension ${extensionSlug} not found for tenant ${tenantId}`);
+      throw new Error(`Extension ${extensionId} not found for org ${orgId}`);
     }
     // Fire update event if status changed
     if (update.status || update.settings) {
@@ -148,8 +251,10 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
   /**
    * Get a specific installed extension
    */
-  async getInstalledExtension(tenantId, extensionSlug) {
-    const result = await this.installedExtensionRepository.findByTenantAndId(tenantId, extensionSlug);
+  async getInstalledExtension(orgId, extensionSlug) {
+    // For now, use accountId as tenantId for backward compatibility until repository is updated
+    const extensionId = await this.resolveExtensionSlug(extensionSlug);
+    const result = await this.installedExtensionRepository.findByOrgAndExtensionId(orgId, extensionId);
     return result ? result : null;
   }
   /**
@@ -159,12 +264,27 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
     const results = await this.installedExtensionRepository.findExtensions(filter);
     return results;
   }
+  /**
+   * Get all installed extensions for a specific extension by extensionSlug
+   * Useful for finding all organizations that have installed a specific extension
+   */
+  async getInstalledExtensionsBySlug(extensionSlug) {
+    const extensionId = await this.resolveExtensionSlug(extensionSlug);
+    if (!extensionId) {
+      this.logger.warn({
+        extensionSlug
+      }, 'Extension not found in registry');
+      return [];
+    }
+    const results = await this.installedExtensionRepository.findByExtensionId(extensionId);
+    return results;
+  }
   /**
    * Enable/disable an installed extension
    */
-  async toggleExtension(tenantId, extensionSlug, enabled, toggledBy) {
+  async toggleExtension(orgId, extensionSlug, enabled, toggledBy, tenantId) {
     const activationState = enabled ? ExtensionActivationState.Enabled : ExtensionActivationState.DisabledByUser;
-    const updatedExtension = await this.updateInstalledExtension(tenantId, extensionSlug, {
+    const updatedExtension = await this.updateInstalledExtension(orgId, extensionSlug, {
       settings: {
         userEnabled: enabled
       },
@@ -177,7 +297,7 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
         })
       },
       lastUpdatedBy: toggledBy
-    });
+    }, tenantId);
     // Fire toggle event
     const event = enabled ? {
       extensionSlug,
@@ -203,13 +323,13 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
   /**
    * Update extension settings/configuration
    */
-  async updateExtensionSettings(tenantId, extensionSlug, userConfig, updatedBy) {
-    const updatedExtension = await this.updateInstalledExtension(tenantId, extensionSlug, {
+  async updateExtensionSettings(orgId, extensionSlug, userConfig, updatedBy, tenantId) {
+    const updatedExtension = await this.updateInstalledExtension(orgId, extensionSlug, {
       settings: {
         userConfig
       },
       lastUpdatedBy: updatedBy
-    });
+    }, tenantId);
     // Fire configuration update event
     const event = {
       extensionSlug,
@@ -217,8 +337,9 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
       updatedBy,
       updatedAt: new Date().toISOString(),
       configType: 'user',
-      newConfig: userConfig,
-      previousConfig: updatedExtension.settings.userConfig
+      newConfig: userConfig
+      // configurationChanges: userConfig,
+      // previousConfiguration: updatedExtension.settings.userConfig,
     };
     // Fire configuration update event
     this.onExtensionConfigurationUpdated.fire(event);
@@ -227,12 +348,13 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
   /**
    * Check for extension updates and return available updates
    */
-  async checkForUpdates(tenantId, extensionSlug) {
+  async checkForUpdates(orgId, extensionSlug) {
     const query = {
-      tenantId
+      orgId
     };
     if (extensionSlug) {
-      query.extensionSlug = extensionSlug;
+      const extensionId = await this.resolveExtensionSlug(extensionSlug);
+      query.extension = extensionId;
     }
     const installedExtensions = await this.installedExtensionRepository.findExtensions(query);
     const updates = [];
@@ -240,7 +362,8 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
       const registryExtension = await this.registryExtensionService.findExtension(installed.extension?.toString());
       if (registryExtension && registryExtension.version !== installed.installedVersion) {
         updates.push({
-          extensionSlug: installed.extension?.toString(),
+          extensionId: installed.extension?.toString(),
+          extensionSlug,
           currentVersion: installed.installedVersion,
           availableVersion: registryExtension.version,
           isSecurityUpdate: this.isSecurityUpdate(installed.installedVersion, registryExtension.version)
@@ -252,29 +375,29 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
   /**
    * Update an extension to a newer version
    */
-  async updateExtensionVersion(tenantId, extensionSlug, targetVersion, updatedBy) {
-    const extension = await this.getInstalledExtension(tenantId, extensionSlug);
+  async updateExtensionVersion(orgId, extensionSlug, targetVersion, updatedBy, tenantId) {
+    const extension = await this.getInstalledExtension(orgId, extensionSlug);
     if (!extension) {
-      throw new Error(`Extension ${extensionSlug} not found for tenant ${tenantId}`);
+      throw new Error(`Extension ${extensionSlug} not found for organization ${orgId}`);
     }
     // Validate target version exists in registry
     const registryExtension = await this.registryExtensionService.findExtension(extensionSlug);
     if (!registryExtension) {
       throw new Error(`Extension ${extensionSlug} not found in registry`);
     }
-    const updatedExtension = await this.updateInstalledExtension(tenantId, extensionSlug, {
+    const updatedExtension = await this.updateInstalledExtension(orgId, extensionSlug, {
       lastUpdatedBy: updatedBy
       // Note: Version update should be handled at the model level, not through update input
-    });
+    }, tenantId);
     // Fire version update event
     const event = {
       extensionSlug,
-      tenantId,
       updatedBy,
       fromVersion: extension.installedVersion,
       toVersion: targetVersion,
       updatedAt: new Date().toISOString(),
-      isSecurityUpdate: this.isSecurityUpdate(extension.installedVersion, targetVersion)
+      isSecurityUpdate: this.isSecurityUpdate(extension.installedVersion, targetVersion),
+      tenantId
     };
     // Fire version update event
     this.onExtensionVersionUpdated.fire(event);
@@ -283,10 +406,10 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
   /**
    * Sync installed extensions with registry status
    */
-  async syncWithRegistry(tenantId) {
-    this.logger.info(`Syncing installed extensions with registry for tenant ${tenantId}`);
+  async syncWithRegistry(orgId, tenantId) {
+    this.logger.info(`Syncing installed extensions with registry for organization ${orgId}`);
     const installedExtensions = await this.installedExtensionRepository.findExtensions({
-      tenantId
+      orgId
     });
     const syncUpdates = [];
     for (const installed of installedExtensions) {
@@ -294,33 +417,46 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
       if (!registryExtension) {
         // Extension removed from registry
         syncUpdates.push({
-          tenantId,
-          extensionSlug: installed.extension?.toString(),
+          orgId,
+          extensionId: installed.extension?.toString(),
           registryStatus: 'removed',
           isOrphaned: true
         });
       } else {
         syncUpdates.push({
-          tenantId,
-          extensionSlug: installed.extension?.toString(),
+          extensionId: installed.extension?.toString(),
           registryStatus: registryExtension.status || 'active',
           latestVersion: registryExtension.version,
-          isOrphaned: false
+          isOrphaned: false,
+          orgId
         });
       }
     }
-    await this.installedExtensionRepository.syncRegistryStatus(syncUpdates);
+    // For now, map to old format for repository compatibility
+    const repoCompatibleUpdates = syncUpdates.map(update => ({
+      orgId: update.orgId,
+      // Use orgId as tenantId for backward compatibility
+      extensionId: update.extensionId,
+      registryStatus: update.registryStatus,
+      latestVersion: update.latestVersion,
+      isOrphaned: update.isOrphaned
+    }));
+    await this.installedExtensionRepository.syncRegistryStatus(repoCompatibleUpdates);
     // Fire sync completion event
     const orphanedUpdates = syncUpdates.filter(u => u.isOrphaned);
     syncUpdates.filter(u => u.registryStatus === 'deprecated');
     const versionsUpdates = syncUpdates.filter(u => u.latestVersion);
     const event = {
-      tenantId,
       syncedAt: new Date().toISOString(),
       extensionsChecked: syncUpdates.length,
+      // syncedExtensions: versionsUpdates.length,
       extensionsOrphaned: orphanedUpdates.length,
       extensionsUpdated: versionsUpdates.length,
-      errors: [] // No errors in this implementation
+      tenantId,
+      errors: []
+      // orphanedExtensions: orphanedUpdates.map((u) => u.extensionId),
+      // deprecatedExtensions: deprecatedUpdates.map((u) => u.extensionId),
+      // updatedExtensions: versionsUpdates.map((u) => u.extensionId),
     };
     // Fire sync completed event
     this.onExtensionSyncCompleted.fire(event);
@@ -329,9 +465,9 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
   /**
    * Get extensions that need attention
    */
-  async getExtensionsNeedingAttention(tenantId) {
+  async getExtensionsNeedingAttention(orgId) {
     const extensions = await this.getInstalledExtensions({
-      tenantId
+      orgId
     });
     const filtered = extensions.filter(ext => {
       // Check for conditions that need attention
@@ -345,28 +481,29 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
   /**
    * Clean up deprecated or removed extensions based on policies
    */
-  async cleanupExtensions(tenantId, dryRun = false) {
+  async cleanupExtensions(orgId, tenantId, dryRun) {
+    // For now, use accountId as tenantId for backward compatibility until repository is updated
     const result = {
       removed: [],
       deprecated: [],
       warnings: []
     };
     const extensions = await this.installedExtensionRepository.findExtensions({
-      tenantId
+      orgId
     });
     for (const extension of extensions) {
       const gracePeriodExpired = extension.policies.deprecationGracePeriod > 0 && extension.lifecycle.lastRegistryCheck && Date.now() - new Date(extension.lifecycle.lastRegistryCheck).getTime() > extension.policies.deprecationGracePeriod * 24 * 60 * 60 * 1000;
       // Remove orphaned extensions
       if (extension.lifecycle.isOrphaned && !extension.policies.allowOrphanedExecution) {
         if (!dryRun) {
-          await this.uninstallExtension(tenantId, extension.extension?.toString(), 'system-cleanup');
+          await this.uninstallExtension(orgId, extension.extension?.toString(), 'system-cleanup', tenantId);
         }
         result.removed.push(extension.extension?.toString());
       }
       // Remove deprecated extensions if auto-remove is enabled and grace period expired
       else if (extension.lifecycle.registryStatus === 'deprecated' && extension.policies.autoRemoveDeprecated && gracePeriodExpired) {
         if (!dryRun) {
-          await this.uninstallExtension(tenantId, extension.extension?.toString(), 'system-cleanup');
+          await this.uninstallExtension(orgId, extension.extension?.toString(), 'system-cleanup', tenantId);
         }
         result.deprecated.push(extension.extension?.toString());
       }
@@ -379,15 +516,111 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
     const event = {
       tenantId,
       cleanedAt: new Date().toISOString(),
-      extensionsRemoved: result.removed,
-      extensionsDeprecated: result.deprecated,
+      // cleanupAt: new Date().toISOString(),
       warnings: result.warnings,
-      dryRun: dryRun || false
+      dryRun: false,
+      extensionsDeprecated: result.deprecated,
+      extensionsRemoved: result.removed
     };
     // Fire cleanup completed event
     this.onExtensionCleanupCompleted.fire(event);
     return result;
   }
+  /**
+   * Sync installed_extensions with system_extension registry
+   * Removes extensions from installed_extensions and configuration_registries
+   * if they are not present in system_extension registry
+   */
+  async cleanupOrphanedExtensions(orgId, tenantId, dryRun) {
+    const result = {
+      removed: [],
+      warnings: []
+    };
+    console.log('🔍 SYNC: Starting extension registry sync...');
+    console.log(`   OrgId: ${orgId}, TenantId: ${tenantId}, DryRun: ${dryRun}`);
+    // Get all installed extensions
+    const extensions = await this.installedExtensionRepository.findExtensions({
+      orgId
+    });
+    console.log(`   Found ${extensions.length} installed extensions`);
+    // Get system_extension document
+    const systemExtensionDoc = await this.broker.call('ConfigurationRegistryService.getConfigurationNodeRegistry', {
+      context: {
+        schemaId: 'configuration',
+        tenantId,
+        extensionName: 'system_extension'
+      }
+    });
+    // Get list of extensions in system_extension
+    const systemExtensionSlugs = new Set();
+    if (systemExtensionDoc && typeof systemExtensionDoc === 'object' && 'configurationNodes' in systemExtensionDoc) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const configNodes = systemExtensionDoc.configurationNodes || [];
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const settingsNode = configNodes.find(node => node.id === 'settings');
+      if (settingsNode?.properties) {
+        Object.keys(settingsNode.properties).forEach(key => {
+          if (key.startsWith('extensions.')) {
+            const slug = key.replace('extensions.', '');
+            systemExtensionSlugs.add(slug);
+          }
+        });
+      }
+    }
+    console.log(`   Found ${systemExtensionSlugs.size} extensions in system_extension registry`);
+    console.log(`   System extensions:`, Array.from(systemExtensionSlugs));
+    // Check each installed extension
+    for (const extension of extensions) {
+      const extensionId = String(extension.extension);
+      // Get the registry extension to find its slug
+      let extensionSlug = null;
+      try {
+        const registryExtension = await this.registryExtensionService.get(extensionId);
+        if (registryExtension) {
+          extensionSlug = registryExtension.extensionSlug || extensionId;
+        }
+      } catch (error) {
+        this.logger.warn(`Failed to fetch registry extension ${extensionId}:`, error);
+      }
+      if (!extensionSlug) {
+        console.log(`⚠️ Could not determine slug for extension ID: ${extensionId}`);
+        result.warnings.push(`Could not determine slug for extension ID: ${extensionId}`);
+      } else if (!systemExtensionSlugs.has(extensionSlug)) {
+        // If extension is in installed_extensions but NOT in system_extension, it's orphaned
+        const orphanMsg = `⚠️ Found orphaned installed_extension: ${extensionSlug} (ID: ${extensionId}) (not in system_extension)`;
+        console.log(orphanMsg);
+        if (!dryRun) {
+          try {
+            // Remove from installed_extensions
+            await this.installedExtensionRepository.deleteExtension(orgId, extensionId);
+            console.log(`   ✅ Deleted from installed_extensions: ${extensionSlug}`);
+            // Remove uiLayout configuration from configuration_registries
+            await this.broker.call('ConfigurationRegistryService.removeConfigurationNodeRegistry', {
+              context: {
+                schemaId: 'uiLayout',
+                tenantId,
+                extensionName: extensionSlug
+              }
+            });
+            console.log(`   ✅ Deleted uiLayout config: ${extensionSlug}`);
+            result.removed.push(extensionSlug);
+          } catch (cleanupError) {
+            console.error(`   ❌ Failed to cleanup ${extensionSlug}:`, cleanupError);
+            result.warnings.push(`Failed to cleanup ${extensionSlug}: ${cleanupError.message}`);
+          }
+        } else {
+          console.log(`   [DRY RUN] Would remove: ${extensionSlug}`);
+          result.removed.push(extensionSlug);
+        }
+      } else {
+        console.log(`✅ Extension ${extensionSlug} is registered in system_extension`);
+      }
+    }
+    console.log('\n✅ SYNC COMPLETE');
+    console.log(`   Removed: ${result.removed.length} extensions`);
+    console.log(`   Warnings: ${result.warnings.length} items`);
+    return result;
+  }
   /**
    * Check if update is a security update (simplified logic)
    */
@@ -397,4 +630,4 @@ let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExt
     return false;
   }
 };
-InstalledExtensionService = InstalledExtensionService_1 = __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])], InstalledExtensionService);export{InstalledExtensionService};//# sourceMappingURL=installed-extension-service.js.map
+InstalledExtensionService = InstalledExtensionService_1 = __decorate([injectable(), __param(0, inject(SERVER_TYPES.IInstalledExtensionRepository)), __param(1, inject(SERVER_TYPES.IRegistryExtensionService)), __param(2, inject(SERVER_TYPES.SlugService)), __param(3, inject(CommonType.MOLECULER_BROKER)), __param(4, inject(CommonType.LOGGER)), __metadata("design:paramtypes", [Object, Object, Object, ServiceBroker, Object])], InstalledExtensionService);export{InstalledExtensionService};//# sourceMappingURL=installed-extension-service.js.map

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

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

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

@@ -1,2 +1 @@
-export {};
 //# sourceMappingURL=installed-extension-service.test.d.ts.map