@adminide-stack/marketplace-module-server 12.0.4-alpha.41 → 12.0.4-alpha.412

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

@@ -0,0 +1,521 @@
+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();
+  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, 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
+    });
+  }
+  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, 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) {
+      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)
+    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, 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({
+      organization: input.orgId,
+      extensionSlug: input.extensionSlug,
+      extension: registryExtension.id,
+      version: versionToUse,
+      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,
+      installedBy: input.installedBy,
+      installedVersion: installedExtension.installedVersion,
+      registryRef: registryExtension.id,
+      installedAt: new Date().toISOString(),
+      policies: input.policies,
+      settings: input.settings,
+      tenantId
+    };
+    this.onExtensionInstalled.fire(event);
+    this.logger.info(`Successfully installed extension ${input.extensionSlug}`);
+    return installedExtension;
+  }
+  /**
+   * Uninstall an extension
+   */
+  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) {
+      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
+    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 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,
+        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 [%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(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 ${extensionId} not found for org ${orgId}`);
+    }
+    // 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(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;
+  }
+  /**
+   * 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(orgId, extensionSlug, enabled, toggledBy, tenantId) {
+    const activationState = enabled ? ExtensionActivationState.Enabled : ExtensionActivationState.DisabledByUser;
+    const updatedExtension = await this.updateInstalledExtension(orgId, extensionSlug, {
+      settings: {
+        userEnabled: enabled
+      },
+      runtime: {
+        activationState,
+        ...(enabled ? {
+          lastActivated: new Date()
+        } : {
+          lastDeactivated: new Date()
+        })
+      },
+      lastUpdatedBy: toggledBy
+    }, tenantId);
+    // 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(orgId, extensionSlug, userConfig, updatedBy, tenantId) {
+    const updatedExtension = await this.updateInstalledExtension(orgId, extensionSlug, {
+      settings: {
+        userConfig
+      },
+      lastUpdatedBy: updatedBy
+    }, tenantId);
+    // Fire configuration update event
+    const event = {
+      extensionSlug,
+      tenantId,
+      updatedBy,
+      updatedAt: new Date().toISOString(),
+      configType: 'user',
+      newConfig: userConfig
+      // configurationChanges: userConfig,
+      // previousConfiguration: updatedExtension.settings.userConfig,
+    };
+    // Fire configuration update event
+    this.onExtensionConfigurationUpdated.fire(event);
+    return updatedExtension;
+  }
+  /**
+   * Check for extension updates and return available updates
+   */
+  async checkForUpdates(orgId, extensionSlug) {
+    const query = {
+      orgId
+    };
+    if (extensionSlug) {
+      const extensionId = await this.resolveExtensionSlug(extensionSlug);
+      query.extension = extensionId;
+    }
+    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({
+          extensionId: installed.extension?.toString(),
+          extensionSlug,
+          currentVersion: installed.installedVersion,
+          availableVersion: registryExtension.version,
+          isSecurityUpdate: this.isSecurityUpdate(installed.installedVersion, registryExtension.version)
+        });
+      }
+    }
+    return updates;
+  }
+  /**
+   * Update an extension to a newer version
+   */
+  async updateExtensionVersion(orgId, extensionSlug, targetVersion, updatedBy, tenantId) {
+    const extension = await this.getInstalledExtension(orgId, extensionSlug);
+    if (!extension) {
+      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(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,
+      updatedBy,
+      fromVersion: extension.installedVersion,
+      toVersion: targetVersion,
+      updatedAt: new Date().toISOString(),
+      isSecurityUpdate: this.isSecurityUpdate(extension.installedVersion, targetVersion),
+      tenantId
+    };
+    // Fire version update event
+    this.onExtensionVersionUpdated.fire(event);
+    return updatedExtension;
+  }
+  /**
+   * Sync installed extensions with registry status
+   */
+  async syncWithRegistry(orgId, tenantId) {
+    this.logger.info(`Syncing installed extensions with registry for organization ${orgId}`);
+    const installedExtensions = await this.installedExtensionRepository.findExtensions({
+      orgId
+    });
+    const syncUpdates = [];
+    for (const installed of installedExtensions) {
+      const registryExtension = await this.registryExtensionService.findExtension(installed.extension?.toString());
+      if (!registryExtension) {
+        // Extension removed from registry
+        syncUpdates.push({
+          orgId,
+          extensionId: installed.extension?.toString(),
+          registryStatus: 'removed',
+          isOrphaned: true
+        });
+      } else {
+        syncUpdates.push({
+          extensionId: installed.extension?.toString(),
+          registryStatus: registryExtension.status || 'active',
+          latestVersion: registryExtension.version,
+          isOrphaned: false,
+          orgId
+        });
+      }
+    }
+    // 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 = {
+      syncedAt: new Date().toISOString(),
+      extensionsChecked: syncUpdates.length,
+      // syncedExtensions: versionsUpdates.length,
+      extensionsOrphaned: orphanedUpdates.length,
+      extensionsUpdated: versionsUpdates.length,
+      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);
+    this.logger.info(`Synced ${syncUpdates.length} extensions with registry`);
+  }
+  /**
+   * Get extensions that need attention
+   */
+  async getExtensionsNeedingAttention(orgId) {
+    const extensions = await this.getInstalledExtensions({
+      orgId
+    });
+    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(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({
+      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(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(orgId, extension.extension?.toString(), 'system-cleanup', tenantId);
+        }
+        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(),
+      // cleanupAt: new Date().toISOString(),
+      warnings: result.warnings,
+      dryRun: false,
+      extensionsDeprecated: result.deprecated,
+      extensionsRemoved: result.removed
+    };
+    // 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(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

@@ -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 @@
+//# 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/services/publisher-analytics-service.d.ts

@@ -0,0 +1,128 @@
+import { CdmLogger } from '@cdm-logger/core';
+import { BaseService2 } from '@common-stack/store-mongo';
+import { Disposable, DisposableCollection, Emitter } from '@adminide-stack/core';
+import { IRegistryExtensionRepository, IRegistryExtensionModel } from 'common/server';
+export interface AnalyticsEvent {
+    eventType: string;
+    extensionSlug: string;
+    publisherId: string;
+    timestamp: string;
+    metadata?: string;
+    region?: string;
+    version?: string;
+}
+export interface AnalyticsDataPoint {
+    timestamp: string;
+    value: number;
+    secondaryValue?: number;
+}
+export interface VersionMetrics {
+    version: string;
+    downloads: number;
+    installations: number;
+    releasedAt: string;
+    adoptionRate: number;
+}
+export interface ExtensionMetrics {
+    extensionSlug: string;
+    name: string;
+    version?: string;
+    downloads: number;
+    installations: number;
+    rating?: number;
+    reviewCount: number;
+    revenue?: number;
+    lastUpdated?: string;
+    versionMetrics: VersionMetrics[];
+}
+export interface RegionMetrics {
+    region: string;
+    regionName: string;
+    downloads: number;
+    installations: number;
+    percentage: number;
+}
+export interface PublisherAnalyticsInput {
+    publisherId: string;
+    period: string;
+    extensionSlugs?: string[];
+    includeRevenue?: boolean;
+    includeRegions?: boolean;
+}
+export interface PublisherAnalyticsResult {
+    publisherId: string;
+    totalExtensions: number;
+    totalDownloads: number;
+    totalInstallations: number;
+    averageRating?: number;
+    period: string;
+    extensions: ExtensionMetrics[];
+    downloadTrend: AnalyticsDataPoint[];
+    installationTrend: AnalyticsDataPoint[];
+    popularRegions: RegionMetrics[];
+}
+export interface RevenueDataPoint {
+    timestamp: string;
+    revenue: number;
+    transactions: number;
+}
+export interface ExtensionRevenue {
+    extensionSlug: string;
+    name: string;
+    revenue: number;
+    paidInstallations: number;
+    arpu: number;
+}
+export interface PublisherRevenueAnalyticsInput {
+    publisherId: string;
+    period: string;
+    currency?: string;
+}
+export interface PublisherRevenueAnalyticsResult {
+    publisherId: string;
+    totalRevenue: number;
+    currency: string;
+    extensionRevenue: ExtensionRevenue[];
+    revenueTrend: RevenueDataPoint[];
+    topEarningExtensions: ExtensionRevenue[];
+}
+export interface TrackAnalyticsEventInput {
+    eventType: string;
+    extensionSlug: string;
+    userId?: string;
+    metadata?: string;
+    region?: string;
+    version?: string;
+}
+export interface TrackAnalyticsEventResult {
+    success: boolean;
+    message?: string;
+    eventId?: string;
+}
+export interface IPublisherAnalyticsService {
+    getPublisherAnalytics(input: PublisherAnalyticsInput): Promise<PublisherAnalyticsResult>;
+    getPublisherRevenueAnalytics(input: PublisherRevenueAnalyticsInput): Promise<PublisherRevenueAnalyticsResult>;
+    trackAnalyticsEvent(input: TrackAnalyticsEventInput): Promise<TrackAnalyticsEventResult>;
+    getRecentAnalyticsEvents(publisherId: string, limit?: number): Promise<AnalyticsEvent[]>;
+}
+export declare class PublisherAnalyticsService extends BaseService2<IRegistryExtensionModel> implements IPublisherAnalyticsService, Disposable {
+    private extensionRepository;
+    protected readonly onAnalyticsEvent: Emitter<AnalyticsEvent>;
+    protected readonly onDownloadEvent: Emitter<AnalyticsEvent>;
+    protected readonly onInstallationEvent: Emitter<AnalyticsEvent>;
+    protected readonly toDispose: DisposableCollection;
+    private logger;
+    constructor(extensionRepository: IRegistryExtensionRepository, logger: CdmLogger.ILogger);
+    dispose(): void;
+    getPublisherAnalytics(input: PublisherAnalyticsInput): Promise<PublisherAnalyticsResult>;
+    getPublisherRevenueAnalytics(input: PublisherRevenueAnalyticsInput): Promise<PublisherRevenueAnalyticsResult>;
+    trackAnalyticsEvent(input: TrackAnalyticsEventInput): Promise<TrackAnalyticsEventResult>;
+    getRecentAnalyticsEvents(publisherId: string, limit?: number): Promise<AnalyticsEvent[]>;
+    get analyticsEvents(): import("@adminide-stack/core").Event<AnalyticsEvent>;
+    get downloadEvents(): import("@adminide-stack/core").Event<AnalyticsEvent>;
+    get installationEvents(): import("@adminide-stack/core").Event<AnalyticsEvent>;
+    private generateTrendData;
+    private generateRegionData;
+    private generateRevenueTrend;
+}
+//# sourceMappingURL=publisher-analytics-service.d.ts.map

package/lib/services/publisher-analytics-service.d.ts.map

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