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

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

@@ -0,0 +1,414 @@
+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 {
+  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 findByTenantAndId(tenantId, extensionSlug) {
+    try {
+      const extension = await this.model.findOne({
+        tenantId,
+        extensionSlug
+      });
+      return extension?.toObject();
+    } catch (error) {
+      this.logger.error('Error in findByTenantAndId', {
+        error,
+        tenantId,
+        extensionSlug
+      });
+      return null;
+    }
+  }
+  async countExtensions(filter) {
+    try {
+      const mongoQuery = {};
+      if (filter.tenantId) {
+        mongoQuery.tenantId = filter.tenantId;
+      }
+      if (filter.extensionSlug) {
+        mongoQuery.extensionSlug = filter.extensionSlug;
+      }
+      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.model.countDocuments(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,
+        tenantId: input.tenantId,
+        extension: input.extensionId,
+        // Store extensionSlug directly since it's a string
+        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'
+          }
+        }]
+      };
+      const extension = await this.model.create(extensionData);
+      return extension.toObject();
+    } catch (error) {
+      this.logger.error('Error creating installed extension', {
+        error,
+        input
+      });
+      throw error;
+    }
+  }
+  /**
+   * Update an existing installed extension
+   */
+  async updateExtension(tenantId, extensionSlug, update) {
+    try {
+      const extension = await this.model.findOneAndUpdate({
+        tenantId,
+        extensionSlug
+      }, {
+        $set: {
+          ...update,
+          lastUpdated: new Date(),
+          ...(update.lastUpdatedBy && {
+            lastUpdatedBy: new mongoose.Types.ObjectId(update.lastUpdatedBy)
+          })
+        }
+      }, {
+        new: true
+      });
+      return extension?.toObject();
+    } catch (error) {
+      this.logger.error('Error updating installed extension', {
+        error,
+        tenantId,
+        extensionSlug
+      });
+      throw error;
+    }
+  }
+  /**
+   * Find a specific installed extension
+   */
+  async findOne(tenantId, extensionSlug) {
+    try {
+      const extension = await this.model.findOne({
+        tenantId,
+        extensionSlug
+      });
+      return extension?.toObject();
+    } catch (error) {
+      this.logger.error('Error finding installed extension', {
+        error,
+        tenantId,
+        extensionSlug
+      });
+      return null;
+    }
+  }
+  /**
+   * Find installed extensions with optional filtering
+   */
+  async findExtensions(query) {
+    try {
+      const mongoQuery = {};
+      if (query.tenantId) {
+        mongoQuery.tenantId = query.tenantId;
+      }
+      if (query.extensionSlug) {
+        mongoQuery.extensionSlug = query.extensionSlug;
+      }
+      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;
+      }
+      const extensions = await this.model.find(mongoQuery);
+      return extensions.map(ext => ext.toObject());
+    } catch (error) {
+      this.logger.error('Error finding installed extensions', {
+        error,
+        query
+      });
+      return [];
+    }
+  }
+  /**
+   * Delete an installed extension
+   */
+  async deleteExtension(tenantId, extensionSlug) {
+    try {
+      const result = await this.model.deleteOne({
+        tenantId,
+        extensionSlug
+      });
+      return result.deletedCount > 0;
+    } catch (error) {
+      this.logger.error('Error deleting installed extension', {
+        error,
+        tenantId,
+        extensionSlug
+      });
+      return false;
+    }
+  }
+  /**
+   * Get installed extensions joined with registry information
+   */
+  async findWithRegistryInfo(query) {
+    try {
+      const mongoQuery = {};
+      if (query.tenantId) {
+        mongoQuery.tenantId = query.tenantId;
+      }
+      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 tenant
+   */
+  async exists(tenantId, extensionSlug) {
+    try {
+      const count = await this.model.countDocuments({
+        tenantId,
+        extensionSlug
+      });
+      return count > 0;
+    } catch (error) {
+      this.logger.error('Error checking extension existence', {
+        error,
+        tenantId,
+        extensionSlug
+      });
+      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
+      });
+      const extensionObjects = extensions.map(ext => ext.toObject());
+      const dependencies = extensionObjects.map(ext => ({
+        extensionSlug: 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 count(query) {
+    try {
+      const mongoQuery = {};
+      if (query.tenantId) {
+        mongoQuery.tenantId = query.tenantId;
+      }
+      if (query.status) {
+        mongoQuery.status = Array.isArray(query.status) ? {
+          $in: query.status
+        } : query.status;
+      }
+      return await this.model.countDocuments(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()
+        }
+      });
+      return extensions.map(ext => ext.toObject());
+    } 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.tenantId,
+            extensionSlug: update.extensionSlug
+          },
+          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":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/store/repositories/registry-extension-repository.d.ts

@@ -0,0 +1,54 @@
+import * as mongoose from 'mongoose';
+import { CdmLogger } from '@cdm-logger/core';
+import { IExtensionRelease, IRegistryExtensionRepository, IRegistryExtensionModel, AsDomainType } from 'common/server';
+import { BaseMongoRepository } from '@common-stack/store-mongo';
+export declare class RegistryExtensionRepository extends BaseMongoRepository<IRegistryExtensionModel> implements IRegistryExtensionRepository {
+    constructor(db: mongoose.Connection, logger: CdmLogger.ILogger, options?: any);
+    createExtension(publisherId: string, name: string): Promise<mongoose.Document<unknown, any, IRegistryExtensionModel & {
+        id: string;
+    }> & Omit<IRegistryExtensionModel & {
+        id: string;
+    } & Required<{
+        _id: import("bson").ObjectID;
+    }>, never>>;
+    updateExtensionName(extensionSlug: string, name: string): Promise<mongoose.Document<unknown, any, IRegistryExtensionModel & {
+        id: string;
+    }> & Omit<IRegistryExtensionModel & {
+        id: string;
+    } & Required<{
+        _id: import("bson").ObjectID;
+    }>, never>>;
+    updateExtension(extensionSlug: string, update: {
+        installed?: boolean;
+    }): Promise<mongoose.Document<unknown, any, IRegistryExtensionModel & {
+        id: string;
+    }> & Omit<IRegistryExtensionModel & {
+        id: string;
+    } & Required<{
+        _id: import("bson").ObjectID;
+    }>, never>>;
+    deleteExtension(extensionSlug: any): Promise<boolean>;
+    extensionReleases(extensionSlug: string): Promise<AsDomainType<IExtensionRelease>[]>;
+    publishExtension(request: any): Promise<mongoose.Document<unknown, any, IRegistryExtensionModel & {
+        id: string;
+    }> & Omit<IRegistryExtensionModel & {
+        id: string;
+    } & Required<{
+        _id: import("bson").ObjectID;
+    }>, never>>;
+    findExtensions(first: number, query: string, local?: boolean, remote?: boolean, prioritizeExtensionIDs?: string[]): Promise<(mongoose.Document<unknown, any, IRegistryExtensionModel & {
+        id: string;
+    }> & Omit<IRegistryExtensionModel & {
+        id: string;
+    } & Required<{
+        _id: import("bson").ObjectID;
+    }>, never>)[]>;
+    findExtension(extensionSlug: string, version?: string): Promise<mongoose.Document<unknown, any, IRegistryExtensionModel & {
+        id: string;
+    }> & Omit<IRegistryExtensionModel & {
+        id: string;
+    } & Required<{
+        _id: import("bson").ObjectID;
+    }>, never>>;
+}
+//# sourceMappingURL=registry-extension-repository.d.ts.map

package/lib/store/repositories/registry-extension-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-extension-repository.d.ts","sourceRoot":"","sources":["../../../src/store/repositories/registry-extension-repository.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,4BAA4B,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACvH,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAGhE,qBACa,2BACT,SAAQ,mBAAmB,CAAC,uBAAuB,CACnD,YAAW,4BAA4B;gBAGN,EAAE,EAAE,QAAQ,CAAC,UAAU,EAClC,MAAM,EAAE,SAAS,CAAC,OAAO,EACP,OAAO,CAAC,EAAE,GAAG;IASxC,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;;;;;;;IAcjD,mBAAmB,CAAC,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;;;;;;;IAMvD,eAAe,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;;;;;;;IAMtE,eAAe,CAAC,aAAa,KAAA;IAW7B,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,iBAAiB,CAAC,EAAE,CAAC;IAMpF,gBAAgB,CAAC,OAAO,EAAE,GAAG;;;;;;;IA0D7B,cAAc,CACvB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,OAAO,EACf,MAAM,CAAC,EAAE,OAAO,EAChB,sBAAsB,CAAC,EAAE,MAAM,EAAE;;;;;;;IAKxB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;;;;;;;CASrE"}

package/lib/store/{repository → repositories}/registry-extension-repository.js

@@ -1,28 +1,30 @@
-import {__decorate,__param,__metadata}from'tslib';import {pick,get,isEmpty,filter}from'lodash-es';import {injectable,inject,optional}from'inversify';import*as mongoose from'mongoose';import'@cdm-logger/core';import {SERVER_TYPES}from'common/server';import {RegistryExtensionModelFunc}from'../models/registry-extension-model.js';var RegistryExtensionRepository_1;
-let RegistryExtensionRepository = RegistryExtensionRepository_1 = class RegistryExtensionRepository {
-  logger;
-  repositoryExtensionModel;
+import {__decorate,__param,__metadata}from'tslib';import {pick,get,isEmpty,filter}from'lodash-es';import {injectable,inject,optional}from'inversify';import*as mongoose from'mongoose';import'@cdm-logger/core';import {BaseMongoRepository}from'@common-stack/store-mongo';import {RegistryExtensionModelFunc}from'../models/registry-extension-model.js';import'../models/installed-extension-model.js';var RegistryExtensionRepository_1;
+let RegistryExtensionRepository = RegistryExtensionRepository_1 = class RegistryExtensionRepository extends BaseMongoRepository {
   constructor(db, logger, options) {
+    super(RegistryExtensionModelFunc, db, logger, options);
+    if (!db) {
+      throw new Error('MongoDB connection is not provided');
+    }
     this.logger = logger.child({
       className: RegistryExtensionRepository_1.name
     });
-    this.repositoryExtensionModel = RegistryExtensionModelFunc(db);
   }
   async createExtension(publisherId, name) {
     this.logger.trace('createExtension with publisherId [%s], name [%s]', publisherId, name);
-    return this.repositoryExtensionModel.create({
+    const result = await this.model.create({
       publisherId,
       name,
       manifest: null,
       uuid: '',
       releases: null,
-      extensionID: ''
+      extensionSlug: ''
     });
+    return result;
   }
-  async updateExtensionName(extensionID, name) {
-    this.logger.trace('updateExtensionName with extension [%s], name [%s]', extensionID, name);
-    await this.repositoryExtensionModel.update({
-      extensionID
+  async updateExtensionName(extensionSlug, name) {
+    this.logger.trace('updateExtensionName with extension [%s], name [%s]', extensionSlug, name);
+    await this.model.update({
+      extensionSlug
     }, {
       $set: {
         name
@@ -30,45 +32,45 @@ let RegistryExtensionRepository = RegistryExtensionRepository_1 = class Registry
     }, {
       upsert: true
     });
-    return this.repositoryExtensionModel.findOne({
-      extensionID
+    return this.model.findOne({
+      extensionSlug
     }).exec();
   }
-  async updateExtension(extensionID, update) {
-    this.logger.trace('updateExtension with extension [%s], update [%j]', extensionID, update);
-    await this.repositoryExtensionModel.update({
-      extensionID
+  async updateExtension(extensionSlug, update) {
+    this.logger.trace('updateExtension with extension [%s], update [%j]', extensionSlug, update);
+    await this.model.update({
+      extensionSlug
     }, {
       $set: update
     }, {
       upsert: true
     });
-    return this.repositoryExtensionModel.findOne({
-      extensionID
+    return this.model.findOne({
+      extensionSlug
     }).exec();
   }
-  async deleteExtension(extensionID) {
+  async deleteExtension(extensionSlug) {
     try {
-      this.logger.trace('deleteExtension with extensionID [%s]', extensionID);
-      const deleteRecord = await this.repositoryExtensionModel.deleteOne({
-        extensionID
+      this.logger.trace('deleteExtension with extensionSlug [%s]', extensionSlug);
+      const deleteRecord = await this.model.deleteOne({
+        extensionSlug
       }).exec();
       return deleteRecord.acknowledged && deleteRecord.deletedCount === 1;
     } catch (err) {
-      this.logger.error(err, 'delete account with payload [%s] failed due to [%o]', extensionID);
+      this.logger.error(err, 'delete account with payload [%s] failed due to [%o]', extensionSlug);
       return false;
     }
   }
-  async extensionReleases(extensionID) {
-    const extension = await this.findExtension(extensionID);
+  async extensionReleases(extensionSlug) {
+    const extension = await this.findExtension(extensionSlug);
     return extension.releases;
   }
   // TODO: change param to IPublishRequest
   async publishExtension(request) {
-    let extension = await this.repositoryExtensionModel.findOne({
-      extensionID: request.extensionID
+    let extension = await this.model.findOne({
+      extensionSlug: request.extensionSlug
     }).exec();
-    const obj = pick(request, ['extensionID', 'name', 'description', 'publisher']);
+    const obj = pick(request, ['extensionSlug', 'name', 'description', 'publisher']);
     let manifest = {};
     try {
       manifest = JSON.parse(request.manifest);
@@ -77,20 +79,20 @@ let RegistryExtensionRepository = RegistryExtensionRepository_1 = class Registry
     obj.activationEvents = manifest.activationEvents || [];
     if (!extension) {
       this.logger.debug('New extension created...');
-      extension = await this.repositoryExtensionModel.create(obj);
+      extension = await this.model.create(obj);
     }
     const release = {
       bundle: request.bundle,
       version: request.version,
       manifest: request.manifest,
       sourceMap: request.sourceMap,
-      extensionID: request.extensionID,
+      extensionSlug: request.extensionSlug,
       activationEvents: manifest.activationEvents
     };
     try {
       this.logger.trace('publishExtension with request [%j]', request);
-      const releaseExists = await this.repositoryExtensionModel.findOne({
-        extensionID: request.extensionID,
+      const releaseExists = await this.model.findOne({
+        extensionSlug: request.extensionSlug,
         'releases.version': request.version
       });
       if (!isEmpty(extension.releases) && releaseExists && !request.force) {
@@ -99,8 +101,8 @@ let RegistryExtensionRepository = RegistryExtensionRepository_1 = class Registry
       } else {
         const releases = filter(extension.releases, record => record.version !== request.version).concat([release]);
         this.logger.trace('Release updates [%j]', releases);
-        await this.repositoryExtensionModel.update({
-          extensionID: request.extensionID
+        await this.model.update({
+          extensionSlug: request.extensionSlug
         }, {
           $set: {
             ...obj,
@@ -111,8 +113,8 @@ let RegistryExtensionRepository = RegistryExtensionRepository_1 = class Registry
           upsert: true
         });
       }
-      return this.repositoryExtensionModel.findOne({
-        extensionID: request.extensionID
+      return this.model.findOne({
+        extensionSlug: request.extensionSlug
       }).exec();
     } catch (err) {
       this.logger.error(err, 'publishExtension was failed for request [%j] with error[%o]', request);
@@ -120,16 +122,16 @@ let RegistryExtensionRepository = RegistryExtensionRepository_1 = class Registry
     }
   }
   async findExtensions(first, query, local, remote, prioritizeExtensionIDs) {
-    return this.repositoryExtensionModel.find({}).exec();
+    return this.model.find({}).exec();
   }
-  async findExtension(extensionID, version) {
+  async findExtension(extensionSlug, version) {
     const q = {
-      extensionID
+      extensionSlug
     };
     if (version) {
       q.version = version;
     }
-    return this.repositoryExtensionModel.findOne(q);
+    return this.model.findOne(q);
   }
 };
-RegistryExtensionRepository = RegistryExtensionRepository_1 = __decorate([injectable(), __param(0, inject(SERVER_TYPES.IExtensionMongoConnection)), __param(1, inject('Logger')), __param(2, inject('MongoOptions')), __param(2, optional()), __metadata("design:paramtypes", [mongoose.Connection, Object, Object])], RegistryExtensionRepository);export{RegistryExtensionRepository};//# sourceMappingURL=registry-extension-repository.js.map
+RegistryExtensionRepository = RegistryExtensionRepository_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])], RegistryExtensionRepository);export{RegistryExtensionRepository};//# sourceMappingURL=registry-extension-repository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry-extension-repository.js","sources":["../../../src/store/repositories/registry-extension-repository.ts"],"sourcesContent":[null],"names":[],"mappings":"0YAGA,IAAA,6BAA0B;;;;;AAqCT,MAAA,MAAA,IAAA,KAAA,CAAA,oCAAuD,CAAA;;;;;;;AAMvD,IAAA,IAAA,CAAA,MAAA,CAAA,KAA6B,CAAA,kDAAkB,EAAA,WAAA,EAAA,IAAA,CAAA;UAAW,MAAA,GAAG,MAAA,IAAO,CAAA,KAAA,CAAA,MAAA,CAAA;AAAE,MAAA,WAAA;;;;;;;IAMtE,OAAe,MAAA;AAWf;QAMgB,mBAAQ,CAAA,aAAK,EAAA,IAAA,EAAA;;;;;;;;;;;;;;;;;;;;;AA6E7C,KAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

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

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

@@ -3,4 +3,7 @@ export const SERVER_TYPES = {
     IExtensionMongoConnection: Symbol('ExtensionMongoConnection'),
     IRegistryExtensionService: Symbol('IRegistryExtensionService'),
     IRegistryExtensionRepository: Symbol('IRegistryExtensionRepository'),
+    IRegistryExtensionDataLoader: Symbol('IRegistryExtensionDataLoader'),
+    IInstalledExtensionService: Symbol('IInstalledExtensionService'),
+    IInstalledExtensionRepository: Symbol('IInstalledExtensionRepository'),
 };