@adminide-stack/marketplace-module-server 12.0.4-alpha.44 → 12.0.4-alpha.441

package/lib/store/repositories/installed-extension-repository.js

@@ -0,0 +1,442 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,optional}from'inversify';import {DB_COLL_NAMES}from'common/server';import {BaseMongoRepository}from'@common-stack/store-mongo';import*as mongoose from'mongoose';import {InstalledExtensionModelFunc}from'../models/installed-extension-model.js';import'../models/publisher-model.js';let InstalledExtensionRepository = class InstalledExtensionRepository extends BaseMongoRepository {
+  constructor(db, logger, options) {
+    super(InstalledExtensionModelFunc, db, logger, options);
+    if (!db) {
+      throw new Error('A database connection is required');
+    }
+    this.logger = logger.child({
+      className: 'InstalledExtensionRepository'
+    });
+  }
+  async findByOrgAndId(orgId, extensionSlug) {
+    try {
+      // Since we store extension as ObjectId, we need to look up by extension reference
+      // For now, we'll return null and let the service handle this differently
+      this.logger.info('findByOrgAndId called with extensionSlug, but we store extension ObjectIds', {
+        orgId,
+        extensionSlug
+      });
+      return null;
+    } catch (error) {
+      this.logger.error('Error in findByOrgAndId', {
+        error,
+        orgId,
+        extensionSlug
+      });
+      return null;
+    }
+  }
+  async findByOrgAndExtensionId(organizationId, extensionId) {
+    try {
+      // Convert organizationId string to ObjectId for organization field lookup
+      return await this.get({
+        organization: new mongoose.Types.ObjectId(organizationId),
+        extension: new mongoose.Types.ObjectId(extensionId)
+      });
+    } catch (error) {
+      this.logger.error('Error in findByOrgAndExtensionId', {
+        error,
+        organizationId,
+        extensionId
+      });
+      return null;
+    }
+  }
+  async countExtensions(filter) {
+    try {
+      const mongoQuery = {};
+      if (filter.orgId) {
+        // Convert orgId string to ObjectId for organization field lookup
+        mongoQuery.organization = new mongoose.Types.ObjectId(filter.orgId);
+      }
+      if (filter.status) {
+        mongoQuery.status = Array.isArray(filter.status) ? {
+          $in: filter.status
+        } : filter.status;
+      }
+      if (filter['lifecycle.registryStatus']) {
+        mongoQuery['lifecycle.registryStatus'] = Array.isArray(filter['lifecycle.registryStatus']) ? {
+          $in: filter['lifecycle.registryStatus']
+        } : filter['lifecycle.registryStatus'];
+      }
+      if (filter['lifecycle.isOrphaned'] !== undefined) {
+        mongoQuery['lifecycle.isOrphaned'] = filter['lifecycle.isOrphaned'];
+      }
+      if (filter['settings.effectiveEnabled'] !== undefined) {
+        mongoQuery['settings.effectiveEnabled'] = filter['settings.effectiveEnabled'];
+      }
+      if (filter.installedBy) {
+        mongoQuery.installedBy = filter.installedBy;
+      }
+      return await this.count(mongoQuery);
+    } catch (error) {
+      this.logger.error('Error in countExtensions', {
+        error,
+        filter
+      });
+      return 0;
+    }
+  }
+  /**
+   * Create a new installed extension record
+   */
+  async createExtension(input) {
+    try {
+      this.logger.trace('Creating installed extension with params (%j)', input);
+      const extensionData = {
+        ...input,
+        organization: new mongoose.Types.ObjectId(input.orgId),
+        // Convert orgId to ObjectId for organization field
+        extension: input.extensionId,
+        // Store ObjectId reference to extension registry
+        installedBy: new mongoose.Types.ObjectId(input.installedBy),
+        installedAt: new Date(),
+        status: 'installed',
+        lifecycle: {
+          registryStatus: 'active',
+          isOrphaned: false,
+          deprecationWarningShown: false,
+          autoUpdateBlocked: false,
+          lastRegistryCheck: new Date().toISOString()
+        },
+        policies: {
+          allowOrphanedExecution: false,
+          requireSecurityUpdates: true,
+          autoRemoveDeprecated: false,
+          deprecationGracePeriod: 30,
+          ...input.policies
+        },
+        settings: {
+          userEnabled: true,
+          systemEnabled: true,
+          effectiveEnabled: true,
+          userConfig: {},
+          systemConfig: {},
+          ...input.settings
+        },
+        runtime: {
+          activationState: 'enabled'
+        },
+        auditLog: [{
+          action: 'installed',
+          timestamp: new Date(),
+          user: new mongoose.Types.ObjectId(input.installedBy),
+          details: {
+            version: input.version,
+            source: 'manual'
+          }
+        }]
+      };
+      return await this.create(extensionData);
+    } catch (error) {
+      this.logger.error('Error creating installed extension', {
+        error,
+        input
+      });
+      throw error;
+    }
+  }
+  /**
+   * Update an existing installed extension
+   */
+  async updateExtension(orgId, extensionId, update) {
+    try {
+      const updateData = {
+        ...update,
+        lastUpdated: new Date(),
+        ...(update.lastUpdatedBy && {
+          lastUpdatedBy: new mongoose.Types.ObjectId(update.lastUpdatedBy)
+        })
+      };
+      return await this.update({
+        organization: new mongoose.Types.ObjectId(orgId),
+        extension: new mongoose.Types.ObjectId(extensionId)
+      }, {
+        $set: updateData
+      });
+    } catch (error) {
+      this.logger.error('Error updating installed extension', {
+        error,
+        orgId,
+        extensionId
+      });
+      throw error;
+    }
+  }
+  /**
+   * Find a specific installed extension by organization and extension ObjectIds
+   */
+  async findOne(orgId, extensionId) {
+    try {
+      return await this.get({
+        organization: new mongoose.Types.ObjectId(orgId),
+        extension: new mongoose.Types.ObjectId(extensionId)
+      });
+    } catch (error) {
+      this.logger.error('Error finding installed extension', {
+        error,
+        orgId,
+        extensionId
+      });
+      return null;
+    }
+  }
+  /**
+   * Find installed extensions with optional filtering
+   * Uses BaseMongoRepository getAll with population to ensure proper _id to id transformation
+   */
+  async findExtensions(query) {
+    try {
+      const mongoQuery = {};
+      // Handle organization-based queries (preferred)
+      if (query.orgId) {
+        mongoQuery.organization = new mongoose.Types.ObjectId(query.orgId);
+      }
+      // Support accountId as a fallback mapping to organization for backward compatibility
+      else if (query.accountId) {
+        mongoQuery.organization = new mongoose.Types.ObjectId(query.accountId);
+      }
+      // Skip extensionSlug filtering at repository level since we store extension as ObjectId
+      // The GraphQL field resolver will handle mapping extension ObjectId to extension details
+      if (query.status) {
+        mongoQuery.status = Array.isArray(query.status) ? {
+          $in: query.status
+        } : query.status;
+      }
+      if (query['lifecycle.registryStatus']) {
+        mongoQuery['lifecycle.registryStatus'] = Array.isArray(query['lifecycle.registryStatus']) ? {
+          $in: query['lifecycle.registryStatus']
+        } : query['lifecycle.registryStatus'];
+      }
+      if (query['lifecycle.isOrphaned'] !== undefined) {
+        mongoQuery['lifecycle.isOrphaned'] = query['lifecycle.isOrphaned'];
+      }
+      if (query['settings.effectiveEnabled'] !== undefined) {
+        mongoQuery['settings.effectiveEnabled'] = query['settings.effectiveEnabled'];
+      }
+      if (query.installedBy) {
+        mongoQuery.installedBy = query.installedBy;
+      }
+      // Use BaseMongoRepository getAll with population
+      // This ensures proper _id to id transformation through virtual fields
+      const extensions = await this.model.find(mongoQuery).exec();
+      return extensions.map(ext => ext.toJSON({
+        virtuals: true
+      }));
+    } catch (error) {
+      this.logger.error('Error finding installed extensions', {
+        error,
+        query
+      });
+      return [];
+    }
+  }
+  /**
+   * Delete an installed extension
+   */
+  async deleteExtension(orgId, extensionId) {
+    try {
+      return await this.delete({
+        organization: new mongoose.Types.ObjectId(orgId),
+        extension: new mongoose.Types.ObjectId(extensionId)
+      });
+    } catch (error) {
+      this.logger.error('Error deleting installed extension', {
+        error,
+        orgId,
+        extensionId
+      });
+      return false;
+    }
+  }
+  /**
+   * Get installed extensions joined with registry information
+   */
+  async findWithRegistryInfo(query) {
+    try {
+      const mongoQuery = {};
+      if (query.orgId) {
+        mongoQuery.organization = new mongoose.Types.ObjectId(query.orgId);
+      }
+      const pipeline = [{
+        $match: mongoQuery
+      }, {
+        $lookup: {
+          from: 'extensionregistry',
+          localField: 'extension',
+          foreignField: '_id',
+          as: 'registryInfo'
+        }
+      }, {
+        $unwind: {
+          path: '$registryInfo',
+          preserveNullAndEmptyArrays: true
+        }
+      }];
+      const extensions = await this.model.aggregate(pipeline);
+      return extensions;
+    } catch (error) {
+      this.logger.error('Error finding extensions with registry info', {
+        error,
+        query
+      });
+      return [];
+    }
+  }
+  /**
+   * Check if extension exists for organization
+   */
+  async exists(extensionId, orgId) {
+    try {
+      const query = orgId ? {
+        organization: new mongoose.Types.ObjectId(orgId),
+        extension: new mongoose.Types.ObjectId(extensionId)
+      } : {
+        extension: new mongoose.Types.ObjectId(extensionId)
+      };
+      const count = await this.count(query);
+      return count > 0;
+    } catch (error) {
+      this.logger.error('Error checking extension existence', {
+        error,
+        orgId,
+        extensionId
+      });
+      return false;
+    }
+  }
+  /**
+   * Bulk update multiple extensions
+   */
+  async bulkUpdateExtensions(tenantId, filter, update) {
+    try {
+      const mongoQuery = {
+        tenantId,
+        ...filter
+      };
+      const result = await this.model.updateMany(mongoQuery, {
+        $set: update
+      });
+      return result.modifiedCount;
+    } catch (error) {
+      this.logger.error('Error bulk updating extensions', {
+        error,
+        tenantId,
+        filter,
+        update
+      });
+      return 0;
+    }
+  }
+  /**
+   * Get extension dependency graph for a tenant
+   */
+  async getDependencyGraph(tenantId) {
+    try {
+      const extensions = await this.model.find({
+        tenantId
+      }).populate(DB_COLL_NAMES.ExtensionRegistries).exec();
+      const extensionObjects = extensions.map(ext => ext.toJSON({
+        virtuals: true
+      }));
+      const dependencies = extensionObjects.map(ext => ({
+        extensionId: ext.extension?.toString() || '',
+        dependsOn: ext.dependencies || [],
+        dependents: ext.dependents || []
+      }));
+      return {
+        extensions: extensionObjects,
+        dependencies
+      };
+    } catch (error) {
+      this.logger.error('Error getting dependency graph', {
+        error,
+        tenantId
+      });
+      return {
+        extensions: [],
+        dependencies: []
+      };
+    }
+  }
+  /**
+   * Count installed extensions matching query
+   */
+  async countByQuery(query) {
+    try {
+      const mongoQuery = {};
+      if (query.orgId) {
+        mongoQuery.organization = new mongoose.Types.ObjectId(query.orgId);
+      }
+      if (query.status) {
+        mongoQuery.status = Array.isArray(query.status) ? {
+          $in: query.status
+        } : query.status;
+      }
+      return await this.count(mongoQuery);
+    } catch (error) {
+      this.logger.error('Error counting extensions', {
+        error,
+        query
+      });
+      return 0;
+    }
+  }
+  /**
+   * Find extensions that need registry sync
+   */
+  async findStaleExtensions(tenantId, maxAge) {
+    try {
+      const staleDate = new Date(Date.now() - maxAge);
+      const extensions = await this.model.find({
+        tenantId,
+        'lifecycle.lastRegistryCheck': {
+          $lt: staleDate.toISOString()
+        }
+      }).exec();
+      return extensions.map(ext => ext.toJSON({
+        virtuals: true
+      }));
+    } catch (error) {
+      this.logger.error('Error finding stale extensions', {
+        error,
+        tenantId,
+        maxAge
+      });
+      return [];
+    }
+  }
+  /**
+   * Update registry status for multiple extensions
+   */
+  async syncRegistryStatus(updates) {
+    try {
+      const bulkOps = updates.map(update => ({
+        updateOne: {
+          filter: {
+            tenantId: update.orgId,
+            extensionSlug: update.extensionId
+          },
+          update: {
+            $set: {
+              'lifecycle.registryStatus': update.registryStatus,
+              'lifecycle.isOrphaned': update.isOrphaned,
+              'lifecycle.lastRegistryCheck': new Date().toISOString(),
+              ...(update.latestVersion && {
+                availableVersion: update.latestVersion
+              })
+            }
+          }
+        }
+      }));
+      await this.model.bulkWrite(bulkOps);
+    } catch (error) {
+      this.logger.error('Error syncing registry status', {
+        error,
+        updates
+      });
+      throw error;
+    }
+  }
+};
+InstalledExtensionRepository = __decorate([injectable(), __param(0, inject('MongoDBConnection')), __param(1, inject('Logger')), __param(2, inject('MongoOptions')), __param(2, optional()), __metadata("design:paramtypes", [mongoose.Connection, Object, Object])], InstalledExtensionRepository);export{InstalledExtensionRepository};//# sourceMappingURL=installed-extension-repository.js.map

