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

package/lib/services/publisher-event-service.d.ts

@@ -0,0 +1,48 @@
+import { CdmLogger } from '@cdm-logger/core';
+import { Disposable, DisposableCollection } from '@adminide-stack/core';
+import * as mongoose from 'mongoose';
+import { TrendDirection, IPublisherEventService } from 'common/server';
+export declare class PublisherEventService implements IPublisherEventService, Disposable {
+    protected readonly toDispose: DisposableCollection;
+    private logger;
+    private db;
+    constructor(db: mongoose.Connection, logger: CdmLogger.ILogger);
+    dispose(): void;
+    recordEvent(event: {
+        publisherId: string;
+        extensionId?: string;
+        eventType: 'download' | 'install' | 'view' | 'rating';
+        value?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    getPublisherStats(publisherId: string): Promise<{
+        totalDownloads: number;
+        totalInstalls: number;
+        totalViews: number;
+        totalRatings: number;
+        averageRating: number;
+        extensionCount: number;
+        lastUpdated: Date;
+    }>;
+    getPublisherAnalytics(publisherId: string, startDate: Date, endDate: Date, granularity: string): Promise<Array<{
+        date: Date;
+        downloads: number;
+        installs: number;
+        views: number;
+        ratings: number;
+        averageRating: number;
+        uniqueUsers: number;
+    }>>;
+    getPublisherTrends(publisherId: string, days: number): Promise<{
+        downloadTrend: TrendDirection;
+        downloadChange: number;
+        installTrend: TrendDirection;
+        installChange: number;
+        viewTrend: TrendDirection;
+        viewChange: number;
+        ratingTrend: TrendDirection;
+        ratingChange: number;
+        trendScore: number;
+    }>;
+}
+//# sourceMappingURL=publisher-event-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-event-service.d.ts","sourceRoot":"","sources":["../../src/services/publisher-event-service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAEvE,qBACa,qBAAsB,YAAW,sBAAsB,EAAE,UAAU;IAC5E,SAAS,CAAC,QAAQ,CAAC,SAAS,uBAA8B;IAE1D,OAAO,CAAC,MAAM,CAAoB;IAElC,OAAO,CAAC,EAAE,CAAsB;gBAES,EAAE,EAAE,QAAQ,CAAC,UAAU,EAAoB,MAAM,EAAE,SAAS,CAAC,OAAO;IAKtG,OAAO,IAAI,IAAI;IAIT,WAAW,CAAC,KAAK,EAAE;QAC5B,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;QACtD,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACtC,GAAG,OAAO,CAAC,IAAI,CAAC;IAUJ,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;QACzD,cAAc,EAAE,MAAM,CAAC;QACvB,aAAa,EAAE,MAAM,CAAC;QACtB,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;QACvB,WAAW,EAAE,IAAI,CAAC;KACrB,CAAC;IA4CW,qBAAqB,CAC9B,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,IAAI,EACf,OAAO,EAAE,IAAI,EACb,WAAW,EAAE,MAAM,GACpB,OAAO,CACN,KAAK,CAAC;QACF,IAAI,EAAE,IAAI,CAAC;QACX,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,MAAM,CAAC;KACvB,CAAC,CACL;IAwEY,kBAAkB,CAC3B,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,GACb,OAAO,CAAC;QACP,aAAa,EAAE,cAAc,CAAC;QAC9B,cAAc,EAAE,MAAM,CAAC;QACvB,YAAY,EAAE,cAAc,CAAC;QAC7B,aAAa,EAAE,MAAM,CAAC;QACtB,SAAS,EAAE,cAAc,CAAC;QAC1B,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,cAAc,CAAC;QAC5B,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;CAuFL"}

package/lib/services/publisher-event-service.js

@@ -0,0 +1,296 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import'@cdm-logger/core';import {DisposableCollection}from'@adminide-stack/core';import*as mongoose from'mongoose';import {TrendDirection}from'common/server';var PublisherEventService_1;
+let PublisherEventService = PublisherEventService_1 = class PublisherEventService {
+  toDispose = new DisposableCollection();
+  logger;
+  db;
+  constructor(db, logger) {
+    this.db = db;
+    this.logger = logger.child({
+      className: PublisherEventService_1.name
+    });
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+  async recordEvent(event) {
+    this.logger.trace('Recording event [%j]', event);
+    const publisherEvents = this.db.collection('publisher_events');
+    await publisherEvents.insertOne({
+      ...event,
+      timestamp: new Date()
+    });
+  }
+  async getPublisherStats(publisherId) {
+    this.logger.trace('Getting publisher stats for publisherId [%s]', publisherId);
+    const publisherEvents = this.db.collection('publisher_events');
+    const stats = await publisherEvents.aggregate([{
+      $match: {
+        publisherId
+      }
+    }, {
+      $group: {
+        _id: null,
+        totalDownloads: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'download']
+            }, 1, 0]
+          }
+        },
+        totalInstalls: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'install']
+            }, 1, 0]
+          }
+        },
+        totalViews: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'view']
+            }, 1, 0]
+          }
+        },
+        totalRatings: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'rating']
+            }, 1, 0]
+          }
+        },
+        averageRating: {
+          $avg: {
+            $cond: [{
+              $eq: ['$eventType', 'rating']
+            }, '$value', null]
+          }
+        },
+        uniqueExtensions: {
+          $addToSet: '$extensionId'
+        }
+      }
+    }]).toArray();
+    const result = stats[0] || {};
+    return {
+      totalDownloads: result.totalDownloads || 0,
+      totalInstalls: result.totalInstalls || 0,
+      totalViews: result.totalViews || 0,
+      totalRatings: result.totalRatings || 0,
+      averageRating: result.averageRating || 0,
+      extensionCount: result.uniqueExtensions ? result.uniqueExtensions.length : 0,
+      lastUpdated: new Date()
+    };
+  }
+  async getPublisherAnalytics(publisherId, startDate, endDate, granularity) {
+    this.logger.trace('Getting publisher analytics for publisherId [%s], period [%s - %s]', publisherId, startDate.toISOString(), endDate.toISOString());
+    const publisherEvents = this.db.collection('publisher_events');
+    const analytics = await publisherEvents.aggregate([{
+      $match: {
+        publisherId,
+        timestamp: {
+          $gte: startDate,
+          $lte: endDate
+        }
+      }
+    }, {
+      $group: {
+        _id: {
+          $dateTrunc: {
+            date: '$timestamp',
+            unit: granularity.toLowerCase()
+          }
+        },
+        downloads: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'download']
+            }, 1, 0]
+          }
+        },
+        installs: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'install']
+            }, 1, 0]
+          }
+        },
+        views: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'view']
+            }, 1, 0]
+          }
+        },
+        ratings: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'rating']
+            }, 1, 0]
+          }
+        },
+        averageRating: {
+          $avg: {
+            $cond: [{
+              $eq: ['$eventType', 'rating']
+            }, '$value', null]
+          }
+        },
+        uniqueUsers: {
+          $addToSet: '$metadata.userId'
+        }
+      }
+    }, {
+      $project: {
+        date: '$_id',
+        downloads: 1,
+        installs: 1,
+        views: 1,
+        ratings: 1,
+        averageRating: {
+          $ifNull: ['$averageRating', 0]
+        },
+        uniqueUsers: {
+          $size: {
+            $ifNull: ['$uniqueUsers', []]
+          }
+        }
+      }
+    }, {
+      $sort: {
+        date: 1
+      }
+    }]).toArray();
+    return analytics;
+  }
+  async getPublisherTrends(publisherId, days) {
+    this.logger.trace('Getting publisher trends for publisherId [%s], days [%d]', publisherId, days);
+    const publisherEvents = this.db.collection('publisher_events');
+    const endDate = new Date();
+    const startDate = new Date();
+    startDate.setDate(startDate.getDate() - days);
+    // Get trends by comparing recent period vs previous period
+    const midDate = new Date();
+    midDate.setDate(midDate.getDate() - Math.floor(days / 2));
+    const [recentStats, previousStats] = await Promise.all([publisherEvents.aggregate([{
+      $match: {
+        publisherId,
+        timestamp: {
+          $gte: midDate,
+          $lte: endDate
+        }
+      }
+    }, {
+      $group: {
+        _id: null,
+        downloads: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'download']
+            }, 1, 0]
+          }
+        },
+        installs: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'install']
+            }, 1, 0]
+          }
+        },
+        views: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'view']
+            }, 1, 0]
+          }
+        },
+        ratings: {
+          $avg: {
+            $cond: [{
+              $eq: ['$eventType', 'rating']
+            }, '$value', null]
+          }
+        }
+      }
+    }]).toArray(), publisherEvents.aggregate([{
+      $match: {
+        publisherId,
+        timestamp: {
+          $gte: startDate,
+          $lt: midDate
+        }
+      }
+    }, {
+      $group: {
+        _id: null,
+        downloads: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'download']
+            }, 1, 0]
+          }
+        },
+        installs: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'install']
+            }, 1, 0]
+          }
+        },
+        views: {
+          $sum: {
+            $cond: [{
+              $eq: ['$eventType', 'view']
+            }, 1, 0]
+          }
+        },
+        ratings: {
+          $avg: {
+            $cond: [{
+              $eq: ['$eventType', 'rating']
+            }, '$value', null]
+          }
+        }
+      }
+    }]).toArray()]);
+    const recent = recentStats[0] || {};
+    const previous = previousStats[0] || {};
+    const calculateTrend = (recentValue, previousValue) => {
+      if (!previousValue || previousValue === 0) {
+        return recentValue > 0 ? {
+          trend: TrendDirection.Increasing,
+          change: 100
+        } : {
+          trend: TrendDirection.Stable,
+          change: 0
+        };
+      }
+      const change = (recentValue - previousValue) / previousValue * 100;
+      if (Math.abs(change) < 5) return {
+        trend: TrendDirection.Stable,
+        change
+      };
+      return {
+        trend: change > 0 ? TrendDirection.Increasing : TrendDirection.Decreasing,
+        change
+      };
+    };
+    const downloadTrend = calculateTrend(recent.downloads || 0, previous.downloads || 0);
+    const installTrend = calculateTrend(recent.installs || 0, previous.installs || 0);
+    const viewTrend = calculateTrend(recent.views || 0, previous.views || 0);
+    const ratingTrend = calculateTrend(recent.ratings || 0, previous.ratings || 0);
+    // Calculate composite trend score
+    const trendScore = (downloadTrend.change + installTrend.change + viewTrend.change + ratingTrend.change) / 4;
+    return {
+      downloadTrend: downloadTrend.trend,
+      downloadChange: downloadTrend.change,
+      installTrend: installTrend.trend,
+      installChange: installTrend.change,
+      viewTrend: viewTrend.trend,
+      viewChange: viewTrend.change,
+      ratingTrend: ratingTrend.trend,
+      ratingChange: ratingTrend.change,
+      trendScore
+    };
+  }
+};
+PublisherEventService = PublisherEventService_1 = __decorate([injectable(), __param(0, inject('MongoDBConnection')), __param(1, inject('Logger')), __metadata("design:paramtypes", [mongoose.Connection, Object])], PublisherEventService);export{PublisherEventService};//# sourceMappingURL=publisher-event-service.js.map

