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

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

@@ -0,0 +1,311 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import'@cdm-logger/core';import {DisposableCollection,Emitter}from'@adminide-stack/core';import {SERVER_TYPES,ExtensionRegistryStatus}from'common/server';let ExtensionGalleryService = class ExtensionGalleryService {
+  logger;
+  registryExtensionService;
+  publisherService;
+  galleryRepository;
+  disposables = new DisposableCollection();
+  _onDidChange = new Emitter();
+  onDidChange = this._onDidChange.event;
+  constructor(logger, registryExtensionService, publisherService, galleryRepository) {
+    this.logger = logger;
+    this.registryExtensionService = registryExtensionService;
+    this.publisherService = publisherService;
+    this.galleryRepository = galleryRepository;
+    this.disposables.push(this._onDidChange);
+  }
+  isEnabled() {
+    return true;
+  }
+  async query(options = {}) {
+    this.logger.trace('ExtensionGalleryService.query with options: %j', options);
+    try {
+      const {
+        text = '',
+        pageSize = 50
+      } = options;
+      const extensions = await this.registryExtensionService.findExtensions(pageSize, text, false,
+      // local
+      true);
+      const galleryExtensions = await Promise.all(extensions.map(ext => this.toGalleryExtension(ext)));
+      return {
+        __typename: 'GalleryPager',
+        firstPage: galleryExtensions,
+        total: galleryExtensions.length,
+        pageSize,
+        page: 0
+      };
+    } catch (error) {
+      this.logger.error('ExtensionGalleryService.query error: %s', error.message);
+      return {
+        __typename: 'GalleryPager',
+        firstPage: [],
+        total: 0,
+        pageSize: options.pageSize || 50,
+        page: 0
+      };
+    }
+  }
+  async getExtension(identifier) {
+    this.logger.trace('ExtensionGalleryService.getExtension: %s', typeof identifier === 'string' ? identifier : identifier.id);
+    try {
+      const extensionId = typeof identifier === 'string' ? identifier : identifier.id;
+      const extension = await this.registryExtensionService.findExtension(extensionId);
+      if (!extension) {
+        return null;
+      }
+      return this.toGalleryExtension(extension);
+    } catch (error) {
+      this.logger.error('ExtensionGalleryService.getExtension error: %s', error.message);
+      return null;
+    }
+  }
+  async download(extension) {
+    this.logger.trace('ExtensionGalleryService.download: %s', extension.id);
+    try {
+      const success = await this.galleryRepository.download(extension);
+      if (success) {
+        // Return the download URL for the extension
+        const downloadUrl = extension.assets?.download?.uri || `${extension.url}/${extension.version}.vsix`;
+        this.logger.info('Extension download prepared: %s -> %s', extension.id, downloadUrl);
+        return downloadUrl;
+      }
+      throw new Error(`Failed to prepare download for extension: ${extension.id}`);
+    } catch (error) {
+      this.logger.error('ExtensionGalleryService.download error: %s', error.message);
+      throw error;
+    }
+  }
+  async getReadme(extension) {
+    this.logger.trace('ExtensionGalleryService.getReadme: %s', extension.id);
+    try {
+      const readmeUrl = extension.assets?.readme?.uri;
+      if (!readmeUrl) {
+        return 'No README available for this extension.';
+      }
+      const readmeAsset = await this.galleryRepository.asset(extension.extensionSlug || extension.id, extension.version, 'README.md');
+      return readmeAsset || 'README content could not be loaded.';
+    } catch (error) {
+      this.logger.warn('Failed to fetch README for %s: %s', extension.id, error.message);
+      return 'Error loading README content.';
+    }
+  }
+  async getManifest(extension) {
+    this.logger.trace('ExtensionGalleryService.getManifest: %s', extension.id);
+    try {
+      // First try to return the already loaded manifest
+      if (extension.manifest) {
+        return extension.manifest;
+      }
+      // If not available, try to fetch from repository
+      const manifestAsset = await this.galleryRepository.asset(extension.extensionSlug || extension.id, extension.version, 'package.json');
+      return manifestAsset;
+    } catch (error) {
+      this.logger.warn('Failed to fetch manifest for %s: %s', extension.id, error.message);
+      return null;
+    }
+  }
+  async getChangelog(extension) {
+    this.logger.trace('ExtensionGalleryService.getChangelog: %s', extension.id);
+    try {
+      const changelogUrl = extension.assets?.changelog?.uri;
+      if (!changelogUrl) {
+        return 'No changelog available for this extension.';
+      }
+      const changelogAsset = await this.galleryRepository.asset(extension.extensionSlug || extension.id, extension.version, 'CHANGELOG.md');
+      return changelogAsset || 'Changelog content could not be loaded.';
+    } catch (error) {
+      this.logger.warn('Failed to fetch changelog for %s: %s', extension.id, error.message);
+      return 'Error loading changelog content.';
+    }
+  }
+  async getLicense(extension) {
+    this.logger.trace('ExtensionGalleryService.getLicense: %s', extension.id);
+    try {
+      const licenseUrl = extension.assets?.license?.uri;
+      if (!licenseUrl) {
+        return 'No license information available for this extension.';
+      }
+      const licenseAsset = await this.galleryRepository.asset(extension.extensionSlug || extension.id, extension.version, 'LICENSE');
+      return licenseAsset || 'License content could not be loaded.';
+    } catch (error) {
+      this.logger.warn('Failed to fetch license for %s: %s', extension.id, error.message);
+      return 'Error loading license information.';
+    }
+  }
+  async loadCompatibleVersion(extension) {
+    this.logger.trace('ExtensionGalleryService.loadCompatibleVersion: %s', extension.id);
+    try {
+      // Get all extensions from registry (search for this specific extension)
+      const allExtensions = await this.registryExtensionService.findExtensions(100, `${extension.publisher.displayName}.${extension.name}`, true, true);
+      // Filter to get versions of the same extension
+      const extensionVersions = allExtensions.filter(ext => ext.name === extension.name);
+      if (!extensionVersions || extensionVersions.length === 0) {
+        // If no versions found, return the current extension
+        return extension;
+      }
+      // Find the latest compatible version
+      const latestVersion = extensionVersions.sort((a, b) => b.version.localeCompare(a.version, undefined, {
+        numeric: true
+      }))[0];
+      // Convert to gallery extension if different from current
+      if (latestVersion.version !== extension.version) {
+        return this.toGalleryExtension(latestVersion);
+      }
+      return extension;
+    } catch (error) {
+      this.logger.warn('Failed to load compatible version for %s: %s', extension.id, error.message);
+      // Return original extension if we can't find a compatible version
+      return extension;
+    }
+  }
+  async toGalleryExtension(registryExt) {
+    let publisherInfo = null;
+    try {
+      const publisherId = registryExt.publisherId || registryExt.publisher;
+      if (publisherId) {
+        publisherInfo = await this.publisherService.findById(publisherId);
+      }
+    } catch (error) {
+      this.logger.warn('Failed to get publisher info: %s', error.message);
+    }
+    const manifest = this.getManifestFromRelease(registryExt);
+    const galleryExtension = {
+      __typename: 'GalleryExtension',
+      id: registryExt.id || registryExt._id?.toString() || '',
+      uuid: registryExt.uuid,
+      name: registryExt.name,
+      displayName: manifest?.displayName || registryExt.name,
+      description: manifest?.description || '',
+      version: registryExt.version || '0.0.1',
+      extensionSlug: registryExt.extensionSlug,
+      manifest: manifest,
+      publisher: publisherInfo,
+      publisherId: publisherInfo?.id || '',
+      installed: registryExt.installed || false,
+      updatedAt: registryExt.updatedAt,
+      url: registryExt.url,
+      remoteURL: registryExt.remoteURL,
+      status: ExtensionRegistryStatus.Active,
+      viewerCanAdminister: registryExt.viewerCanAdminister || false,
+      isLocal: registryExt.isLocal || false,
+      categories: manifest?.categories || [],
+      tags: manifest?.keywords || [],
+      releases: registryExt.releases || [],
+      downloadCount: 0,
+      installCount: 0,
+      weeklyDownloads: 0,
+      rating: 0,
+      ratingCount: 0,
+      featured: false,
+      preview: false,
+      date: registryExt.updatedAt?.toISOString(),
+      assets: {
+        __typename: 'GalleryExtensionAssets',
+        icon: {
+          __typename: 'GalleryExtensionAsset',
+          uri: manifest?.icon || './media/defaultIcon.png',
+          fallbackUri: './media/defaultIcon.png'
+        },
+        readme: {
+          __typename: 'GalleryExtensionAsset',
+          uri: `${registryExt.url}/README.md`,
+          fallbackUri: `${registryExt.url}/README.md`
+        },
+        changelog: {
+          __typename: 'GalleryExtensionAsset',
+          uri: `${registryExt.url}/CHANGELOG.md`,
+          fallbackUri: `${registryExt.url}/CHANGELOG.md`
+        },
+        license: {
+          __typename: 'GalleryExtensionAsset',
+          uri: `${registryExt.url}/LICENSE`,
+          fallbackUri: `${registryExt.url}/LICENSE`
+        },
+        download: {
+          __typename: 'GalleryExtensionAsset',
+          uri: `${registryExt.url}/${registryExt.version}.vsix`,
+          fallbackUri: `${registryExt.url}/${registryExt.version}.vsix`
+        },
+        manifest: {
+          __typename: 'GalleryExtensionAsset',
+          uri: `${registryExt.url}/package.json`,
+          fallbackUri: `${registryExt.url}/package.json`
+        }
+      },
+      properties: {
+        __typename: 'GalleryExtensionProperties',
+        dependencies: manifest?.extensionDependencies || [],
+        extensionPack: manifest?.extensionPack || [],
+        engine: manifest?.engines?.vscode || 'unknown',
+        localizedLanguages: []
+      },
+      resources: {
+        __typename: 'GalleryExtensionResources',
+        license: `${registryExt.url}/LICENSE`,
+        repository: manifest?.repository?.url || '',
+        changelog: `${registryExt.url}/CHANGELOG.md`,
+        download: `${registryExt.url}/${registryExt.version}.vsix`,
+        icon: manifest?.icon || './media/defaultIcon.png',
+        manifest: `${registryExt.url}/package.json`,
+        readme: `${registryExt.url}/README.md`
+      },
+      coreExtension: registryExt,
+      identifier: {
+        __typename: 'ExtensionIdentifier',
+        id: registryExt.extensionSlug || registryExt.id,
+        uuid: registryExt.uuid
+      }
+    };
+    return galleryExtension;
+  }
+  async getAllVersions(extension) {
+    this.logger.trace('ExtensionGalleryService.getAllVersions: %s', extension.id);
+    try {
+      // Get all versions from registry
+      const allExtensions = await this.registryExtensionService.findExtensions(1000,
+      // Get more versions
+      `${extension.publisher.displayName}.${extension.name}`, true, true);
+      // Filter to get all versions of the same extension
+      const extensionVersions = allExtensions.filter(ext => ext.name === extension.name);
+      // Convert all to gallery extensions and sort by version (newest first)
+      const galleryVersions = await Promise.all(extensionVersions.map(ext => this.toGalleryExtension(ext)));
+      // Sort by version (descending)
+      return galleryVersions.sort((a, b) => b.version.localeCompare(a.version, undefined, {
+        numeric: true
+      }));
+    } catch (error) {
+      this.logger.warn('Failed to get all versions for %s: %s', extension.id, error.message);
+      // Return empty array if we can't find versions
+      return [];
+    }
+  }
+  /**
+   * Helper method to get manifest from the current release
+   * Since manifests are stored in releases, not directly in the registry extension
+   */
+  getManifestFromRelease(registryExt) {
+    const {
+      releases
+    } = registryExt;
+    if (!releases || releases.length === 0) {
+      return null;
+    }
+    // Find the current release that matches the extension's version
+    const currentRelease = releases.find(release => release.version === registryExt.version);
+    if (!currentRelease || !currentRelease.manifest) {
+      return null;
+    }
+    try {
+      // Parse the manifest from the release (stored as JSON string)
+      const parsedManifest = typeof currentRelease.manifest === 'string' ? JSON.parse(currentRelease.manifest) : currentRelease.manifest;
+      return parsedManifest;
+    } catch (error) {
+      this.logger.warn('Failed to parse extension manifest for', registryExt.extensionSlug, ':', error);
+      return null;
+    }
+  }
+  dispose() {
+    this.disposables.dispose();
+  }
+};
+ExtensionGalleryService = __decorate([injectable(), __param(0, inject('Logger')), __param(1, inject(SERVER_TYPES.IRegistryExtensionService)), __param(2, inject(SERVER_TYPES.IMarketplacePublisherService)), __param(3, inject(SERVER_TYPES.IExtensionGalleryRepository)), __metadata("design:paramtypes", [Object, Object, Object, Object])], ExtensionGalleryService);export{ExtensionGalleryService};//# sourceMappingURL=extension-gallery-service.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extension-gallery-service.js","sources":["../../src/services/extension-gallery-service.ts"],"sourcesContent":[null],"names":[],"mappings":"0PAgCQ,uBAAiB,GAAA,MAAA,uBAAgB,CAAA;QAEjC;AAbJ,EAAA,wBAAiB;AAEjB,EAAA,gBAAQ;AAER,EAAA;AAGuC,EAAA,WAAA,GAAA,IAAA,oBAAkB;AAWlD,EAAA,eAAa,IAAA,OAAO,EAAA;oBAIC,CAAA,YAAkB,MAAG;AAkCpC,EAAA,WAAA,CAAA,MAAa,EAAA,wBAAY,EAAA,gBAAgC,EAAA,iBAAQ,EAAA;IAqBjE,IAAA,CAAA,eAAoB;IAkBpB,IAAA,CAAA,wBAAqB,GAAA,wBAAmC;IAsBxD,IAAA,CAAA,gBAAqB,GAAE,gBAAiB;IAuBxC,IAAA,CAAA,iBAAsB,GAAE;IAsBxB,IAAA,CAAA,gBAAoB,CAAE,IAAA,CAAA,YAAiB;;cA4DtC;IAwHD,OAAA,IAAA;AA2Bb,EAAA;;;AAGG,IAAA,IAAA;AACH,MAAA,MAAQ;AA2BD,QAAA,OAAW,EAAA;AAGrB,QAAA,QAAA,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/services/index.d.ts

