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

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

@@ -0,0 +1,400 @@
+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;
+let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExtensionService extends BaseService2 {
+  installedExtensionRepository;
+  registryExtensionService;
+  broker;
+  onExtensionInstalled = new Emitter();
+  onExtensionUninstalled = new Emitter();
+  onExtensionEnabled = new Emitter();
+  onExtensionDisabled = new Emitter();
+  onExtensionUpdated = new Emitter();
+  onExtensionVersionUpdated = new Emitter();
+  onExtensionConfigurationUpdated = new Emitter();
+  onExtensionSyncCompleted = new Emitter();
+  onExtensionCleanupCompleted = new Emitter();
+  onExtensionStatusChanged = new Emitter();
+  onExtensionActivationFailed = new Emitter();
+  onExtensionDeprecated = new Emitter();
+  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) {
+    super(installedExtensionRepository);
+    this.installedExtensionRepository = installedExtensionRepository;
+    this.registryExtensionService = registryExtensionService;
+    this.broker = broker;
+    this.logger = logger.child({
+      className: InstalledExtensionService_1.name
+    });
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+  /**
+   * 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);
+    if (existing) {
+      throw new Error(`Extension ${input.extensionSlug} is already installed for tenant ${input.tenantId}`);
+    }
+    // Get extension from registry to validate
+    const registryExtension = await this.registryExtensionService.findExtension(input.extensionSlug);
+    if (!registryExtension) {
+      throw new Error(`Extension ${input.extensionSlug} not found in registry`);
+    }
+    // Delegate to the internal install method (validation already done)
+    return this.doInstallExtension(input, registryExtension);
+  }
+  /**
+   * Internal method to perform the actual installation after validation
+   */
+  async doInstallExtension(input, registryExtension) {
+    // Create the installed extension record with proper defaults
+    const installedExtension = await this.installedExtensionRepository.create({
+      tenantId: input.tenantId,
+      extensionSlug: input.extensionSlug,
+      extension: registryExtension.id,
+      version: input.version || registryExtension.version,
+      installedVersion: registryExtension.version,
+      installedBy: input.installedBy,
+      policies: {
+        allowOrphanedExecution: false,
+        requireSecurityUpdates: true,
+        autoRemoveDeprecated: false,
+        deprecationGracePeriod: 30,
+        ...input.policies
+      },
+      settings: {
+        userEnabled: true,
+        systemEnabled: true,
+        ...input.settings
+      }
+    });
+    // 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
+    };
+    this.onExtensionInstalled.fire(event);
+    this.logger.info(`Successfully installed extension ${input.extensionSlug}`);
+    return installedExtension;
+  }
+  /**
+   * 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);
+    if (!extension) {
+      throw new Error(`Extension ${extensionSlug} not found for tenant ${tenantId}`);
+    }
+    // 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);
+    if (extensionDeps && extensionDeps.dependents.length > 0) {
+      throw new Error(`Cannot uninstall ${extensionSlug}: Required by ${extensionDeps.dependents.join(', ')}`);
+    }
+    // Delete the extension
+    const deleted = await this.installedExtensionRepository.deleteExtension(tenantId, extensionSlug);
+    if (deleted) {
+      // Fire uninstallation event
+      const event = {
+        extensionSlug,
+        tenantId,
+        uninstalledBy,
+        uninstalledAt: new Date().toISOString(),
+        wasEnabled: extension.settings?.userEnabled || false,
+        dependencies: extension.dependencies || []
+      };
+      this.onExtensionUninstalled.fire(event);
+      this.logger.info(`Successfully uninstalled extension ${extensionSlug}`);
+    }
+    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, {
+      ...update,
+      lastUpdatedBy: update.lastUpdatedBy
+    });
+    if (!updatedExtension) {
+      throw new Error(`Extension ${extensionSlug} not found for tenant ${tenantId}`);
+    }
+    // Fire update event if status changed
+    if (update.status || update.settings) {
+      const event = {
+        extensionSlug,
+        tenantId,
+        updatedBy: update.lastUpdatedBy || 'system',
+        updatedAt: new Date().toISOString(),
+        changes: update
+      };
+      this.onExtensionUpdated.fire(event);
+    }
+    return updatedExtension;
+  }
+  /**
+   * Get a specific installed extension
+   */
+  async getInstalledExtension(tenantId, extensionSlug) {
+    const result = await this.installedExtensionRepository.findByTenantAndId(tenantId, extensionSlug);
+    return result ? result : null;
+  }
+  /**
+   * Get all installed extensions for a tenant with optional filtering
+   */
+  async getInstalledExtensions(filter) {
+    const results = await this.installedExtensionRepository.findExtensions(filter);
+    return results;
+  }
+  /**
+   * Enable/disable an installed extension
+   */
+  async toggleExtension(tenantId, extensionSlug, enabled, toggledBy) {
+    const activationState = enabled ? ExtensionActivationState.Enabled : ExtensionActivationState.DisabledByUser;
+    const updatedExtension = await this.updateInstalledExtension(tenantId, extensionSlug, {
+      settings: {
+        userEnabled: enabled
+      },
+      runtime: {
+        activationState,
+        ...(enabled ? {
+          lastActivated: new Date()
+        } : {
+          lastDeactivated: new Date()
+        })
+      },
+      lastUpdatedBy: toggledBy
+    });
+    // Fire toggle event
+    const event = enabled ? {
+      extensionSlug,
+      tenantId,
+      enabledBy: toggledBy,
+      enabledAt: new Date().toISOString(),
+      previousState: updatedExtension.runtime.activationState
+    } : {
+      extensionSlug,
+      tenantId,
+      disabledBy: toggledBy,
+      disabledAt: new Date().toISOString(),
+      reason: 'user'
+    };
+    // Fire status change event
+    if (enabled) {
+      this.onExtensionEnabled.fire(event);
+    } else {
+      this.onExtensionDisabled.fire(event);
+    }
+    return updatedExtension;
+  }
+  /**
+   * Update extension settings/configuration
+   */
+  async updateExtensionSettings(tenantId, extensionSlug, userConfig, updatedBy) {
+    const updatedExtension = await this.updateInstalledExtension(tenantId, extensionSlug, {
+      settings: {
+        userConfig
+      },
+      lastUpdatedBy: updatedBy
+    });
+    // Fire configuration update event
+    const event = {
+      extensionSlug,
+      tenantId,
+      updatedBy,
+      updatedAt: new Date().toISOString(),
+      configType: 'user',
+      newConfig: userConfig,
+      previousConfig: updatedExtension.settings.userConfig
+    };
+    // Fire configuration update event
+    this.onExtensionConfigurationUpdated.fire(event);
+    return updatedExtension;
+  }
+  /**
+   * Check for extension updates and return available updates
+   */
+  async checkForUpdates(tenantId, extensionSlug) {
+    const query = {
+      tenantId
+    };
+    if (extensionSlug) {
+      query.extensionSlug = extensionSlug;
+    }
+    const installedExtensions = await this.installedExtensionRepository.findExtensions(query);
+    const updates = [];
+    for (const installed of installedExtensions) {
+      const registryExtension = await this.registryExtensionService.findExtension(installed.extension?.toString());
+      if (registryExtension && registryExtension.version !== installed.installedVersion) {
+        updates.push({
+          extensionSlug: installed.extension?.toString(),
+          currentVersion: installed.installedVersion,
+          availableVersion: registryExtension.version,
+          isSecurityUpdate: this.isSecurityUpdate(installed.installedVersion, registryExtension.version)
+        });
+      }
+    }
+    return updates;
+  }
+  /**
+   * Update an extension to a newer version
+   */
+  async updateExtensionVersion(tenantId, extensionSlug, targetVersion, updatedBy) {
+    const extension = await this.getInstalledExtension(tenantId, extensionSlug);
+    if (!extension) {
+      throw new Error(`Extension ${extensionSlug} not found for tenant ${tenantId}`);
+    }
+    // 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, {
+      lastUpdatedBy: updatedBy
+      // Note: Version update should be handled at the model level, not through update input
+    });
+    // Fire version update event
+    const event = {
+      extensionSlug,
+      tenantId,
+      updatedBy,
+      fromVersion: extension.installedVersion,
+      toVersion: targetVersion,
+      updatedAt: new Date().toISOString(),
+      isSecurityUpdate: this.isSecurityUpdate(extension.installedVersion, targetVersion)
+    };
+    // Fire version update event
+    this.onExtensionVersionUpdated.fire(event);
+    return updatedExtension;
+  }
+  /**
+   * Sync installed extensions with registry status
+   */
+  async syncWithRegistry(tenantId) {
+    this.logger.info(`Syncing installed extensions with registry for tenant ${tenantId}`);
+    const installedExtensions = await this.installedExtensionRepository.findExtensions({
+      tenantId
+    });
+    const syncUpdates = [];
+    for (const installed of installedExtensions) {
+      const registryExtension = await this.registryExtensionService.findExtension(installed.extension?.toString());
+      if (!registryExtension) {
+        // Extension removed from registry
+        syncUpdates.push({
+          tenantId,
+          extensionSlug: installed.extension?.toString(),
+          registryStatus: 'removed',
+          isOrphaned: true
+        });
+      } else {
+        syncUpdates.push({
+          tenantId,
+          extensionSlug: installed.extension?.toString(),
+          registryStatus: registryExtension.status || 'active',
+          latestVersion: registryExtension.version,
+          isOrphaned: false
+        });
+      }
+    }
+    await this.installedExtensionRepository.syncRegistryStatus(syncUpdates);
+    // 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,
+      extensionsOrphaned: orphanedUpdates.length,
+      extensionsUpdated: versionsUpdates.length,
+      errors: [] // No errors in this implementation
+    };
+    // Fire sync completed event
+    this.onExtensionSyncCompleted.fire(event);
+    this.logger.info(`Synced ${syncUpdates.length} extensions with registry`);
+  }
+  /**
+   * Get extensions that need attention
+   */
+  async getExtensionsNeedingAttention(tenantId) {
+    const extensions = await this.getInstalledExtensions({
+      tenantId
+    });
+    const filtered = extensions.filter(ext => {
+      // Check for conditions that need attention
+      const isOrphaned = ext.lifecycle?.isOrphaned;
+      const isDeprecated = ext.lifecycle?.registryStatus === 'deprecated';
+      const hasUpdates = ext.availableVersion && ext.availableVersion !== ext.installedVersion;
+      return isOrphaned || isDeprecated || hasUpdates;
+    });
+    return filtered;
+  }
+  /**
+   * Clean up deprecated or removed extensions based on policies
+   */
+  async cleanupExtensions(tenantId, dryRun = false) {
+    const result = {
+      removed: [],
+      deprecated: [],
+      warnings: []
+    };
+    const extensions = await this.installedExtensionRepository.findExtensions({
+      tenantId
+    });
+    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');
+        }
+        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');
+        }
+        result.deprecated.push(extension.extension?.toString());
+      }
+      // Add warnings for extensions that need attention
+      else if (extension.lifecycle.registryStatus === 'deprecated' || extension.lifecycle.isOrphaned) {
+        result.warnings.push(extension.extension?.toString());
+      }
+    }
+    // Fire cleanup completion event
+    const event = {
+      tenantId,
+      cleanedAt: new Date().toISOString(),
+      extensionsRemoved: result.removed,
+      extensionsDeprecated: result.deprecated,
+      warnings: result.warnings,
+      dryRun: dryRun || false
+    };
+    // Fire cleanup completed event
+    this.onExtensionCleanupCompleted.fire(event);
+    return result;
+  }
+  /**
+   * Check if update is a security update (simplified logic)
+   */
+  isSecurityUpdate(_currentVersion, _targetVersion) {
+    // Simple heuristic - in a real implementation, this would check
+    // security advisories or version metadata
+    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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-service.test.d.ts","sourceRoot":"","sources":["../../src/services/installed-extension-service.test.ts"],"names":[],"mappings":""}

package/lib/store/index.d.ts

@@ -1,3 +1,3 @@
 export * from './models';
-export * from './repository';
+export * from './repositories';
 //# sourceMappingURL=index.d.ts.map

package/lib/store/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/store/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/store/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC"}

package/lib/store/models/index.d.ts

@@ -1,2 +1,3 @@
 export * from './registry-extension-model';
+export * from './installed-extension-model';
 //# sourceMappingURL=index.d.ts.map

package/lib/store/models/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/store/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/store/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC"}

package/lib/store/models/installed-extension-model.d.ts

@@ -0,0 +1,4 @@
+import { IInstalledExtensionModel } from 'common/server';
+import { Connection, Schema } from 'mongoose';
+export declare const InstalledExtensionModelFunc: (db: Connection) => import("mongoose").Model<IInstalledExtensionModel, {}, {}, {}, Schema<IInstalledExtensionModel, import("mongoose").Model<IInstalledExtensionModel, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IInstalledExtensionModel>>;
+//# sourceMappingURL=installed-extension-model.d.ts.map

package/lib/store/models/installed-extension-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-model.d.ts","sourceRoot":"","sources":["../../../src/store/models/installed-extension-model.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,wBAAwB,EAQ3B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAyR9C,eAAO,MAAM,2BAA2B,GAAI,IAAI,UAAU,gQACe,CAAC"}