package/lib/services/publisher-event-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-event-service.js","sources":["../../src/services/publisher-event-service.ts"],"sourcesContent":[null],"names":[],"mappings":"0PACA,IAAA;IAWI,qBAAgC,GAAA,uBAAA,GAAA,MAAA,qBAAA,CAAA;kBAEW,oBAAW;AAK/C,EAAA,MAAA;IAIM;aACT,CAAA,EAAA,EAAA;QACA,CAAA,EAAA,GAAA,EAAA;QACA,CAAA,MAAA,GAAS,YAAY,CAAA;eACf,EAAE,uBAAO,CAAA;;;AAYN,EAAA,OAAA,GAAA;QACT,CAAA,SAAA,CAAA;;QAEA,WAAU,CAAE,OAAO;QACnB,CAAA,MAAA,CAAA,KAAY,CAAE,sBAAO,EAAA,KAAA,CAAA;UACrB,sBAAsB,CAAA,EAAA,CAAA,UAAA,CAAA,kBAAA,CAAA;UACtB,yBAAuB,CAAA;SACvB,KAAA;MACF,SAAA,EAAA,IAAA,IAAA;KA4CW,CAAA;;QAQL,iBAAiB,CAAC,WAAA,EAAA;QAClB,CAAA,MAAA,CAAQ,oDAAS,EAAA,WAAA,CAAA;UACjB,eAAc,GAAA,IAAA,CAAA,EAAA,CAAA,UAAA,CAAA,kBAAA,CAAA;UACd,KAAO,SAAS,eAAA,CAAA,SAAA,CAAA,CAAA;YAChB,EAAA;QACA;AACH;KAyEQ,EAAA;YAIT,EAAA;QACA,GAAA,EAAA,IAAA;QACA,cAAc;UACd,IAAA,EAAA;YACA,KAAS,EAAE;cACX,GAAA,EAAU,CAAE,YAAO,EAAA,UAAA;aACnB,EAAA,CAAA,EAAA,CAAW;;SAEX;QACF,aAAA,EAAA;AAuFL,UAAA,IAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/services/publisher-service-context.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=publisher-service-context.d.ts.map

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

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

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

