@adminide-stack/marketplace-module-server 12.0.4-alpha.121 → 12.0.4-alpha.124

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

@@ -1 +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,EAO7B,YAAY,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAE1E;;;GAGG;AACH,qBACa,4BAA6B,SAAQ,yBAAyB;IAKnE,SAAS,CAAC,WAAW,EAAE,YAAY;gBAHiB,UAAU,EAAE,6BAA6B,EAC7C,eAAe,EAAE,yBAAyB,EAEhF,WAAW,EAAE,YAAY,EACE,MAAM,EAAE,aAAa,EAC/B,MAAM,EAAE,SAAS,CAAC,OAAO;IAMxD,OAAO,CAAC,mBAAmB;CA0T9B"}
+{"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,EAM7B,YAAY,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AA0D1E;;;GAGG;AACH,qBACa,4BAA6B,SAAQ,yBAAyB;IAKnE,SAAS,CAAC,WAAW,EAAE,YAAY;gBAHiB,UAAU,EAAE,6BAA6B,EAC7C,eAAe,EAAE,yBAAyB,EAEhF,WAAW,EAAE,YAAY,EACE,MAAM,EAAE,aAAa,EAC/B,MAAM,EAAE,SAAS,CAAC,OAAO;IAMxD,OAAO,CAAC,mBAAmB;CA4Z9B"}

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

@@ -1,4 +1,51 @@
-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';/**
+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,SystemContributionExtensionNames,ExtensionServiceAction,MoleculerServiceName}from'common/server';import {InstalledExtensionService}from'./installed-extension-service.js';/**
+ * Convert scope string values from package.json to ConfigurationScope enum numbers
+ * Maps: "application" -> 1, "machine" -> 2, "window" -> 3, "resource" -> 4
+ */
+function convertScopeStringToNumber(scope) {
+  if (typeof scope === 'number') {
+    return scope; // Already a number
+  }
+  if (typeof scope === 'string') {
+    const scopeMap = {
+      application: 1 /* ConfigurationScope.APPLICATION */,
+      machine: 2 /* ConfigurationScope.MACHINE */,
+      window: 3 /* ConfigurationScope.WINDOW */,
+      resource: 4 /* ConfigurationScope.RESOURCE */
+    };
+    const normalizedScope = scope.toLowerCase();
+    if (normalizedScope in scopeMap) {
+      return scopeMap[normalizedScope];
+    }
+    console.warn(`Unknown scope string: "${scope}", defaulting to WINDOW`);
+  }
+  // Default to WINDOW scope if undefined or unknown
+  return 3 /* ConfigurationScope.WINDOW */;
+}
+/**
+ * Recursively process configuration properties to convert scope strings to numbers
+ */
+function processConfigurationProperties(properties) {
+  if (!properties || typeof properties !== 'object') {
+    return properties;
+  }
+  const processedProperties = {
+    ...properties
+  };
+  for (const [key, value] of Object.entries(processedProperties)) {
+    if (value && typeof value === 'object') {
+      const objectValue = value;
+      // If this property has a scope, convert it
+      if ('scope' in objectValue) {
+        objectValue.scope = convertScopeStringToNumber(objectValue.scope);
+      }
+      // Recursively process nested properties
+      processedProperties[key] = processConfigurationProperties(objectValue);
+    }
+  }
+  return processedProperties;
+}
+/**
  * Extended InstalledExtensionService that handles Moleculer event broadcasting
  * Follows the pattern of AccountService/AccountServiceExt
  */
@@ -47,19 +94,17 @@ let InstalledExtensionServiceExt = class InstalledExtensionServiceExt extends In
               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,
-                properties: config.properties || {},
-                type: config.type || ['object'],
-                scope: 'WINDOW',
-                // Default scope
-                extensionInfo: {
-                  id: event.extensionSlug,
-                  displayName: registryExtension.name
-                }
-              }));
+              configurationNodes = configurations.map(config => {
+                // Process properties to convert scope strings to numbers
+                const processedProperties = processConfigurationProperties(config.properties || {});
+                return {
+                  id: `${event.extensionSlug}`,
+                  title: config.title || registryExtension.name,
+                  description: config.description,
+                  properties: processedProperties,
+                  type: config.type || ['object']
+                };
+              });
               // Create configuration defaults
               configurationDefaults = [{
                 source: {
@@ -90,11 +135,10 @@ let InstalledExtensionServiceExt = class InstalledExtensionServiceExt extends In
               default: true,
               // Default to enabled when installed
               description: `Enable/disable ${event.extensionSlug} extension`,
-              scope: 'window'
+              scope: 3 /* ConfigurationScope.WINDOW */
             }
           },
           type: ['object'],
-          scope: 3 /* ConfigurationScope.WINDOW */,
           extensionInfo: {
             id: event.extensionSlug,
             displayName: registryExtension?.name || event.extensionSlug
@@ -125,13 +169,8 @@ let InstalledExtensionServiceExt = class InstalledExtensionServiceExt extends In
           },
           context
         });
