feat: endpoint to get solution group details

Author: azam-ismail

src/checks.ts

@@ -8,6 +8,7 @@ import {
 } from './polkadot/polka';
 import { sleep } from './util/sleep';
 import { getBaseUrls } from './util/base-urls';
+import { saveOperatorAddress } from './util/operator-address-cache';
 
 export const runChecks = async (api: ApiPromise, account: KeyringPair, logger): Promise<void> => {
   const shouldRetryInfinite: boolean = MAIN_CONFIG.RETRY_WORKER_CHECKS;
@@ -54,6 +55,9 @@ export const performInitialChecks = async (
 
   logger.info({ operatorAddress }, 'operator address');
 
+  // Save operator address to local cache
+  saveOperatorAddress(account.address, operatorAddress);
+
   const operatorSubscriptions: string[] = await retryHttpAsyncCall(
     async () => await getOperatorSubscriptions(api, operatorAddress),
   );

src/health/health.ts

@@ -1,4 +1,12 @@
-import { getAllInstalledSolutionsNames, runtimeStarted } from '../node-red/red';
+import {
+  getAllInstalledSolutionsNames,
+  getAllInstalledSolutionsWithGroups,
+  runtimeStarted,
+  type InstalledSolutionDetails,
+} from '../node-red/red';
+import { createKeyringPair } from '../polkadot/account';
+import { MAIN_CONFIG } from '../config';
+import { getCachedOperatorAddress } from '../util/operator-address-cache';
 
 enum HealthStatus {
   OK = 'OK',
@@ -23,6 +31,33 @@ interface NodeRedHealthStatus extends ComponentHealthStatus {
   };
 }
 
+interface SolutionInfo {
+  id: string;
+  name: string;
+  status: string;
+  installed: boolean;
+}
+
+interface SolutionGroupInfo {
+  id: string;
+  name?: string;
+  hasCidAllowList?: boolean;
+  solutions: SolutionInfo[];
+}
+
+interface OperatorInfo {
+  address: string;
+  subscriptions: string[];
+  solutionGroups: SolutionGroupInfo[];
+}
+
+interface SolutionGroupsDetailsStatus {
+  timestamp: string;
+  rpcUrl?: string;
+  workerAddress?: string;
+  operator?: OperatorInfo;
+}
+
 export const isLive = (): ComponentHealthStatus => {
   return {
     status: HealthStatus.OK,
@@ -59,3 +94,111 @@ export const getNodeRedHealth = async (): Promise<NodeRedHealthStatus> => {
     },
   };
 };
+
+const getOperatorInfo = async (timeoutMs: number = 5000): Promise<OperatorInfo | undefined> => {
+  try {
+    const account = createKeyringPair();
+
+    // Get installed solutions with groups from Node-RED (local, fast)
+    let installedSolutionsWithGroups: InstalledSolutionDetails[] = [];
+    try {
+      installedSolutionsWithGroups = await getAllInstalledSolutionsWithGroups();
+    } catch {
+      return undefined;
+    }
+
+    if (installedSolutionsWithGroups.length === 0) {
+      // No installed solutions - still need operator address
+      const operatorAddress = await getCachedOperatorAddress(account.address, timeoutMs);
+
+      if (operatorAddress == null) {
+        return undefined;
+      }
+
+      return {
+        address: operatorAddress,
+        subscriptions: [],
+        solutionGroups: [],
+      };
+    }
+
+    // Extract unique solution group IDs from installed solutions (local data)
+    const uniqueSolutionGroupIds = [
+      ...new Set(installedSolutionsWithGroups.map((s) => s.solutionGroupId)),
+    ];
+
+    // Get operator address (required) - getCachedOperatorAddress handles cache and chain query
+    const operatorAddress = await getCachedOperatorAddress(account.address, timeoutMs);
+
+    if (operatorAddress == null) {
+      return undefined;
+    }
+
+    // Group installed solutions by solutionGroupId (local data)
+    const solutionGroupsMap = new Map<string, InstalledSolutionDetails[]>();
+    for (const solution of installedSolutionsWithGroups) {
+      const group = solutionGroupsMap.get(solution.solutionGroupId) ?? [];
+      group.push(solution);
+      solutionGroupsMap.set(solution.solutionGroupId, group);
+    }
+
+    // Build solution groups from local data
+    const solutionGroups: SolutionGroupInfo[] = Array.from(solutionGroupsMap.entries()).map(
+      ([solutionGroupId, solutions]) => {
+        const solutionInfos: SolutionInfo[] = solutions.map((solution) => {
+          // Extract name from solutionId (format: "name.uuid")
+          // Example: "newTestGPSaaS.1348d595-ccc4-4a38-85ad-f0e31cc7f410" -> "newTestGPSaaS"
+          const name = solution.solutionId.includes('.')
+            ? solution.solutionId.split('.').slice(0, -1).join('.')
+            : solution.solutionId;
+
+          return {
+            id: solution.solutionId,
+            name,
+            status: 'Active', // Assume active if installed
+            installed: true, // All are installed
+          };
+        });
+
+        return {
+          id: solutionGroupId,
+          name: solutionGroupId, // Use groupId as name (we don't have name from chain)
+          solutions: solutionInfos,
+        };
+      },
+    );
+
+    return {
+      address: operatorAddress,
+      subscriptions: uniqueSolutionGroupIds,
+      solutionGroups,
+    };
+  } catch {
+    return undefined;
+  }
+};
+
+export const getSolutionGroupsDetailsStatus = async (): Promise<SolutionGroupsDetailsStatus> => {
+  const timestamp = new Date().toISOString();
+
+  // Gather configuration (non-sensitive)
+  let rpcUrl: string | undefined;
+  let workerAddress: string | undefined;
+  try {
+    const account = createKeyringPair();
+    workerAddress = account.address;
+    rpcUrl = MAIN_CONFIG.PALLET_RPC_URL;
+  } catch {
+    rpcUrl = MAIN_CONFIG.PALLET_RPC_URL;
+  }
+
+  // Get operator information with solution groups
+  const operatorInfo = await getOperatorInfo();
+
+  return {
+    timestamp,
+    rpcUrl,
+    workerAddress,
+    operator: operatorInfo,
+  };
+};

src/node-red/red.ts

@@ -398,6 +398,33 @@ export const getAllInstalledSolutionsNames = async (): Promise<string[]> => {
   return solutionIds.filter((x) => x !== null);
 };
 
+export interface InstalledSolutionDetails {
+  solutionId: string;
+  solutionGroupId: string;
+}
+
+export const getAllInstalledSolutionsWithGroups = async (): Promise<InstalledSolutionDetails[]> => {
+  const tabNodes = await getTabNodes();
+
+  const solutions: Array<InstalledSolutionDetails | null> = await Promise.all(
+    tabNodes.map(async (tabNode: RedNode) => {
+      const solutionId = getNodeEnv(tabNode, 'EWX_SOLUTION_ID', false);
+      const solutionGroupId = getNodeEnv(tabNode, 'EWX_SOLUTION_GROUP_ID', false);
+
+      if (solutionId == null || solutionGroupId == null) {
+        return null;
+      }
+
+      return {
+        solutionId,
+        solutionGroupId,
+      };
+    }),
+  );
+
+  return solutions.filter((x): x is InstalledSolutionDetails => x !== null);
+};
+
 export const getTabNodes = async (): Promise<RedNodes> => {
   const currentFlows: Flows = await getAllFlows();
 

src/routes/health.ts

@@ -1,7 +1,7 @@
 import { MAIN_CONFIG } from '../config';
 import express from 'express';
 import { createLogger } from '../util/logger';
-import { isLive, isReady } from '../health/health';
+import { isLive, isReady, getSolutionGroupsDetailsStatus } from '../health/health';
 import asyncHandler from 'express-async-handler';
 
 export const createHealthRouter = (): express.Router | null => {
@@ -32,5 +32,16 @@ export const createHealthRouter = (): express.Router | null => {
     }),
   );
 
+  healthRouter.get(
+    '/health/status',
+    asyncHandler(async (req, res) => {
+      const result = await getSolutionGroupsDetailsStatus();
+
+      healthLogger.debug(result, 'requested solution groups details status');
+
+      res.json(result);
+    }),
+  );
+
   return healthRouter;
 };

src/util/operator-address-cache.ts

@@ -0,0 +1,62 @@
+import { createLogger } from './logger';
+import { getOperatorAddress, retryHttpAsyncCall } from '../polkadot/polka';
+import { createReadPalletApi } from './pallet-api';
+
+const logger = createLogger('OperatorAddressCache');
+
+// In-memory cache: Map<workerAddress, operatorAddress>
+const operatorAddressCache = new Map<string, string>();
+
+export const saveOperatorAddress = (workerAddress: string, operatorAddress: string): void => {
+  operatorAddressCache.set(workerAddress, operatorAddress);
+};
+
+export const getCachedOperatorAddress = async (
+  workerAddress: string,
+  timeoutMs: number = 5000,
+): Promise<string | null> => {
+  // Return cached value if available
+  const cached = operatorAddressCache.get(workerAddress);
+  if (cached != null) {
+    return cached;
+  }
+
+  // Query chain if not cached
+  try {
+    const apiPromise = retryHttpAsyncCall(async () => await createReadPalletApi());
+    const timeoutPromise = new Promise<never>((_resolve, reject) => {
+      setTimeout(() => {
+        reject(new Error('Operator address fetch timeout'));
+      }, timeoutMs);
+    });
+
+    const api = await Promise.race([apiPromise, timeoutPromise]);
+
+    const operatorAddressPromise = retryHttpAsyncCall(
+      async () => await getOperatorAddress(api, workerAddress),
+    );
+    const operatorAddress = await Promise.race([operatorAddressPromise, timeoutPromise]).catch(
+      () => null,
+    );
+
+    await api.disconnect().catch(() => {
+      // Ignore disconnect errors
+    });
+
+    if (operatorAddress != null) {
+      // Cache the result
+      operatorAddressCache.set(workerAddress, operatorAddress);
+      return operatorAddress;
+    }
+
+    logger.warn({ workerAddress }, 'no operator assigned to worker');
+    return null;
+  } catch (error) {
+    logger.warn({ error, workerAddress }, 'failed to get operator address from chain');
+    return null;
+  }
+};
+
+export const clearOperatorAddress = (workerAddress: string): void => {
+  operatorAddressCache.delete(workerAddress);
+};