@@ -0,0 +1,60 @@
+import { CdmLogger } from '@cdm-logger/core';
+import { BaseService2 } from '@common-stack/store-mongo';
+import { Disposable, DisposableCollection, Emitter } from '@adminide-stack/core';
+import { IMarketplacePublisherService, IMarketplacePublisherRepository, AsDomainType, IMarketplacePublisherModel } from 'common/server';
+export declare class MarketplacePublisherService extends BaseService2<IMarketplacePublisherModel> implements IMarketplacePublisherService, Disposable {
+    protected readonly onPublisherCreated: Emitter<{
+        publisherId: string;
+        publisherName: string;
+        displayName: string;
+        createdAt: string;
+    }>;
+    protected readonly onPublisherUpdated: Emitter<{
+        publisherId: string;
+        changes: Record<string, unknown>;
+        updatedAt: string;
+    }>;
+    protected readonly onPublisherVerified: Emitter<{
+        publisherId: string;
+        verifiedAt: string;
+    }>;
+    protected readonly toDispose: DisposableCollection;
+    private logger;
+    constructor(repository: IMarketplacePublisherRepository, logger: CdmLogger.ILogger);
+    dispose(): void;
+    findById(id: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    findByPublisherName(publisherName: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    findPublishers(search?: string, orderBy?: string, orderDirection?: 'ASC' | 'DESC', first?: number, after?: number): Promise<{
+        publishers: AsDomainType<IMarketplacePublisherModel>[];
+        totalCount: number;
+    }>;
+    createPublisher(data: {
+        displayName: string;
+        publisherName: string;
+        description?: string;
+        website?: string;
+        email?: string;
+        domain?: string;
+    }): Promise<AsDomainType<IMarketplacePublisherModel>>;
+    updatePublisher(publisherId: string, data: {
+        displayName?: string;
+        description?: string;
+        website?: string;
+        avatarUrl?: string;
+    }): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    updatePublisherStats(publisherId: string, stats: {
+        extensionCount?: number;
+        totalInstalls?: number;
+        averageRating?: number;
+    }): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    verifyPublisher(publisherId: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    getPublisherStats(publisherId: string): Promise<{
+        totalExtensions: number;
+        totalDownloads: number;
+        totalInstallations: number;
+        averageRating: number;
+        verifiedCount: number;
+        topExtension?: unknown;
+    } | null>;
+}
+//# sourceMappingURL=publisher-service.d.ts.map

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

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

package/lib/services/publisher-service.js

@@ -0,0 +1,134 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import'@cdm-logger/core';import {BaseService2}from'@common-stack/store-mongo';import {Emitter,DisposableCollection}from'@adminide-stack/core';import {SERVER_TYPES}from'common/server';import {validatePublisherData}from'../utils/publisherValidation.js';var MarketplacePublisherService_1;
+let MarketplacePublisherService = MarketplacePublisherService_1 = class MarketplacePublisherService extends BaseService2 {
+  onPublisherCreated = new Emitter();
+  onPublisherUpdated = new Emitter();
+  onPublisherVerified = new Emitter();
+  toDispose = new DisposableCollection(this.onPublisherCreated, this.onPublisherUpdated, this.onPublisherVerified);
+  logger;
+  constructor(repository, logger) {
+    super(repository);
+    this.logger = logger.child({
+      className: MarketplacePublisherService_1.name
+    });
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+  async findById(id) {
+    this.logger.trace('findById with id [%s]', id);
+    // Use inherited get method from BaseService
+    const result = await this.get(id);
+    this.logger.trace('findById result: %j', result);
+    return result;
+  }
+  async findByPublisherName(publisherName) {
+    this.logger.trace('findByPublisherName with publisherName [%s]', publisherName);
+    const result = await this.repository.findByPublisherName(publisherName);
+    return result ? result : null;
+  }
+  async findPublishers(search, orderBy = 'createdAt', orderDirection = 'DESC', first = 20, after = 0) {
+    this.logger.trace('findPublishers with search [%s], orderBy [%s], orderDirection [%s], first [%d], after [%d]', search, orderBy, orderDirection, first, after);
+    const result = await this.repository.findPublishers(search, orderBy, orderDirection, first, after);
+    return {
+      publishers: result.publishers,
+      totalCount: result.totalCount
+    };
+  }
+  async createPublisher(data) {
+    this.logger.trace('createPublisher with data [%j]', data);
+    // Validate publisher data
+    const validation = validatePublisherData({
+      publisherName: data.publisherName,
+      displayName: data.displayName,
+      email: data.email,
+      website: data.website,
+      description: data.description
+    });
+    if (!validation.valid) {
+      throw new Error(validation.error);
+    }
+    // Check if publisher name already exists
+    const existing = await this.repository.findByPublisherName(data.publisherName);
+    if (existing) {
+      throw new Error(`Publisher with name "${data.publisherName}" already exists`);
+    }
+    const publisherData = {
+      displayName: data.displayName,
+      name: data.publisherName.toLowerCase(),
+      description: data.description,
+      websiteUrl: data.website,
+      email: data.email,
+      verified: false,
+      extensionCount: 0,
+      totalDownloads: 0
+      // Remove fields that don't exist in the model
+      // flags: [],
+      // isDomainVerified: false,
+      // totalInstalls: 0,
+      // averageRating: 0,
+    };
+    const publisher = await this.repository.create(publisherData);
+    this.onPublisherCreated.fire({
+      publisherId: publisher.id,
+      publisherName: publisher.name,
+      displayName: publisher.displayName,
+      createdAt: publisher.createdAt.toISOString()
+    });
+    return publisher;
+  }
+  async updatePublisher(publisherId, data) {
+    this.logger.trace('updatePublisher for publisher [%s] with data [%j]', publisherId, data);
+    const updateData = {
+      ...data,
+      updatedAt: new Date()
+    };
+    const publisher = await this.update(publisherId, updateData);
+    if (publisher) {
+      this.onPublisherUpdated.fire({
+        publisherId: publisher.id,
+        changes: data,
+        updatedAt: publisher.updatedAt.toISOString()
+      });
+    }
+    return publisher ? publisher : null;
+  }
+  async updatePublisherStats(publisherId, stats) {
+    this.logger.trace('updatePublisherStats for publisher [%s] with stats [%j]', publisherId, stats);
+    const result = await this.repository.updatePublisherStats(publisherId, stats);
+    return result ? result : null;
+  }
+  async verifyPublisher(publisherId) {
+    this.logger.trace('verifyPublisher with publisherId [%s]', publisherId);
+    const publisher = await this.update(publisherId, {
+      verified: true
+    });
+    if (publisher) {
+      this.onPublisherVerified.fire({
+        publisherId: publisher.id,
+        verifiedAt: publisher.updatedAt.toISOString()
+      });
+    }
+    return publisher ? publisher : null;
+  }
+  async getPublisherStats(publisherId) {
+    this.logger.trace('getPublisherStats for publisher [%s]', publisherId);
+    const publisher = await this.findById(publisherId);
+    if (!publisher) {
+      return null;
+    }
+    // TODO: Implement proper logic to calculate averageRating, verifiedCount and topExtension
+    // For now, using placeholder values
+    return {
+      totalExtensions: publisher.extensionCount,
+      totalDownloads: publisher.totalDownloads,
+      totalInstallations: publisher.totalDownloads,
+      // Using totalDownloads as approximation
+      averageRating: 0,
+      // TODO: Calculate from actual extension ratings
+      verifiedCount: publisher.verified ? 1 : 0,
+      // Placeholder - should be calculated across all publishers
+      topExtension: null // TODO: Implement logic to find top extension
+    };
+  }
+};
+MarketplacePublisherService = MarketplacePublisherService_1 = __decorate([injectable(), __param(0, inject(SERVER_TYPES.IMarketplacePublisherRepository)), __param(1, inject('Logger')), __metadata("design:paramtypes", [Object, Object])], MarketplacePublisherService);export{MarketplacePublisherService};//# sourceMappingURL=publisher-service.js.map

package/lib/services/publisher-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-service.js","sources":["../../src/services/publisher-service.ts"],"sourcesContent":[null],"names":[],"mappings":"uVACA,IAAA;+BAoB2B,GAAA,6BAAA,GAAA,MAAA,2BAAA,SAAA,YAAA,CAAA;oBACR,GAAA,IAAM,OAAA,EAAA;AAChB,EAAA,kBAAA,GAAA,IAAA,OAAA,EAAA;qBAEK,GAAS,IAAA,OAAA,EAAA;sCACI,CAAA,IAAA,CAAA,kBAAA,EAAA,IAAA,CAAA,kBAAA,EAAA,IAAA,CAAA,mBAAA,CAAA;AACV,EAAA,MAAA;wBACE,EAAM,MAAA,EAAA;AAChB,IAAA,KAAA,CAAA,UAAA,CAAA;IAEL,IAAA,CAAA,MAAU,GAAA,MAAS,CAAA,KAAA,CAAA;8CACI,CAAA;;AAElB,EAAA;AAEL,EAAA,OAAA,GAAA;IAMA,IAAA,CAAA,SAAc,CAAoB,OAAA,EAAA;AAGwB,EAAA;AAOnD,EAAA,MAAA,QAAW,CAAA,EAAI,EAAA;AAIhB,IAAA,IAAA,CAAA,MAAW,CAAA,KAAE,CAAA,uBAAiB,EAAa,EAAA,CAAA;AAQpC;IAMA,MAAA,MAAA,GACT,MAAM,SAAS,EACf,CAAA;AAKA,IAAA,IAAA,CAAA,MAAA,CAAA,KAAY,CAAA,qBAAa,EAAA,MAAA,CAAA;WACzB,MAAA;;QAuBS,mBAAsB,CAAA,aAAA,EAAA;QAC/B,CAAA,MAAA,CAAA,KAAa,8CAAO,EAAA,aAAA,CAAA;UACpB,MAAA,GAAA,UAAqB,CAAC,UAAA,CAAA,mBAAA,CAAA,aAAA,CAAA;WACtB,MAAA,GAAY,MAAE,GAAO,IAAA;;QAErB,cAAc,CAAC,MAAA,EAAA,OAAA,GAAA,WAAA,EAAA,cAAA,GAAA,MAAA,EAAA,KAAA,GAAA,EAAA,EAAA,KAAA,GAAA,CAAA,EAAA;QACf,CAAA,MAAO,CAAA,KAAE,CAAA,4FAAO,EAAA,MAAA,EAAA,OAAA,EAAA,cAAA,EAAA,KAAA,EAAA,KAAA,CAAA;AACnB,IAAA,YAAW,GAAA,MAAA,IAAa,CAAA,UAAA,CAAA,cAA0B,CAAC,MAAC,EAAA,OAAA,EAAA,cAAA,EAAA,KAAA,EAAA,KAAA,CAAA;AAoDxC,IAAA,OAAA;gBAGL,EAAA,MAAc,CAAA,UAAO;gBACrB,EAAA,MAAc,CAAA;;;QAInB,eAAQ,CAAA,IAAY;AAqBV,IAAA,IAAA,CAAA,MAAA,CAAA,KAAA,CAAA,gCAEF,EAAA,IAAA,CAAA;;UAEH,UAAA,GAAc,qBAAS,CAAA;mBACvB,EAAa,IAAG,CAAA,aAAO;MAC1B,WACM,EAAA,IAAA,CAAA;AASE,MAAA,KAAA,EAAA,IAAA,CAAA,KAAgB;AAchB,MAAA,OAAA,EAAA,IAAA,CAAA,OAAkB;iBAC3B,EAAA,IAAe,CAAA;;QAEf,CAAA,UAAA,CAAA,KAAA,EAAkB;YAClB,IAAA,KAAa,CAAA,UAAS,CAAA,KAAA,CAAA;;;AAGzB,IAAA,cAAQ,GAAA,MAAA,IAAA,CAAA,UAAA,CAAA,mBAAA,CAAA,IAAA,CAAA,aAAA,CAAA;AA0BZ,IAAA,IAAA,QAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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';
+export * from './publisher-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,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,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;AAqP9C,eAAO,MAAM,2BAA2B,GAAI,IAAI,UAAU,gQACe,CAAC"}