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

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

@@ -1,4 +1,4 @@
-import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,optional}from'inversify';import {BaseMongoRepository}from'@common-stack/store-mongo';import*as mongoose from'mongoose';import'../models/registry-extension-model.js';import {InstalledExtensionModelFunc}from'../models/installed-extension-model.js';let InstalledExtensionRepository = class InstalledExtensionRepository extends BaseMongoRepository {
+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) {
@@ -8,30 +8,46 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
       className: 'InstalledExtensionRepository'
     });
   }
-  async findByTenantAndId(tenantId, extensionSlug) {
+  async findByOrgAndId(orgId, extensionSlug) {
     try {
-      const extension = await this.model.findOne({
-        tenantId,
+      // 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 extension?.toObject();
+      return null;
     } catch (error) {
-      this.logger.error('Error in findByTenantAndId', {
+      this.logger.error('Error in findByOrgAndId', {
         error,
-        tenantId,
+        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.tenantId) {
-        mongoQuery.tenantId = filter.tenantId;
-      }
-      if (filter.extensionSlug) {
-        mongoQuery.extensionSlug = filter.extensionSlug;
+      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) ? {
@@ -52,7 +68,7 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
       if (filter.installedBy) {
         mongoQuery.installedBy = filter.installedBy;
       }
-      return await this.model.countDocuments(mongoQuery);
+      return await this.count(mongoQuery);
     } catch (error) {
       this.logger.error('Error in countExtensions', {
         error,
@@ -69,9 +85,10 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
       this.logger.trace('Creating installed extension with params (%j)', input);
       const extensionData = {
         ...input,
-        tenantId: input.tenantId,
+        organization: new mongoose.Types.ObjectId(input.orgId),
+        // Convert orgId to ObjectId for organization field
         extension: input.extensionId,
-        // Store extensionSlug directly since it's a string
+        // Store ObjectId reference to extension registry
         installedBy: new mongoose.Types.ObjectId(input.installedBy),
         installedAt: new Date(),
         status: 'installed',
@@ -110,8 +127,7 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
           }
         }]
       };
-      const extension = await this.model.create(extensionData);
-      return extension.toObject();
+      return await this.create(extensionData);
     } catch (error) {
       this.logger.error('Error creating installed extension', {
         error,
@@ -123,63 +139,85 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
   /**
    * Update an existing installed extension
    */
-  async updateExtension(tenantId, extensionSlug, update) {
+  async updateExtension(orgId, extensionId, update) {
     try {
-      const extension = await this.model.findOneAndUpdate({
-        tenantId,
-        extensionSlug
-      }, {
-        $set: {
-          ...update,
-          lastUpdated: new Date(),
-          ...(update.lastUpdatedBy && {
-            lastUpdatedBy: new mongoose.Types.ObjectId(update.lastUpdatedBy)
-          })
-        }
+      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)
       }, {
-        new: true
+        $set: updateData
       });
-      return extension?.toObject();
     } catch (error) {
       this.logger.error('Error updating installed extension', {
         error,
-        tenantId,
-        extensionSlug
+        orgId,
+        extensionId
       });
       throw error;
     }
   }
   /**
-   * Find a specific installed extension
+   * Find a specific installed extension by organization and extension ObjectIds
    */
-  async findOne(tenantId, extensionSlug) {
+  async findOne(orgId, extensionId) {
     try {
-      const extension = await this.model.findOne({
-        tenantId,
-        extensionSlug
+      return await this.get({
+        organization: new mongoose.Types.ObjectId(orgId),
+        extension: new mongoose.Types.ObjectId(extensionId)
       });
-      return extension?.toObject();
     } catch (error) {
       this.logger.error('Error finding installed extension', {
         error,
-        tenantId,
-        extensionSlug
+        orgId,
+        extensionId
       });
       return null;
     }
   }
+  /**
+   * Find all installed extensions for a specific extension ObjectId
+   */
+  async findByExtensionId(extensionId) {
+    try {
+      const mongoQuery = {
+        extension: new mongoose.Types.ObjectId(extensionId)
+      };
+      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 by extensionId', {
+        error,
+        extensionId
+      });
+      return [];
+    }
+  }
   /**
    * Find installed extensions with optional filtering
+   * Uses BaseMongoRepository getAll with population to ensure proper _id to id transformation
    */
   async findExtensions(query) {
     try {
       const mongoQuery = {};
-      if (query.tenantId) {
-        mongoQuery.tenantId = query.tenantId;
+      // Handle organization-based queries (preferred)
+      if (query.orgId) {
+        mongoQuery.organization = new mongoose.Types.ObjectId(query.orgId);
       }
-      if (query.extensionSlug) {
-        mongoQuery.extensionSlug = query.extensionSlug;
+      // 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
@@ -199,8 +237,12 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
       if (query.installedBy) {
         mongoQuery.installedBy = query.installedBy;
       }
-      const extensions = await this.model.find(mongoQuery);
-      return extensions.map(ext => ext.toObject());
+      // 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,
@@ -212,18 +254,17 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
   /**
    * Delete an installed extension
    */
-  async deleteExtension(tenantId, extensionSlug) {
+  async deleteExtension(orgId, extensionId) {
     try {
-      const result = await this.model.deleteOne({
-        tenantId,
-        extensionSlug
+      return await this.delete({
+        organization: new mongoose.Types.ObjectId(orgId),
+        extension: new mongoose.Types.ObjectId(extensionId)
       });
-      return result.deletedCount > 0;
     } catch (error) {
       this.logger.error('Error deleting installed extension', {
         error,
-        tenantId,
-        extensionSlug
+        orgId,
+        extensionId
       });
       return false;
     }
@@ -234,8 +275,8 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
   async findWithRegistryInfo(query) {
     try {
       const mongoQuery = {};
-      if (query.tenantId) {
-        mongoQuery.tenantId = query.tenantId;
+      if (query.orgId) {
+        mongoQuery.organization = new mongoose.Types.ObjectId(query.orgId);
       }
       const pipeline = [{
         $match: mongoQuery
@@ -263,20 +304,23 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
     }
   }
   /**
-   * Check if extension exists for tenant
+   * Check if extension exists for organization
    */
-  async exists(tenantId, extensionSlug) {
+  async exists(extensionId, orgId) {
     try {
-      const count = await this.model.countDocuments({
-        tenantId,
-        extensionSlug
-      });
+      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,
-        tenantId,
-        extensionSlug
+        orgId,
+        extensionId
       });
       return false;
     }
@@ -311,10 +355,12 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
     try {
       const extensions = await this.model.find({
         tenantId
-      });
-      const extensionObjects = extensions.map(ext => ext.toObject());
+      }).populate(DB_COLL_NAMES.ExtensionRegistries).exec();
+      const extensionObjects = extensions.map(ext => ext.toJSON({
+        virtuals: true
+      }));
       const dependencies = extensionObjects.map(ext => ({
-        extensionSlug: ext.extension?.toString() || '',
+        extensionId: ext.extension?.toString() || '',
         dependsOn: ext.dependencies || [],
         dependents: ext.dependents || []
       }));
@@ -336,18 +382,18 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
   /**
    * Count installed extensions matching query
    */
-  async count(query) {
+  async countByQuery(query) {
     try {
       const mongoQuery = {};
-      if (query.tenantId) {
-        mongoQuery.tenantId = query.tenantId;
+      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.model.countDocuments(mongoQuery);
+      return await this.count(mongoQuery);
     } catch (error) {
       this.logger.error('Error counting extensions', {
         error,
@@ -367,8 +413,10 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
         'lifecycle.lastRegistryCheck': {
           $lt: staleDate.toISOString()
         }
-      });
-      return extensions.map(ext => ext.toObject());
+      }).exec();
+      return extensions.map(ext => ext.toJSON({
+        virtuals: true
+      }));
     } catch (error) {
       this.logger.error('Error finding stale extensions', {
         error,
@@ -386,8 +434,8 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject,opti
       const bulkOps = updates.map(update => ({
         updateOne: {
           filter: {
-            tenantId: update.tenantId,
-            extensionSlug: update.extensionSlug
+            tenantId: update.orgId,
+            extensionSlug: update.extensionId
           },
           update: {
             $set: {

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

@@ -1 +1 @@
-{"version":3,"file":"installed-extension-repository.js","sources":["../../../src/store/repositories/installed-extension-repository.ts"],"sourcesContent":[null],"names":[],"mappings":"kUAqBqC,IAAA,4BAAa,GAAA,MACxB,4BACyB,SAAG,mBAAG,CAAA;AAS/C,EAAA,WAAA,CAAA,EAAA,EAAA,MACM,EAAA,OAAQ,EAAA;IAYd,KAAe,CAAA,2BAAS,EAAA,EAAA,EAAA,MAAA,EAAA,OAAmC,CAAA;AAiCjE,IAAA,IAAA,CAAA,EAAA,EAAA;;AAEG;IACU,IAAe,CAAA,MAAA,GAAA,MACnB,CAAA,KAAgC,CAAA;AAyDzC,MAAA,SAAA,EAAA;;AAEG;QACyB,0BACd,EAAM,aACH,EAAA;AA4BjB,IAAA,IAAA;;AAEG,QAAA,QAAA;AACU,QAAA;AAab,OAAA,CAAA;;AAEG,KAAA,CAAA,OAAA,KAAA,EAAA;AACU,MAAA,IAAA,CAAA,MAAA,CAAc,KAAC,CAAK,4BAA8B,EAAA;AA0C/D,QAAA,KAAA;;AAEG,QAAA;AACU,OAAA,CAAA;AAUb,MAAA,OAAA,IAAA;;AAEG;QAC8B,eAAA,CAAA,MAAM,EAAE;AAkCzC,IAAA,IAAA;;AAEG,MAAA,IAAA,MAAA,CAAA,QAAA,EAAA;AACU,QAAA,UAAO,CAAQ,QAAQ,GAAE,MAAA,CAAA,QAAe;AAUrD;;AAEG,QAAA,UAAA,CAAA,aAAA,GAAA,MAAA,CAAA,aAAA;;AAgBH,MAAA,IAAA,MAAA,CAAA,MAAA,EAAA;;AAEG,UAAA,GAAA,EAAA,MAAA,CAAA;AACU,SAAA,GAAA,MAAA,CAAA,MAA2B;AACpC;UACY,MAAA,CAAA,0BAAQ,CAAA,EAAA;kBACH,CAAA,0BAAS,CAAA,GAAA,KAAA,CAAA,OAAA,CAAA,MAAA,CAAA,0BAAA,CAAA,CAAA,GAAA;aACb,EAAA,MAAA,CAAA,0BAAW;YACpB,MAAU,CAAA,0BAAW,CAAA;AACxB;MACH,IAAA,MAAA,CAAA,sBAAA,CAAA,KAAA,SAAA,EAAA;AAoBF,QAAA,UAAA,CAAA,sBAAA,CAAA,GAAA,MAAA,CAAA,sBAAA,CAAA;;AAEG,MAAA,IAAA,MAAA,CAAA,2BAAA,CAAA,KAAA,SAAA,EAAA;QACe,UAAQ,CAAA,2BAAmC,CAAA,GAAA,kCAAQ,CAAA;AAmBrE;;AAEG,QAAA,UAAA,CAAA,WAAA,GAAA,MAAA,CAAA,WAAA;AACU;AAkBb,MAAA,OAAA,MAAA,IAAA,CAAA,KAAA,CAAA,cAAA,CAAA,UAAA,CAAA;;AAEG,MAAA,IAAA,CAAA,MAAA,CAAA,KAAA,CAAA,0BAAA,EAAA;AACU,QAAA,KAAA;QAEL;QACA;aACc,CAAA;;;AAGjB;AA0BR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"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;;AAEG,OAAA,CAAA;AACU,MAAA,OAAA,IAAA;AAab,IAAA,CAAA,CAAA,OAAA,KAAA,EAAA;;;AAGG,QAAA,KAAA;AACU,QAAA;AAgDb,OAAA,CAAA;;AAEG,IAAA;AACU,EAAA;AAYb,EAAA,MAAA,uBAAA,CAAA,cAAA,EAAA,WAAA,EAAA;;AAEG;MACU,OAAA,MAAA,IAAA,CAAoB;AAkCjC,QAAA,YAAA,EAAA,IAAA,QAAA,CAAA,KAAA,CAAA,QAAA,CAAA,cAAA,CAAA;;AAEG,OAAA,CAAA;AACU,IAAA,CAAA,CAAA,OAAO,KAAA,EAAA;AAgBpB,MAAA,IAAA,CAAA,MAAA,CAAA,KAAA,CAAA,kCAAA,EAAA;;AAEG,QAAA,cAAA;QACU;AAeb,OAAA,CAAA;;AAEG,IAAA;AACU,EAAA;AACT,EAAA,MAAA,eAAY,CAAA,MAAA,EAAY;QACxB;YACI,UAAA,GAAa;gBACb,CAAA,KAAS,EAAE;;AAEd,QAAA,UAAE,CAAA,YAAA,GAAA,IAAA,QAAA,CAAA,KAAA,CAAA,QAAA,CAAA,MAAA,CAAA,KAAA,CAAA;MACL;AAoBF,MAAA,IAAA,MAAA,CAAA,MAAA,EAAA;;AAEG,UAAA,GAAA,EAAA,MAAA,CAAA;SACU,GAAA,aAAoB;AAmBjC,MAAA;;AAEG,QAAA,UAAA,CAAA,0BAAA,CAAA,GAAA,KAAA,CAAA,OAAA,CAAA,MAAA,CAAA,0BAAA,CAAA,CAAA,GAAA;AACU,UAAA,GAAA,EAAA,MAAA,CAAA,0BAEH;AAkBV,SAAA,GAAA,MAAA,CAAA,0BAAA,CAAA;;AAEG,MAAA,IAAA,MAAA,CAAA,sBAAA,CAAA,KAAA,SAAA,EAAA;AACU,QAAA,UAAA,CAAA,sBACM,CAAA,GAAA,MAAA,CAAA,sBAAA,CAAA;;UAEX,MAAA,CAAA,2BAAoB,CAAA,KAAA,SAAA,EAAA;QACpB,UAAA,CAAA,2BAAuB,CAAA,GAAA,MAAA,CAAA,2BAAA,CAAA;;UAEvB,MAAA,CAAA,WAAoB,EAAA;AACvB,QAAC,UACK,CAAA,WAAK,GAAA,MAAA,CAAA,WAAA;AAyBnB,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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({
+      name: 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

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

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

@@ -1,9 +1,12 @@
-
 export const SERVER_TYPES = {
-    IExtensionMongoConnection: Symbol('ExtensionMongoConnection'),
-    IRegistryExtensionService: Symbol('IRegistryExtensionService'),
-    IRegistryExtensionRepository: Symbol('IRegistryExtensionRepository'),
-    IRegistryExtensionDataLoader: Symbol('IRegistryExtensionDataLoader'),
+
     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>;
+}

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

@@ -18,25 +18,30 @@ export interface IInstalledExtensionRepository extends IBaseMongoRepository<IIns
      * Update an existing installed extension
      */
     updateExtension(
-        tenantId: string,
-        extensionSlug: string,
+        orgId: string,
+        extensionId: string,
         update: IUpdateInstalledExtensionInput,
     ): Promise<AsDomainType<IInstalledExtensionModel> | null>;
 
     /**
-     * Find a specific installed extension
+     * Find a specific installed extension by organization and extension ObjectIds
      */
-    findByTenantAndId(tenantId: string, extensionSlug: string): Promise<AsDomainType<IInstalledExtensionModel> | null>;
+    findByOrgAndExtensionId(orgId: string, extensionId: string): Promise<AsDomainType<IInstalledExtensionModel> | null>;
 
     /**
      * Find installed extensions with optional filtering
      */
     findExtensions(filter: IInstalledExtensionFilter): Promise<AsDomainType<IInstalledExtensionModel>[]>;
 
+    /**
+     * Find all installed extensions for a specific extension ObjectId
+     */
+    findByExtensionId(extensionId: string): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+
     /**
      * Delete an installed extension
      */
-    deleteExtension(tenantId: string, extensionSlug: string): Promise<boolean>;
+    deleteExtension(orgId: string, extensionId: string): Promise<boolean>;
 
     /**
      * Get installed extensions joined with registry information
@@ -44,26 +49,26 @@ export interface IInstalledExtensionRepository extends IBaseMongoRepository<IIns
     findWithRegistryInfo(filter: IInstalledExtensionFilter): Promise<any[]>;
 
     /**
-     * Check if extension exists for tenant
+     * Check if extension exists for organization
      */
-    exists(tenantId: string, extensionSlug: string): Promise<boolean>;
+    exists(orgId: string, extensionId: string): Promise<boolean>;
 
     /**
      * Bulk update multiple extensions (useful for policy changes or admin actions)
      */
     bulkUpdateExtensions(
-        tenantId: string,
+        orgId: string,
         filter: Partial<IInstalledExtensionFilter>,
         update: Partial<IUpdateInstalledExtensionInput>,
     ): Promise<number>;
 
     /**
-     * Get extension dependency graph for a tenant
+     * Get extension dependency graph for an organization
      */
-    getDependencyGraph(tenantId: string): Promise<{
+    getDependencyGraph(orgId: string): Promise<{
         extensions: AsDomainType<IInstalledExtensionModel>[];
         dependencies: Array<{
-            extensionSlug: string;
+            extensionId: string;
             dependsOn: string[];
             dependents: string[];
         }>;
@@ -77,15 +82,15 @@ export interface IInstalledExtensionRepository extends IBaseMongoRepository<IIns
     /**
      * Find extensions that need registry sync (stale registry status)
      */
-    findStaleExtensions(tenantId: string, maxAge: number): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+    findStaleExtensions(orgId: string, maxAge: number): Promise<AsDomainType<IInstalledExtensionModel>[]>;
 
     /**
      * Update registry status for multiple extensions
      */
     syncRegistryStatus(
         updates: Array<{
-            tenantId: string;
-            extensionSlug: string;
+            orgId: string;
+            extensionId: string;
             registryStatus: string;
             latestVersion?: string;
             isOrphaned: boolean;