package/lib/store/repositories/installed-extension-repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-repository.js","sources":["../../../src/store/repositories/installed-extension-repository.ts"],"sourcesContent":[null],"names":[],"mappings":"mWAiCU,IAAA,4BAA4B,qCAAkC,SAAY;AAe1E,EAAA,WAAA,CAAA,EAAA,EAAA,MAAA,EAAA,OACF,EAAA;IAeE,KAAA,CAAA,2BAAwB,EAAA,EAAA,EAAA,MAAA,EAAA,OAA4B,CAAA;AA+B1D,IAAA,IAAA,CAAA,EAAA,EAAA;;AAEG,IAAA;IACU,IAAA,CAAA,MAAA,GAAA,MACT,CAAK,KAAE,CAAA;AAwDX,MAAA,SAAA,EAAA;;AAEG,EAAA;QACU,oBACF,EAAA,aACP,EAAA;AAyBJ,IAAA,IAAA;;AAEG;AACU,MAAA,IAAA,CAAO,MAAM,CAAA,IAAE,CAAA;AAY5B,QAAA,KAAA;;;AAGG,MAAA,OAAA,IAAA;AACU,IAAA,CAAA,CAAA,OAAA,KAAc,EAAC;AAgD5B,MAAA,IAAA,CAAA,MAAA,CAAA,KAAA,CAAA,yBAAA,EAAA;;AAEG,QAAA,KAAA;AACU,QAAA;AAYb,OAAA,CAAA;;AAEG,IAAA;;AAmCH,EAAA,MAAA,uBAAA,CAAA,cAAA,EAAA,WAAA,EAAA;;AAEG;AACU,MAAA,OAAO,MAAA,IAAW,CAAE,GAAA,CAAA;AAgBjC,QAAA,YAAA,EAAA,IAAA,QAAA,CAAA,KAAA,CAAA,QAAA,CAAA,cAAA,CAAA;;AAEG,OAAA,CAAA;IACU,CAAA,CAAA,OAAA,KAAA,EAAA;AAeb,MAAA,IAAA,CAAA,MAAA,CAAA,KAAA,CAAA,kCAAA,EAAA;;AAEG,QAAA,cAAA;AACU,QAAA;AACT,OAAA,CAAA;aACA,IAAA;;;uBAGc,CAAE,MAAM,EAAE;AACvB,IAAA,IAAA;MACH,MAAA,UAAA,GAAA,EAAA;AAoBF,MAAA,IAAA,MAAA,CAAA,KAAA,EAAA;;AAEG,QAAA,UAAA,CAAA,YAAA,GAAA,IAAA,QAAA,CAAA,KAAA,CAAA,QAAA,CAAA,MAAA,CAAA,KAAA,CAAA;MACU;AAmBb,MAAA,IAAA,MAAA,CAAA,MAAA,EAAA;;AAEG,UAAA,GAAA,EAAA,MAAA,CAAA;AACU,SAAA,GAAA,MAAA,CAAA,MACT;AAmBJ,MAAA;;AAEG,QAAA,UAAA,CAAA,0BAAA,CAAA,GAAA,KAAA,CAAA,OAAA,CAAA,MAAA,CAAA,0BAAA,CAAA,CAAA,GAAA;AACU,UAAA,GAAA,EAAA,MAAA,CAAkB,0BACZ;SACX,GAAA,iCAAc,CAAA;;UAEd,MAAA,CAAA,sBAAuB,CAAA,KAAA,SAAA,EAAA;QACvB,UAAA,CAAA,sBAAuB,CAAA,GAAA,MAAA,CAAA,sBAAA,CAAA;;AAE1B,MAAC,IACH,MAAO,CAAC,2BAAK,CAAA,KAAA,SAAA,EAAA;AAyBnB,QAAA,UAAA,CAAA,2BAAA,CAAA,GAAA,MAAA,CAAA,2BAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/store/repositories/publisher-analytics-repository.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=publisher-analytics-repository.d.ts.map