@@ -1,2 +1,7 @@
-export * from './extension-service';
+export * from './installed-extension-service';
+export * from './installed-extension-service-ext';
+export * from './publisher-service';
+export * from './publisher-event-service';
+export * from './extension-gallery-service';
+export * from './extension-gallery-repository';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC"}

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

@@ -0,0 +1,16 @@
+import { ServiceBroker } from 'moleculer';
+import { CdmLogger } from '@cdm-logger/core';
+import { IRegistryExtensionService, IInstalledExtensionRepository, ISlugService, IRedisCacheManager } from 'common/server';
+import { InstalledExtensionService } from './installed-extension-service';
+/**
+ * Extended InstalledExtensionService that handles Moleculer event broadcasting
+ * Follows the pattern of AccountService/AccountServiceExt
+ */
+export declare class InstalledExtensionServiceExt extends InstalledExtensionService {
+    protected slugService: ISlugService;
+    protected readonly redisCacheManager: IRedisCacheManager;
+    constructor(repository: IInstalledExtensionRepository, registryService: IRegistryExtensionService, slugService: ISlugService, redisCacheManager: IRedisCacheManager, broker: ServiceBroker, logger: CdmLogger.ILogger);
+    private setupEventListeners;
+    private dropCache;
+}
+//# sourceMappingURL=installed-extension-service-ext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-service-ext.d.ts","sourceRoot":"","sources":["../../src/services/installed-extension-service-ext.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAgBH,yBAAyB,EACzB,6BAA6B,EAO7B,YAAY,EACZ,kBAAkB,EACrB,MAAM,eAAe,CAAC;AAQvB,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AA0D1E;;;GAGG;AACH,qBACa,4BAA6B,SAAQ,yBAAyB;IAKnE,SAAS,CAAC,WAAW,EAAE,YAAY;IAEnC,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAE,kBAAkB;gBALJ,UAAU,EAAE,6BAA6B,EAC7C,eAAe,EAAE,yBAAyB,EAEhF,WAAW,EAAE,YAAY,EAEhB,iBAAiB,EAAE,kBAAkB,EACnB,MAAM,EAAE,aAAa,EAC/B,MAAM,EAAE,SAAS,CAAC,OAAO;IAMxD,OAAO,CAAC,mBAAmB;YAoeb,SAAS;CA6C1B"}