-        this.broker.broadcast(ContributionRegistryServiceEvent.ContributionNodeRegistryAdd, {
-          configurationNode,
-          context,
-          timestamp: new Date()
-        }, [MoleculerServiceName.ConfigurationRegistryService
-        // MoleculerServiceName.MailService, // Using MailService instead of NotificationService
-        ]);
+        // STEP 1: MANDATORY - Register extension in system_extension FIRST (REQUIRED FOR ALL EXTENSIONS)
+        console.log('\n🔧 STEP 1: Registering extension in SYSTEM_EXTENSION (MANDATORY)');
         // Create separate configuration node for system extension status
         const systemExtensionNode = {
           schemaId: ConfigurationSchemaId.Configuration,
@@ -146,46 +185,139 @@ let InstalledExtensionServiceExt = class InstalledExtensionServiceExt extends In
           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
-        ]);
+        let systemExtensionRegistered = false;
+        try {
+          console.log('Broadcasting SYSTEM extension registry (MANDATORY)...');
+          await this.broker.call('ConfigurationRegistryService.createConfigurationNodeRegistry', {
+            data: systemExtensionNode,
+            context: systemContext
+          });
+          systemExtensionRegistered = true;
+          console.log('✅ STEP 1 SUCCESS: Extension registered in system_extension');
+        } catch (systemError) {
+          console.error('❌ STEP 1 FAILED: System extension registration failed:', systemError);
+          throw new Error(`Extension installation failed: Could not register in system (${systemError.message})`);
+        }
+        // STEP 2: CONDITIONAL - Create extension configuration ONLY IF CONTRIBUTIONS EXIST
+        let extensionConfigCreated = false;
+        if (configurationNodes.length > 0) {
+          console.log('\n📝 STEP 2: Creating extension configuration (contributions exist)');
+          try {
+            console.log('Broadcasting extension configuration registry...');
+            await this.broker.call('ConfigurationRegistryService.createConfigurationNodeRegistry', {
+              data: configurationNode,
+              context
+            });
+            extensionConfigCreated = true;
+            console.log('✅ STEP 2 SUCCESS: Extension configuration created');
+          } catch (configError) {
+            console.error('❌ STEP 2 FAILED: Extension configuration creation failed:', configError);
+            // This is not fatal since system extension is already registered
+            console.warn('⚠️ Extension is registered in system but configuration creation failed');
+          }
+        } else {
+          console.log('\nℹ️ STEP 2: Skipping extension configuration (no contributions found)');
+        }
+        console.log('\n=== EXTENSION INSTALLATION COMPLETED ===');
+        console.log('System Extension Registered:', systemExtensionRegistered ? '✅' : '❌');
+        console.log('Extension Config Created:', extensionConfigCreated ? '✅' : 'ℹ️ Not needed');
+        console.log('Overall Installation:', systemExtensionRegistered ? '✅ SUCCESS' : '❌ FAILED');
       } catch (error) {
         console.error('Error processing extension installed event:', error);
       }
     });
     // Listen to extension uninstalled events
     this.onExtensionUninstalled.event(async event => {
+      console.log('=== EXTENSION UNINSTALLATION STARTED ===');
+      console.log('Extension slug:', event.extensionSlug);
+      console.log('Tenant:', event.tenantId);
+      let uninstallationSuccessful = false;
+      let extensionConfigRemoved = false;
+      let systemExtensionUpdated = false;
       try {
-        // Remove extension status from configuration registry
+        // STEP 1: Remove the extension's own configuration registry entry (if it exists)
+        console.log('\n🗑️ STEP 1: Removing extension 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]);
+        try {
+          console.log('Removing extension configuration document...');
+          await this.broker.call('ConfigurationRegistryService.removeConfigurationNodeRegistry', {
+            context
+          });
+          extensionConfigRemoved = true;
+          console.log('✅ STEP 1 SUCCESS: Extension configuration removed');
+        } catch (configError) {
+          console.warn('⚠️ STEP 1 WARNING: Extension configuration removal failed (may not exist):', configError);
+          // This is not fatal - extension might not have had configuration
+        }
+        // STEP 2: MANDATORY - Remove extension node from system_extension document
+        console.log('\n🔧 STEP 2: Unregistering extension from SYSTEM_EXTENSION (MANDATORY)');
+        try {
+          // First, get the current system_extension document
+          const systemContext = {
+            schemaId: ConfigurationSchemaId.Configuration,
+            tenantId: event.tenantId,
+            extensionName: SystemContributionExtensionNames.SystemExtension,
+            accountId: event.uninstalledBy
+          };
+          console.log('Fetching current system_extension document...');
+          const currentSystemDoc = await this.broker.call('ConfigurationRegistryService.getConfigurationNodeRegistry', {
+            context: systemContext
+          });
+          if (currentSystemDoc && currentSystemDoc.configurationNodes) {
+            const systemDoc = currentSystemDoc;
+            // Filter out the specific extension's status node
+            const configurationNodes = systemDoc.configurationNodes;
+            const updatedConfigurationNodes = configurationNodes.filter(node => node.id !== `${event.extensionSlug}.status`);
+            console.log('Removing extension status node:', `${event.extensionSlug}.status`);
+            console.log(`Original nodes: ${configurationNodes.length}, After removal: ${updatedConfigurationNodes.length}`);
+            // Update the system_extension document with the filtered nodes
+            const updatedSystemExtensionNode = {
+              schemaId: ConfigurationSchemaId.Configuration,
+              tenantId: event.tenantId,
+              extensionName: SystemContributionExtensionNames.SystemExtension,
+              policyConfigs: systemDoc.policyConfigs || null,
+              configurationNodes: updatedConfigurationNodes,
+              configurationDefaults: systemDoc.configurationDefaults || []
+            };
+            console.log('Updating system_extension document...');
+            await this.broker.call('ConfigurationRegistryService.updateConfigurationNodeRegistry', {
+              data: updatedSystemExtensionNode,
+              context: systemContext
+            });
+            systemExtensionUpdated = true;
+            console.log('✅ STEP 2 SUCCESS: Extension unregistered from system_extension');
+          } else {
+            console.warn('⚠️ STEP 2 WARNING: No system_extension document found or no configuration nodes');
+            systemExtensionUpdated = true; // Consider it successful if document doesn't exist
+          }
+        } catch (systemError) {
+          console.error('❌ STEP 2 FAILED: System extension unregistration failed:', systemError);
+          throw new Error(`Extension uninstallation failed: Could not unregister from system (${systemError.message})`);
+        }
+        // Uninstallation is successful if system extension is updated
+        uninstallationSuccessful = systemExtensionUpdated;
+        console.log('\n=== EXTENSION UNINSTALLATION COMPLETED ===');
+        console.log('Extension Config Removed:', extensionConfigRemoved ? '✅' : 'ℹ️ Not found');
+        console.log('System Extension Updated:', systemExtensionUpdated ? '✅' : '❌');
+        console.log('Overall Uninstallation:', uninstallationSuccessful ? '✅ SUCCESS' : '❌ FAILED');
       } catch (error) {
-        console.error('Error processing extension uninstalled event:', error);
+        console.error('❌ EXTENSION UNINSTALLATION FAILED:', error);
+        console.error('Error details:', {
+          message: error.message,
+          stack: error.stack,
+          extensionSlug: event.extensionSlug,
+          tenantId: event.tenantId,
+          extensionConfigRemoved,
+          systemExtensionUpdated
+        });
+        throw error; // Re-throw to ensure calling code knows uninstallation failed
       }
+      // Notify other services about the uninstallation
       this.broker.broadcast(ExtensionServiceAction.OnExtensionUninstalled, {
         event
       }, [MoleculerServiceName.ConfigurationService, 'WorkbenchService',

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

@@ -1 +1 @@
-{"version":3,"file":"installed-extension-service-ext.js","sources":["../../src/services/installed-extension-service-ext.ts"],"sourcesContent":[null],"names":[],"mappings":"6bAmCG;AACH;;AAG4D;AAWxD,IAAA,4BAA2B,GAAA,MAAA,4BAAA,SAAA,yBAAA,CAAA;AA0T9B,EAAA,WAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"installed-extension-service-ext.js","sources":["../../src/services/installed-extension-service-ext.ts"],"sourcesContent":[null],"names":[],"mappings":"4ZA0FG;AACH;;AAG4D;AAWxD,SAAA,0BAA2B,CAAA,KAAA,EAAA;AA4Z9B,EAAA,IAAA,OAAA,KAAA,KAAA,QAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@adminide-stack/marketplace-module-server",
-    "version": "12.0.4-alpha.121",
+    "version": "12.0.4-alpha.124",
     "description": "Sample core for higher packages to depend on",
     "license": "UNLICENSED",
     "author": "CDMBase LLC",
@@ -21,11 +21,11 @@
         "watch": "yarn build:lib:watch"
     },
     "dependencies": {
-        "@adminide-stack/extension-api": "12.0.4-alpha.121",
+        "@adminide-stack/extension-api": "12.0.4-alpha.124",
         "nanoid": "^5.1.5"
     },
     "devDependencies": {
-        "common": "12.0.4-alpha.121"
+        "common": "12.0.4-alpha.124"
     },
     "peerDependencies": {
         "graphql-tag": ">=2.0.0"
@@ -57,5 +57,5 @@
     "typescript": {
         "definition": "lib/index.d.ts"
     },
-    "gitHead": "01a0259fb2895a796b4609693f11e2e46e291832"
+    "gitHead": "c5b43e0809575b93b7b16a462a7f4cc50e9aab18"
 }