package/lib/store/repositories/publisher-analytics-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-analytics-repository.d.ts","sourceRoot":"","sources":["../../../src/store/repositories/publisher-analytics-repository.ts"],"names":[],"mappings":""}

package/lib/store/repositories/publisher-repository.d.ts

@@ -0,0 +1,19 @@
+import * as mongoose from 'mongoose';
+import { CdmLogger } from '@cdm-logger/core';
+import { BaseMongoRepository } from '@common-stack/store-mongo';
+import { AsDomainType, IMarketplacePublisherRepository, IMarketplacePublisherModel } from 'common/server';
+export declare class MarketplacePublisherRepository extends BaseMongoRepository<IMarketplacePublisherModel> implements IMarketplacePublisherRepository {
+    constructor(db: mongoose.Connection, logger: CdmLogger.ILogger, options?: unknown);
+    findByPublisherName(publisherName: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    findPublishers(search?: string, orderBy?: string, orderDirection?: 'ASC' | 'DESC', limit?: number, offset?: number): Promise<{
+        publishers: AsDomainType<IMarketplacePublisherModel>[];
+        totalCount: number;
+    }>;
+    updatePublisherStats(publisherId: string, stats: {
+        extensionCount?: number;
+        totalInstalls?: number;
+        averageRating?: number;
+    }): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    verifyPublisher(publisherId: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+}
+//# sourceMappingURL=publisher-repository.d.ts.map

package/lib/store/repositories/publisher-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-repository.d.ts","sourceRoot":"","sources":["../../../src/store/repositories/publisher-repository.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,+BAA+B,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAG1G,qBACa,8BACT,SAAQ,mBAAmB,CAAC,0BAA0B,CACtD,YAAW,+BAA+B;gBAGT,EAAE,EAAE,QAAQ,CAAC,UAAU,EAClC,MAAM,EAAE,SAAS,CAAC,OAAO,EACP,OAAO,CAAC,EAAE,OAAO;IAS5C,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,0BAA0B,CAAC,GAAG,IAAI,CAAC;IAKpG,cAAc,CACvB,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,SAAc,EACrB,cAAc,GAAE,KAAK,GAAG,MAAe,EACvC,KAAK,SAAK,EACV,MAAM,SAAI,GACX,OAAO,CAAC;QACP,UAAU,EAAE,YAAY,CAAC,0BAA0B,CAAC,EAAE,CAAC;QACvD,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;IA2CW,oBAAoB,CAC7B,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE;QACH,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,aAAa,CAAC,EAAE,MAAM,CAAC;KAC1B,GACF,OAAO,CAAC,YAAY,CAAC,0BAA0B,CAAC,GAAG,IAAI,CAAC;IAkB9C,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,0BAA0B,CAAC,GAAG,IAAI,CAAC;CAa9G"}

package/lib/store/repositories/publisher-repository.js

@@ -0,0 +1,87 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,optional}from'inversify';import*as mongoose from'mongoose';import'@cdm-logger/core';import {BaseMongoRepository}from'@common-stack/store-mongo';import'../models/installed-extension-model.js';import {PublisherModelFunc}from'../models/publisher-model.js';var MarketplacePublisherRepository_1;
+let MarketplacePublisherRepository = MarketplacePublisherRepository_1 = class MarketplacePublisherRepository extends BaseMongoRepository {
+  constructor(db, logger, options) {
+    super(PublisherModelFunc, db, logger, options);
+    if (!db) {
+      throw new Error('MongoDB connection is not provided');
+    }
+    this.logger = logger.child({
+      className: MarketplacePublisherRepository_1.name
+    });
+  }
+  async findByPublisherName(publisherName) {
+    this.logger.trace('findByPublisherName with publisherName [%s]', publisherName);
+    return this.model.findOne({
+      publisherName: publisherName.toLowerCase()
+    }).exec();
+  }
+  async findPublishers(search, orderBy = 'createdAt', orderDirection = 'DESC', limit = 20, offset = 0) {
+    this.logger.trace('findPublishers with limit [%d], offset [%d], search [%s]', limit, offset, search);
+    const query = this.model.find();
+    // Apply search filter
+    if (search && search.trim()) {
+      const searchRegex = new RegExp(search.trim(), 'i');
+      query.or([{
+        displayName: searchRegex
+      }, {
+        publisherName: searchRegex
+      }, {
+        description: searchRegex
+      }]);
+    }
+    // Get total count for pagination
+    const totalCount = await this.model.countDocuments(query.getQuery()).exec();
+    // Apply ordering
+    const sortDirection = orderDirection === 'ASC' ? 1 : -1;
+    let sortField;
+    if (orderBy === 'displayName') {
+      sortField = 'displayName';
+    } else if (orderBy === 'extensionCount') {
+      sortField = 'extensionCount';
+    } else if (orderBy === 'totalInstalls') {
+      sortField = 'totalInstalls';
+    } else if (orderBy === 'averageRating') {
+      sortField = 'averageRating';
+    } else {
+      sortField = 'createdAt';
+    }
+    query.sort({
+      [sortField]: sortDirection
+    });
+    // Apply pagination
+    query.skip(offset).limit(limit);
+    const publishers = await query.exec();
+    return {
+      publishers,
+      totalCount
+    };
+  }
+  async updatePublisherStats(publisherId, stats) {
+    this.logger.trace('updatePublisherStats for publisher [%s] with stats [%j]', publisherId, stats);
+    const updateData = {
+      updatedAt: new Date()
+    };
+    if (stats.extensionCount !== undefined) {
+      updateData.extensionCount = stats.extensionCount;
+    }
+    if (stats.totalInstalls !== undefined) {
+      updateData.totalInstalls = stats.totalInstalls;
+    }
+    if (stats.averageRating !== undefined) {
+      updateData.averageRating = Math.max(0, Math.min(5, stats.averageRating)); // Clamp between 0-5
+    }
+    return this.model.findByIdAndUpdate(publisherId, updateData, {
+      new: true
+    }).exec();
+  }
+  async verifyPublisher(publisherId) {
+    this.logger.trace('verifyPublisher with publisherId [%s]', publisherId);
+    return this.model.findByIdAndUpdate(publisherId, {
+      verified: true,
+      updatedAt: new Date()
+    }, {
+      new: true
+    }).exec();
+  }
+};
+MarketplacePublisherRepository = MarketplacePublisherRepository_1 = __decorate([injectable(), __param(0, inject('MongoDBConnection')), __param(1, inject('Logger')), __param(2, inject('MongoOptions')), __param(2, optional()), __metadata("design:paramtypes", [mongoose.Connection, Object, Object])], MarketplacePublisherRepository);export{MarketplacePublisherRepository};//# sourceMappingURL=publisher-repository.js.map

package/lib/store/repositories/publisher-repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-repository.js","sources":["../../../src/store/repositories/publisher-repository.ts"],"sourcesContent":[null],"names":[],"mappings":"yUACA,IAAA,gCAAoC;IA4BnB,8BACM,GACf,gCACc,SAAO,8BAErB,SAAM,mBACC,CAAA;AACP,EAAA,WAAA,CAAA,EAAA,EAAU,MAAE,EAAA,OAAa,EAAA;SACzB,CAAA,kBAAmB,EAAA,EAAA,EAAA,MAAA,EAAA,OAAA,CAAA;QACrB,CAAA,EAAA,EAAA;AA2CW,MAAA,MAAA,IAAA,KAAA,CAAA,oCAEF,CAAA;;QAEH,CAAA,MAAA,GAAA,MAAgB,CAAA,KAAM,CAAC;eACvB,EAAA,gCAAuB,CAAA;KAC1B,CAAA;AAmBQ,EAAA;AAahB,EAAA,MAAA,mBAAA,CAAA,aAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/templates/constants/DB_COLL_NAMES.ts.template

@@ -0,0 +1,5 @@
+export const DB_COLL_NAMES = {
+    // from package: marketplace-server
+    InstalledExtensions: 'installed_extensions',
+    MarketplacePublisher: 'marketplace_publishers',
+};

package/lib/templates/constants/SERVER_TYPES.ts.template

@@ -1,6 +1,12 @@
-
 export const SERVER_TYPES = {
-    IExtensionMongoConnection: Symbol('ExtensionMongoConnection'),
-    IRegistryExtensionService: Symbol('IRegistryExtensionService'),
-    IRegistryExtensionRepository: Symbol('IRegistryExtensionRepository'),
+
+    IInstalledExtensionService: Symbol('IInstalledExtensionService'),
+    IInstalledExtensionRepository: Symbol('IInstalledExtensionRepository'),
+    IMarketplacePublisherService: Symbol('IMarketplacePublisherService'),
+    IMarketplacePublisherRepository: Symbol('IMarketplacePublisherRepository'),
+    IPublisherEventService: Symbol('IPublisherEventService'),
+    // Extension Gallery Services
+    IExtensionGalleryService: Symbol.for('IExtensionGalleryService'),
+    IExtensionGalleryRepository: Symbol.for('IExtensionGalleryRepository'),
+    ExtensionGalleryDataLoader: Symbol.for('ExtensionGalleryDataLoader'),
 };

package/lib/templates/repositories/ExtensionGalleryRepository.ts.template

@@ -0,0 +1,44 @@
+// from package: marketplace-server
+import { IGalleryExtension } from 'common/server';
+
+/**
+ * Gallery query result interface for repository operations
+ */
+export interface IGalleryQueryResult {
+    results: IGalleryExtension[];
+    total: number;
+    pageSize: number;
+}
+
+/**
+ * Extension asset interface
+ */
+export interface IExtensionAsset {
+    uri: string;
+    fallbackUri?: string;
+}
+
+/**
+ * Repository interface for ExtensionGallery data access
+ */
+export interface IExtensionGalleryRepository {
+    /**
+     * Get asset content for an extension
+     */
+    asset<T>(extensionSlug: string, version: string, asset: string): Promise<T>;
+
+    /**
+     * Get extensions by ID
+     */
+    get(id: string, fields: string[]): Promise<IGalleryExtension[]>;
+
+    /**
+     * Download an extension
+     */
+    download(extension: IGalleryExtension): Promise<boolean>;
+
+    /**
+     * Query extensions
+     */
+    query(query: Record<string, unknown>): Promise<IGalleryQueryResult>;
+}