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

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

@@ -1,54 +1,42 @@
 import { CdmLogger } from '@cdm-logger/core';
-import { IRegistryExtensionService, IRegistryExtensionRepository } from 'common/server';
-export declare class RegistryExtensionService implements IRegistryExtensionService {
+import { BaseService2 } from '@common-stack/store-mongo';
+import { Disposable, DisposableCollection, Emitter } from '@adminide-stack/core';
+import { IRegistryExtensionService, IRegistryExtensionRepository, IRegistryExtensionModel } from 'common/server';
+export declare class RegistryExtensionService extends BaseService2<IRegistryExtensionModel> implements IRegistryExtensionService, Disposable {
     private extensionRepository;
+    protected readonly onExtensionCreated: Emitter<{
+        extensionSlug: string;
+        publisherId: string;
+        name: string;
+        createdAt: string;
+    }>;
+    protected readonly onExtensionUpdated: Emitter<{
+        extensionSlug: string;
+        changes: Record<string, unknown>;
+        updatedAt: string;
+    }>;
+    protected readonly onExtensionDeleted: Emitter<{
+        extensionSlug: string;
+        deletedAt: string;
+    }>;
+    protected readonly onExtensionPublished: Emitter<{
+        extensionSlug: string;
+        version: string;
+        publishedAt: string;
+    }>;
+    protected readonly toDispose: DisposableCollection;
     private logger;
     constructor(extensionRepository: IRegistryExtensionRepository, logger: CdmLogger.ILogger);
-    createExtension(publisherId: string, name: string): Promise<import("common").INode & {
-        __typename?: "RegistryExtension";
-        activationEvents?: import("common").Maybe<Array<import("common").Maybe<import("common").Scalars["String"]["output"]>>>;
-        extensionID?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        extensionIDWithoutRegistry?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        id: import("common").Scalars["ID"]["output"];
-        installed?: import("common").Maybe<import("common").Scalars["Boolean"]["output"]>;
-        isLocal?: import("common").Maybe<import("common").Scalars["Boolean"]["output"]>;
-        manifest?: import("common").Maybe<import("common").IExtensionManifest>;
-        name: import("common").Scalars["String"]["output"];
-        publisher?: import("common").Maybe<import("common").IRegistryPublisher>;
-        releases?: import("common").Maybe<Array<import("common").Maybe<import("common").IExtensionRelease>>>;
-        remoteURL?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        updatedAt?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        url?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        uuid: import("common").Scalars["String"]["output"];
-        version?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        viewerCanAdminister?: import("common").Maybe<import("common").Scalars["Boolean"]["output"]>;
-    } & import("common/server").IRepositoryDefault>;
-    updateExtensionName(extensionID: string, name: string): Promise<any>;
-    updateExtension(extensionID: string, update: {
+    dispose(): void;
+    createExtension(publisherId: string, name: string): Promise<import("common/server").AsDomainType<IRegistryExtensionModel>>;
+    updateExtensionName(extensionSlug: string, name: string): Promise<import("common/server").AsDomainType<IRegistryExtensionModel>>;
+    updateExtension(extensionSlug: string, update: {
         installed?: boolean;
-    }): Promise<import("common").INode & {
-        __typename?: "RegistryExtension";
-        activationEvents?: import("common").Maybe<Array<import("common").Maybe<import("common").Scalars["String"]["output"]>>>;
-        extensionID?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        extensionIDWithoutRegistry?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        id: import("common").Scalars["ID"]["output"];
-        installed?: import("common").Maybe<import("common").Scalars["Boolean"]["output"]>;
-        isLocal?: import("common").Maybe<import("common").Scalars["Boolean"]["output"]>;
-        manifest?: import("common").Maybe<import("common").IExtensionManifest>;
-        name: import("common").Scalars["String"]["output"];
-        publisher?: import("common").Maybe<import("common").IRegistryPublisher>;
-        releases?: import("common").Maybe<Array<import("common").Maybe<import("common").IExtensionRelease>>>;
-        remoteURL?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        updatedAt?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        url?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        uuid: import("common").Scalars["String"]["output"];
-        version?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        viewerCanAdminister?: import("common").Maybe<import("common").Scalars["Boolean"]["output"]>;
-    } & import("common/server").IRepositoryDefault>;
-    extensionReleases(extensionID: string): Promise<import("common").IExtensionRelease[]>;
-    deleteExtension(extensionID: string): Promise<boolean>;
-    publishExtension(request: any): Promise<any>;
-    findExtensions(first: number, query: string, local?: boolean, remote?: boolean, prioritizeExtensionIDs?: string[]): Promise<any>;
-    findExtension(extensionID: string): Promise<any>;
+    }): Promise<import("common/server").AsDomainType<IRegistryExtensionModel>>;
+    extensionReleases(extensionSlug: string): Promise<import("common/server").AsDomainType<import("common").IExtensionReleaseModel>[]>;
+    deleteExtension(extensionSlug: string): Promise<boolean>;
+    publishExtension(request: any): Promise<import("common/server").AsDomainType<IRegistryExtensionModel>>;
+    findExtensions(first: number, query: string, local?: boolean, remote?: boolean, prioritizeExtensionIDs?: string[]): Promise<import("common/server").AsDomainType<IRegistryExtensionModel>[]>;
+    findExtension(extensionSlug: string): Promise<import("common/server").AsDomainType<IRegistryExtensionModel>>;
 }
 //# sourceMappingURL=extension-service.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"extension-service.d.ts","sourceRoot":"","sources":["../../src/services/extension-service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAgB,yBAAyB,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAEtG,qBACa,wBAAyB,YAAW,yBAAyB;IAKlE,OAAO,CAAC,mBAAmB;IAJ/B,OAAO,CAAC,MAAM,CAAoB;gBAItB,mBAAmB,EAAE,4BAA4B,EAGzD,MAAM,EAAE,SAAS,CAAC,OAAO;IAKhB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;;+EA4C4m6a,kCAAiB;6CAA4G,kCAAiB;4DAA2G,kCAAiB;YAAkF,8BAAc;2CAAiF,mCAAkB;yCAA8G,mCAAkB;;cAAyI,kCAAkB;;;2CAA4R,kCAAiB;2CAA6G,kCAAiB;qCAAuF,kCAAiB;cAA4D,kCAAkB;yCAAqE,kCAAiB;qDAA4H,mCAAkB;;IAxC1s9a,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAIrD,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;;+EAoCyl6a,kCAAiB;6CAA4G,kCAAiB;4DAA2G,kCAAiB;YAAkF,8BAAc;2CAAiF,mCAAkB;yCAA8G,mCAAkB;;cAAyI,kCAAkB;;;2CAA4R,kCAAiB;2CAA6G,kCAAiB;qCAAuF,kCAAiB;cAA4D,kCAAkB;yCAAqE,kCAAiB;qDAA4H,mCAAkB;;IA3B1s9a,iBAAiB,CAAC,WAAW,EAAE,MAAM;IAKrC,eAAe,CAAC,WAAW,EAAE,MAAM;IAInC,gBAAgB,CAAC,OAAO,KAAA;IAIxB,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,WAAW,EAAE,MAAM;CAGjD"}
+{"version":3,"file":"extension-service.d.ts","sourceRoot":"","sources":["../../src/services/extension-service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACjF,OAAO,EAEH,yBAAyB,EACzB,4BAA4B,EAC5B,uBAAuB,EAC1B,MAAM,eAAe,CAAC;AAEvB,qBACa,wBACT,SAAQ,YAAY,CAAC,uBAAuB,CAC5C,YAAW,yBAAyB,EAAE,UAAU;IAqC5C,OAAO,CAAC,mBAAmB;IAnC/B,SAAS,CAAC,QAAQ,CAAC,kBAAkB;uBAClB,MAAM;qBACR,MAAM;cACb,MAAM;mBACD,MAAM;OAChB;IAEL,SAAS,CAAC,QAAQ,CAAC,kBAAkB;uBAClB,MAAM;iBACZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;mBACrB,MAAM;OAChB;IAEL,SAAS,CAAC,QAAQ,CAAC,kBAAkB;uBAClB,MAAM;mBACV,MAAM;OAChB;IAEL,SAAS,CAAC,QAAQ,CAAC,oBAAoB;uBACpB,MAAM;iBACZ,MAAM;qBACF,MAAM;OAClB;IAEL,SAAS,CAAC,QAAQ,CAAC,SAAS,uBAK1B;IAEF,OAAO,CAAC,MAAM,CAAoB;gBAItB,mBAAmB,EAAE,4BAA4B,EAGzD,MAAM,EAAE,SAAS,CAAC,OAAO;IAM7B,OAAO,IAAI,IAAI;IAIF,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAIjD,mBAAmB,CAAC,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAIvD,eAAe,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;IAqBtE,iBAAiB,CAAC,aAAa,EAAE,MAAM;IAKvC,eAAe,CAAC,aAAa,EAAE,MAAM;IAIrC,gBAAgB,CAAC,OAAO,KAAA;IAIxB,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;CAGnD"}

package/lib/services/extension-service.js

@@ -1,33 +1,51 @@
-import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import'@cdm-logger/core';import {SERVER_TYPES}from'common/server';var RegistryExtensionService_1;
-let RegistryExtensionService = RegistryExtensionService_1 = class RegistryExtensionService {
+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';var RegistryExtensionService_1;
+let RegistryExtensionService = RegistryExtensionService_1 = class RegistryExtensionService extends BaseService2 {
   extensionRepository;
+  onExtensionCreated = new Emitter();
+  onExtensionUpdated = new Emitter();
+  onExtensionDeleted = new Emitter();
+  onExtensionPublished = new Emitter();
+  toDispose = new DisposableCollection(this.onExtensionCreated, this.onExtensionUpdated, this.onExtensionDeleted, this.onExtensionPublished);
   logger;
   constructor(extensionRepository, logger) {
+    super(extensionRepository);
     this.extensionRepository = extensionRepository;
     this.logger = logger.child({
       className: RegistryExtensionService_1.name
     });
   }
+  dispose() {
+    this.toDispose.dispose();
+  }
   async createExtension(publisherId, name) {
     return this.extensionRepository.createExtension(publisherId, name);
   }
-  async updateExtensionName(extensionID, name) {
-    return this.extensionRepository.updateExtensionName(extensionID, name);
+  async updateExtensionName(extensionSlug, name) {
+    return this.extensionRepository.updateExtensionName(extensionSlug, name);
   }
-  async updateExtension(extensionID, update) {
-    const extension = await this.findExtension(extensionID);
+  async updateExtension(extensionSlug, update) {
+    const extension = await this.findExtension(extensionSlug);
     if (!extension) {
-      throw new Error(`Extension ${extensionID} not found`);
+      throw new Error(`Extension ${extensionSlug} not found`);
+    }
+    const updatedExtension = await this.extensionRepository.updateExtension(extensionSlug, update);
+    // Fire events for extension lifecycle changes
+    if (updatedExtension) {
+      this.onExtensionUpdated.fire({
+        extensionSlug: updatedExtension.extensionSlug,
+        changes: update,
+        updatedAt: new Date().toISOString()
+      });
     }
-    return this.extensionRepository.updateExtension(extensionID, update);
+    return updatedExtension;
   }
   // TODO: Add method to interface
-  async extensionReleases(extensionID) {
-    this.logger.debug(`Fetching releases for ${extensionID}`);
-    return this.extensionRepository.extensionReleases(extensionID);
+  async extensionReleases(extensionSlug) {
+    this.logger.debug(`Fetching releases for ${extensionSlug}`);
+    return this.extensionRepository.extensionReleases(extensionSlug);
   }
-  async deleteExtension(extensionID) {
-    return this.extensionRepository.deleteExtension(extensionID);
+  async deleteExtension(extensionSlug) {
+    return this.extensionRepository.deleteExtension(extensionSlug);
   }
   async publishExtension(request) {
     return this.extensionRepository.publishExtension(request);
@@ -35,8 +53,8 @@ let RegistryExtensionService = RegistryExtensionService_1 = class RegistryExtens
   async findExtensions(first, query, local, remote, prioritizeExtensionIDs) {
     return this.extensionRepository.findExtensions(first, query, local, remote, prioritizeExtensionIDs);
   }
-  async findExtension(extensionID) {
-    return this.extensionRepository.findExtension(extensionID);
+  async findExtension(extensionSlug) {
+    return this.extensionRepository.findExtension(extensionSlug);
   }
 };
 RegistryExtensionService = RegistryExtensionService_1 = __decorate([injectable(), __param(0, inject(SERVER_TYPES.IRegistryExtensionRepository)), __param(1, inject('Logger')), __metadata("design:paramtypes", [Object, Object])], RegistryExtensionService);export{RegistryExtensionService};//# sourceMappingURL=extension-service.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"extension-service.js","sources":["../../src/services/extension-service.ts"],"sourcesContent":[null],"names":[],"mappings":"8JACA,IAAA;AASgB,IAAA,wBAAA,GAAA,0BAAiD,GAAA,MAAA,wBAGhC,CAAA;AAKhB,EAAA,mBAA2B;;;kDA4Cgx6a;;eAA4N,EAAA,0BAAA,CAAA;;;;eAA8X,CAAA,mBAAA,CAAA,eAAA,CAAA,WAAA,EAAA,IAAA,CAAA;;;uDAA6S,CAAA,WAAA,EAAA,IAAA,CAAA;;qCAAqN,MAAiB,EAAA;mBAA8E,GAAA,MAAA,IAAA,CAAA,aAAA,CAAA,WAAA,CAAA;;yDAAoO,CAAA,CAAA;;AAxC1s9a,IAAA,OAAA,IAAA,CAAA,mBAA+B,CAAA,eAAgB,CAAM,WAAA,EAAA,MAAA,CAAA;AAIrD;;AAAoE,EAAA,MAAA,iBAAA,CAAA,WAAA,EAAA;;;;;eAoCm86a,CAAA,mBAAA,CAAA,eAAA,CAAA,WAAA,CAAA;;;;;;;;;iDAAi5B,CAAA,WAAA,CAAA;;;qDAAgS,GAAkB,UAAA,CAAA,CAAA,UAAA,EAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,CAAA,YAAA,CAAA,4BAAA,CAAA,CAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,CAAA,QAAA,CAAA,CAAA,EAAA,UAAA,CAAA,mBAAA,EAAA,CAAA,MAAA,EAAA,MAAA,CAAA,CAAA,CAAA,EAAA,wBAAA,CAAA"}
+{"version":3,"file":"extension-service.js","sources":["../../src/services/extension-service.ts"],"sourcesContent":[null],"names":[],"mappings":"mRACA,IAAA;4BAgB6B,GAAA,0BAAA,GAAA,MAAA,wBAAA,SAAA,YAAA,CAAA;qBACR;oBACD,GAAA,IAAA,OAAA,EAAA;oBACK,GAAA,IAAA,OAAA,EAAA;AAChB,EAAA,kBAAA,GAAA,IAAA,OAAA,EAAA;sBAEa,GAAmB,IAAA,OAAA,EAAA;sCACZ,CAAA,IAAA,CAAA,kBAAA,EAAA,IAAA,CAAA,kBAAA,EAAA,IAAA,CAAA,kBAAA,EAAA,IAAA,CAAA,oBAAA,CAAA;AACZ,EAAA,MAAA;iCACQ,EAAA,MAAA,EAAA;AAChB,IAAA,KAAA,CAAA,mBAAA,CAAA;IAEL,IAAS,CAAA,mBAA4B,GAAA,mBAAA;wBACZ,CAAA,KAAA,CAAA;2CACJ,CAAA;AAChB,KAAA,CAAA;;;kBAIc,CAAA,OAAA,EAAA;;AAEd,EAAA,MAAA,eAAA,CAAA,WAAA,EAAA,IAAA,EAAA;AAEL,IAAA,OAAA,IAAU,CAAA,mBAKR,CAAA,eAAA,CAAA,WAAA,EAAA,IAAA,CAAA;;AAMU,EAAA,MAAA,mBAAA,CAAA,aAAiD,EAAA,IAAA,EAAA;AAS7D,IAAA,OAAO,IAAI,CAAI,mBAAA,CAAA,mBAAA,CAAA,aAAA,EAAA,IAAA,CAAA;AAIF;AAIA,EAAA,MAAA,eAAmB,CAAC,aAAa,EAAE,MAAM,EAAE;AAI3C,IAAA,MAAA,SAAe,GAAc,MAAA,IAAA,CAAA,2BAAkB,CAAA;QAAE,CAAS,SAAC,EAAE;AAAS,MAAA,MAAA,IAAA,KAAA,CAAA,CAAA,UAAA,EAAA,aAAA,CAAA,UAAA,CAAA,CAAA;;IA0BtE,MAAe,gBAAc,GAAA,MAAE,IAAM,CAAA,mBAAA,CAAA,eAAA,CAAA,aAAA,EAAA,MAAA,CAAA;;IAQrC,IAAc,gBAClB,EAAE;MASe,IAAA,CAAA,kBAAc,CAAA,IAAQ,CAAA;AAGnD,QAAA,aAAA,EAAA,gBAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/services/index.d.ts

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-service-ext.d.ts","sourceRoot":"","sources":["../../src/services/installed-extension-service-ext.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAgBH,yBAAyB,EACzB,6BAA6B,EAOhC,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAE1E;;;GAGG;AACH,qBACa,4BAA6B,SAAQ,yBAAyB;gBAEf,UAAU,EAAE,6BAA6B,EAC7C,eAAe,EAAE,yBAAyB,EACrD,MAAM,EAAE,aAAa,EAC/B,MAAM,EAAE,SAAS,CAAC,OAAO;IAMxD,OAAO,CAAC,mBAAmB;CAsT9B"}

package/lib/services/installed-extension-service-ext.js

@@ -0,0 +1,271 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import'@cdm-logger/core';import {SERVER_TYPES,ConfigurationSchemaId,ContributionRegistryServiceEvent,MoleculerServiceName,SystemContributionExtensionNames,ExtensionServiceAction}from'common/server';import {InstalledExtensionService}from'./installed-extension-service.js';/**
+ * Extended InstalledExtensionService that handles Moleculer event broadcasting
+ * Follows the pattern of AccountService/AccountServiceExt
+ */
+let InstalledExtensionServiceExt = class InstalledExtensionServiceExt extends InstalledExtensionService {
+  constructor(repository, registryService, broker, logger) {
+    super(repository, registryService, broker, logger);
+    this.setupEventListeners();
+  }
+  setupEventListeners() {
+    // Listen to extension installed events
+    this.onExtensionInstalled.event(async event => {
+      console.log('_____>>>>>>> EXTENSION INSTALLLED EVENT IS GETTIN CALLED');
+      try {
+        // Get full extension data with metadata to extract contributions
+        const registryExtension = await this.registryExtensionService.findExtension(event.extensionSlug);
+        let configurationNodes = [];
+        let configurationDefaults = [];
+        if (registryExtension && registryExtension.manifest) {
+          console.log('Extension found with manifest:', event.extensionSlug);
+          console.log('Manifest object keys:', Object.keys(registryExtension.manifest));
+          // The manifest is now properly parsed by the model's virtual property
+          let contributes = null;
+          // Check if manifest has contributes directly (cast to access contributes property)
+          const manifestAny = registryExtension.manifest;
+          if (manifestAny.contributes) {
+            contributes = manifestAny.contributes;
+            console.log('Found parsed contributes:', Object.keys(contributes));
+          }
+          // Fallback: try to parse raw if contributes not found but raw exists
+          else if (registryExtension.manifest.raw) {
+            try {
+              const parsedManifest = JSON.parse(registryExtension.manifest.raw);
+              console.log('Parsed manifest keys:', Object.keys(parsedManifest));
+              contributes = parsedManifest.contributes;
+              console.log('Parsed contributes from manifest.raw:', contributes ? 'found' : 'not found');
+              if (contributes) {
+                console.log('Contributes keys:', Object.keys(contributes));
+                console.log('Configuration exists:', !!contributes.configuration);
+                if (contributes.configuration) {
+                  console.log('Configuration data:', JSON.stringify(contributes.configuration, null, 2));
+                }
+              }
+            } catch (error) {
+              console.warn('Failed to parse extension manifest.raw:', error);
+            }
+          } else {
+            console.log('No manifest.raw found');
+          }
+          // Extract configuration contributions if they exist
+          if (contributes && contributes.configuration) {
+            console.log('Configuration contributions found, processing...');
+            const configurations = Array.isArray(contributes.configuration) ? contributes.configuration : [contributes.configuration];
+            // Format contributions for configuration registry
+            configurationNodes = configurations.map(config => ({
+              id: `${event.extensionSlug}`,
+              title: config.title || registryExtension.name,
+              description: config.description || registryExtension.manifest.description,
+              properties: config.properties || {},
+              type: config.type || ['object'],
+              scope: 'WINDOW',
+              // Default scope
+              extensionInfo: {
+                id: event.extensionSlug,
+                displayName: registryExtension.name
+              }
+            }));
+            // Create configuration defaults
+            configurationDefaults = [{
+              source: {
+                id: event.extensionSlug,
+                displayName: registryExtension.name
+              },
+              overrides: {} // Default empty overrides
+            }];
+            console.log(`Processed ${configurationNodes.length} configuration nodes`);
+          } else {
+            console.log('No configuration contributions found in manifest');
+          }
+        } else {
+          console.log('No extension or manifest found for:', event.extensionSlug);
+        }
+        // Add the extension's enabled/disabled state to configuration nodes
+        // This tracks the extension status regardless of whether it has configuration contributions
+        const extensionStatusNode = {
+          id: `${event.extensionSlug}.status`,
+          title: `${registryExtension?.name || event.extensionSlug} Status`,
+          description: `Extension enabled/disabled status for ${event.extensionSlug}`,
+          properties: {
+            [`extensions.${event.extensionSlug}`]: {
+              type: 'boolean',
+              default: true,
+              // Default to enabled when installed
+              description: `Enable/disable ${event.extensionSlug} extension`,
+              scope: 'window'
+            }
+          },
+          type: ['object'],
+          scope: 3 /* ConfigurationScope.WINDOW */,
+          extensionInfo: {
+            id: event.extensionSlug,
+            displayName: registryExtension?.name || event.extensionSlug
+          }
+        };
+        // Add the extension status node to configurationNodes
+        // configurationNodes.push(extensionStatusNode);
+        // Create the configuration node data that configuration registry expects
+        const configurationNode = {
+          schemaId: ConfigurationSchemaId.Configuration,
+          tenantId: event.tenantId,
+          extensionName: event.extensionSlug,
+          policyConfigs: event.policies || null,
+          configurationNodes,
+          configurationDefaults
+        };
+        const context = {
+          schemaId: ConfigurationSchemaId.Configuration,
+          tenantId: event.tenantId,
+          extensionName: event.extensionSlug,
+          accountId: event.installedBy
+          // Add other context fields as needed
+        };
+        console.log('Broadcasting configuration registry event with data:', {
+          configurationNode: {
+            ...configurationNode,
+            configurationNodes: `${configurationNodes.length} nodes`
+          },
+          context
+        });
+        this.broker.broadcast(ContributionRegistryServiceEvent.ContributionNodeRegistryAdd, {
+          configurationNode,
+          context,
+          timestamp: new Date()
+        }, [MoleculerServiceName.ConfigurationRegistryService
+        // MoleculerServiceName.MailService, // Using MailService instead of NotificationService
+        ]);
+        // Create separate configuration node for system extension status
+        const systemExtensionNode = {
+          schemaId: ConfigurationSchemaId.Configuration,
+          tenantId: event.tenantId,
+          extensionName: SystemContributionExtensionNames.SystemExtension,
+          policyConfigs: null,
+          configurationNodes: [extensionStatusNode]
+        };
+        const systemContext = {
+          schemaId: ConfigurationSchemaId.Configuration,
+          tenantId: event.tenantId,
+          extensionName: SystemContributionExtensionNames.SystemExtension,
+          accountId: event.installedBy
+        };
+        this.broker.broadcast(ContributionRegistryServiceEvent.ContributionNodeRegistryAdd, {
+          configurationNode: systemExtensionNode,
+          context: systemContext,
+          timestamp: new Date()
+        }, [MoleculerServiceName.ConfigurationRegistryService
+        // MoleculerServiceName.MailService, // Using MailService instead of NotificationService
+        ]);
+      } catch (error) {
+        console.error('Error processing extension installed event:', error);
+      }
+    });
+    // Listen to extension uninstalled events
+    this.onExtensionUninstalled.event(async event => {
+      try {
+        // Remove extension status from configuration registry
+        const context = {
+          schemaId: ConfigurationSchemaId.Configuration,
+          tenantId: event.tenantId,
+          extensionName: event.extensionSlug,
+          accountId: event.uninstalledBy
+        };
+        // Remove the extension's own configuration registry entry
+        this.broker.broadcast(ContributionRegistryServiceEvent.ContributionNodeRegistryRemove, {
+          context,
+          timestamp: new Date()
+        }, [MoleculerServiceName.ConfigurationRegistryService]);
+        // Remove the extension status from system extensions
+        const systemContext = {
+          schemaId: ConfigurationSchemaId.Configuration,
+          tenantId: event.tenantId,
+          extensionName: SystemContributionExtensionNames.SystemExtension,
+          accountId: event.uninstalledBy
+        };
+        this.broker.broadcast(ContributionRegistryServiceEvent.ContributionNodeRegistryRemove, {
+          context: systemContext,
+          timestamp: new Date()
+        }, [MoleculerServiceName.ConfigurationRegistryService]);
+      } catch (error) {
+        console.error('Error processing extension uninstalled event:', error);
+      }
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionUninstalled, {
+        event
+      }, [MoleculerServiceName.ConfigurationService, 'WorkbenchService',
+      // Using string literal as MoleculerServiceName.WorkbenchService doesn't exist
+      MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+    // Listen to extension enabled events
+    this.onExtensionEnabled.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionEnabled, {
+        event
+      }, [MoleculerServiceName.ConfigurationService, 'WorkbenchService' // Using string literal as MoleculerServiceName.WorkbenchService doesn't exist
+      ]);
+    });
+    // Listen to extension disabled events
+    this.onExtensionDisabled.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionDisabled, {
+        event
+      }, [MoleculerServiceName.ConfigurationService, 'WorkbenchService' // Using string literal as MoleculerServiceName.WorkbenchService doesn't exist
+      ]);
+    });
+    // Listen to extension updated events
+    this.onExtensionUpdated.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionUpdated, {
+        event
+      }, [MoleculerServiceName.ConfigurationService]);
+    });
+    // Listen to extension version updated events
+    this.onExtensionVersionUpdated.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionVersionUpdated, {
+        event
+      }, [MoleculerServiceName.ConfigurationService, 'WorkbenchService',
+      // Using string literal as MoleculerServiceName.WorkbenchService doesn't exist
+      MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+    // Listen to extension configuration updated events
+    this.onExtensionConfigurationUpdated.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionConfigurationUpdated, {
+        event
+      }, [MoleculerServiceName.ConfigurationService, 'WorkbenchService' // Using string literal as MoleculerServiceName.WorkbenchService doesn't exist
+      ]);
+    });
+    // Listen to extension sync completed events
+    this.onExtensionSyncCompleted.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionSyncCompleted, {
+        event
+      }, [MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+    // Listen to extension cleanup completed events
+    this.onExtensionCleanupCompleted.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionCleanupCompleted, {
+        event
+      }, [MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+    // Listen to extension activation failed events
+    this.onExtensionActivationFailed.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionActivationFailed, {
+        event
+      }, [MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+    // Listen to extension deprecated events
+    this.onExtensionDeprecated.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionDeprecated, {
+        event
+      }, [MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+    // Listen to extension orphaned events
+    this.onExtensionOrphaned.event(event => {
+      this.broker.broadcast(ExtensionServiceAction.OnExtensionOrphaned, {
+        event
+      }, [MoleculerServiceName.MailService // Using MailService instead of NotificationService
+      ]);
+    });
+  }
+};
+InstalledExtensionServiceExt = __decorate([injectable(), __param(0, inject(SERVER_TYPES.IInstalledExtensionRepository)), __param(1, inject(SERVER_TYPES.IRegistryExtensionService)), __param(2, inject(CommonType.MOLECULER_BROKER)), __param(3, inject(CommonType.LOGGER)), __metadata("design:paramtypes", [Object, Object, ServiceBroker, Object])], InstalledExtensionServiceExt);export{InstalledExtensionServiceExt};//# sourceMappingURL=installed-extension-service-ext.js.map

package/lib/services/installed-extension-service-ext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-service-ext.js","sources":["../../src/services/installed-extension-service-ext.ts"],"sourcesContent":[null],"names":[],"mappings":"6bAkCG;AACH;AAG4D;AASxD;AAsTH,IAAA,4BAAA,GAAA,MAAA,4BAAA,SAAA,yBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,93 @@
+import { CdmLogger } from '@cdm-logger/core';
+import { ServiceBroker } from 'moleculer';
+import { Disposable, DisposableCollection, Emitter } from '@adminide-stack/core';
+import { IInstalledExtensionModel, ICreateInstalledExtensionInput, IUpdateInstalledExtensionInput, IRegistryExtensionService, IInstalledExtensionFilter, IInstalledExtensionService, IInstalledExtensionRepository, IExtensionInstalledEvent, IExtensionUninstalledEvent, IExtensionEnabledEvent, IExtensionDisabledEvent, IExtensionUpdatedEvent, IExtensionVersionUpdatedEvent, IExtensionStatusChangedEvent, IExtensionActivationFailedEvent, IExtensionDeprecatedEvent, IExtensionOrphanedEvent, IExtensionConfigurationUpdatedEvent, IExtensionSyncCompletedEvent, IExtensionCleanupCompletedEvent, AsDomainType } from 'common/server';
+import { BaseService2 } from '@common-stack/store-mongo';
+export declare class InstalledExtensionService extends BaseService2<IInstalledExtensionModel> implements IInstalledExtensionService, Disposable {
+    private installedExtensionRepository;
+    protected registryExtensionService: IRegistryExtensionService;
+    protected broker: ServiceBroker;
+    protected readonly onExtensionInstalled: Emitter<IExtensionInstalledEvent>;
+    protected readonly onExtensionUninstalled: Emitter<IExtensionUninstalledEvent>;
+    protected readonly onExtensionEnabled: Emitter<IExtensionEnabledEvent>;
+    protected readonly onExtensionDisabled: Emitter<IExtensionDisabledEvent>;
+    protected readonly onExtensionUpdated: Emitter<IExtensionUpdatedEvent>;
+    protected readonly onExtensionVersionUpdated: Emitter<IExtensionVersionUpdatedEvent>;
+    protected readonly onExtensionConfigurationUpdated: Emitter<IExtensionConfigurationUpdatedEvent>;
+    protected readonly onExtensionSyncCompleted: Emitter<IExtensionSyncCompletedEvent>;
+    protected readonly onExtensionCleanupCompleted: Emitter<IExtensionCleanupCompletedEvent>;
+    protected readonly onExtensionStatusChanged: Emitter<IExtensionStatusChangedEvent>;
+    protected readonly onExtensionActivationFailed: Emitter<IExtensionActivationFailedEvent>;
+    protected readonly onExtensionDeprecated: Emitter<IExtensionDeprecatedEvent>;
+    protected readonly onExtensionOrphaned: Emitter<IExtensionOrphanedEvent>;
+    protected readonly toDispose: DisposableCollection;
+    private logger;
+    constructor(installedExtensionRepository: IInstalledExtensionRepository, registryExtensionService: IRegistryExtensionService, broker: ServiceBroker, logger: CdmLogger.ILogger);
+    dispose(): void;
+    /**
+     * Install a new extension from the registry
+     */
+    installExtension(input: ICreateInstalledExtensionInput): Promise<AsDomainType<IInstalledExtensionModel>>;
+    /**
+     * Internal method to perform the actual installation after validation
+     */
+    private doInstallExtension;
+    /**
+     * Uninstall an extension
+     */
+    uninstallExtension(tenantId: string, extensionSlug: string, uninstalledBy: string): Promise<boolean>;
+    /**
+     * Update an installed extension's configuration or status
+     */
+    updateInstalledExtension(tenantId: string, extensionSlug: string, update: IUpdateInstalledExtensionInput): Promise<AsDomainType<IInstalledExtensionModel>>;
+    /**
+     * Get a specific installed extension
+     */
+    getInstalledExtension(tenantId: string, extensionSlug: string): Promise<AsDomainType<IInstalledExtensionModel> | null>;
+    /**
+     * Get all installed extensions for a tenant with optional filtering
+     */
+    getInstalledExtensions(filter: IInstalledExtensionFilter): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+    /**
+     * Enable/disable an installed extension
+     */
+    toggleExtension(tenantId: string, extensionSlug: string, enabled: boolean, toggledBy: string): Promise<AsDomainType<IInstalledExtensionModel>>;
+    /**
+     * Update extension settings/configuration
+     */
+    updateExtensionSettings(tenantId: string, extensionSlug: string, userConfig: Record<string, unknown>, updatedBy: string): Promise<AsDomainType<IInstalledExtensionModel>>;
+    /**
+     * Check for extension updates and return available updates
+     */
+    checkForUpdates(tenantId: string, extensionSlug?: string): Promise<Array<{
+        extensionSlug: string;
+        currentVersion: string;
+        availableVersion: string;
+        isSecurityUpdate: boolean;
+    }>>;
+    /**
+     * Update an extension to a newer version
+     */
+    updateExtensionVersion(tenantId: string, extensionSlug: string, targetVersion: string, updatedBy: string): Promise<AsDomainType<IInstalledExtensionModel>>;
+    /**
+     * Sync installed extensions with registry status
+     */
+    syncWithRegistry(tenantId: string): Promise<void>;
+    /**
+     * Get extensions that need attention
+     */
+    getExtensionsNeedingAttention(tenantId: string): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+    /**
+     * Clean up deprecated or removed extensions based on policies
+     */
+    cleanupExtensions(tenantId: string, dryRun?: boolean): Promise<{
+        removed: string[];
+        deprecated: string[];
+        warnings: string[];
+    }>;
+    /**
+     * Check if update is a security update (simplified logic)
+     */
+    private isSecurityUpdate;
+}
+//# sourceMappingURL=installed-extension-service.d.ts.map

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

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