@kumori/aurora-backend-handler 1.1.25 → 1.1.26

package/backend-handler.ts

@@ -54,8 +54,8 @@ import {
 import EventHelper, { RegistryUpdatePayload } from "./event-helper";
 import { environment } from "./environment";
 import {
+  fetchAndStoreMarketplaceSchema,
   initializeGlobalWebSocketClient,
-  loadMarketplaceItemSchema,
   updateUserComplete,
 } from "./websocket-manager";
 import {
@@ -1016,19 +1016,15 @@ export class BackendHandler {
       eventHelper.marketplace.unsubscribe.loadItems(loadItemsCb),
     );
     const loadSchemaCb = async (payload: string) => {
-      try {
-        const { tenant, item } = JSON.parse(payload) as {
-          tenant: string;
-          item: MarketplaceItem;
-        };
-        const schema = await getMarketplaceSchema(tenant, item, token);
-        await loadMarketplaceItemSchema(item, schema);
-        eventHelper.marketplace.publish.schemaLoaded(item);
-      } catch (error) {
-        console.error(`Error loading schema for marketplace item:`, error);
-        eventHelper.marketplace.publish.schemaLoadError(payload);
-      }
-    };
+  try {
+    const { item } = JSON.parse(payload) as { item: MarketplaceItem };
+    await fetchAndStoreMarketplaceSchema(item);
+    eventHelper.marketplace.publish.schemaLoaded(item);
+  } catch (error) {
+    console.error(`Error loading schema for marketplace item:`, error);
+    eventHelper.marketplace.publish.schemaLoadError(payload);
+  }
+};
 
     eventHelper.marketplace.subscribe.loadSchema(loadSchemaCb);
     this.unsubscribeFunctions.push(() =>

package/helpers/marketplace-helper.ts

@@ -0,0 +1,109 @@
+export const processMarketplaceSchemaResponse = (rawEntry: any, nameKey: string) => {
+  const roles: string[] = rawEntry.roles || [];
+  const roleName = roles.join(", ");
+  const schemas = rawEntry.schemas || [];
+
+  const processSchema = (schema: any) => {
+    const parameters: any[] = [];
+    const resources: any[] = [];
+    const channels: any[] = [];
+
+    const configProps = schema.properties?.config?.properties;
+    if (configProps) {
+      Object.entries(configProps).forEach(([key, value]: [string, any]) => {
+        parameters.push({
+          name: key,
+          type: value.type || "string",
+          required: schema.properties?.config?.required?.includes(key) || false,
+          defaultValue: value.default ?? value.enum?.[0] ?? value.const ?? undefined,
+        });
+      });
+    }
+
+    const volumeTypes = ["Registered", "NonReplicated", "Persisted", "Volatile", "Ephemeral", "Persistent"];
+    const isVolumeResource = (v: any): boolean => {
+      if (!v.oneOf) return false;
+      return v.oneOf.some((o: any) => {
+        if (o.oneOf) return o.oneOf.some((n: any) => volumeTypes.includes(n?.properties?.$kdsl?.const?.NamedType?.Name));
+        return volumeTypes.includes(o?.properties?.$kdsl?.const?.NamedType?.Name);
+      });
+    };
+
+    const resourceProps = schema.properties?.resource;
+    if (resourceProps?.properties) {
+      Object.entries(resourceProps.properties).forEach(([key, value]: [string, any]) => {
+        if (isVolumeResource(value)) {
+          resources.push({
+            name: key,
+            type: "volume",
+            required: resourceProps.required?.includes(key) || false,
+          });
+        } else {
+          const typeName = value.properties?.["$kdsl"]?.const?.NamedType?.Name;
+          const resourceType = typeName ? typeName.toLowerCase() : Object.keys(value.properties || {})[0];
+          const inner = value.properties?.[resourceType] || value.properties?.inner;
+          const defaultValue =
+            inner?.default !== undefined
+              ? String(inner.default)
+              : inner?.enum?.[0]
+                ? String(inner.enum[0])
+                : undefined;
+          resources.push({
+            name: key,
+            type: resourceType || "string",
+            required: resourceProps.required?.includes(key) || false,
+            defaultValue,
+          });
+        }
+      });
+    }
+
+    const srvProps = schema.properties?.srv?.properties;
+    if (srvProps) {
+      (["client", "server", "duplex"] as const).forEach((channelType) => {
+        if (srvProps[channelType]?.properties) {
+          Object.entries(srvProps[channelType].properties).forEach(([channelName, channelData]: [string, any]) => {
+            const port = channelData.properties?.port?.const || channelData.properties?.port?.enum?.[0];
+            const protocol = channelData.properties?.protocol?.const || channelData.properties?.protocol?.enum?.[0];
+            channels.push({
+              name: channelName,
+              type: channelType,
+              resource: port && protocol ? { type: "port", value: `${protocol}:${port}` } : undefined,
+            });
+          });
+        }
+      });
+    }
+
+    return { parameters, resources, channels };
+  };
+
+  if (schemas.length > 0 && schemas[0].oneOf) {
+    const processedVariants: any[] = [];
+    for (const schemaRef of schemas[0].oneOf) {
+      const refKey = schemaRef.$ref?.replace("#/$defs/", "");
+      const actualSchema = schemas[0].$defs?.[refKey];
+      if (actualSchema) {
+        const result = processSchema(actualSchema);
+        processedVariants.push({ name: nameKey, roleName, roles, variant: refKey, ...result });
+      }
+    }
+    return {
+      parameters: processedVariants[0]?.parameters || [],
+      resources: processedVariants[0]?.resources || [],
+      channels: processedVariants[0]?.channels || [],
+      name: nameKey,
+      roleName,
+      roles,
+      hasVariants: true,
+      variants: processedVariants,
+    };
+  }
+
+  if (schemas[0]) {
+    const result = processSchema(schemas[0]);
+    return { ...result, name: nameKey, roleName, roles, hasVariants: false };
+  }
+
+  return { parameters: [], resources: [], channels: [], name: nameKey, roleName, roles, hasVariants: false };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kumori/aurora-backend-handler",
-  "version": "1.1.25",
+  "version": "1.1.26",
   "description": "backend handler",
   "main": "backend-handler.ts",
   "scripts": {

package/websocket-manager.ts

@@ -74,6 +74,7 @@ import { handleLinkEvent } from "./helpers/link-helper";
 import { eventHelper } from "./backend-handler";
 import { Revision } from "@kumori/aurora-interfaces/interfaces/revision-interface";
 import { requestRevisionData } from "./api/service-api-service";
+import { processMarketplaceSchemaResponse } from "./helpers/marketplace-helper";
 
 let WebSocketClass: any;
 
@@ -2039,19 +2040,55 @@ const resolveServiceStatus = (service: Service): Service => {
     status: currentRevision.status,
   };
 };
-export const loadMarketplaceItemSchema = async (
+export const fetchAndStoreMarketplaceSchema = async (
   item: MarketplaceItem,
-  schema: any,
 ): Promise<void> => {
-  const tenant = tenantsMap.get(item.tenant);
-  if (tenant) {
-    tenant.marketplaceItems = (tenant.marketplaceItems || []).map((i) =>
-      i.name === item.name && i.domain === item.domain
-        ? { ...i, schema }
-        : i,
+  const tenantsWithItem: string[] = [];
+  tenantsMap.forEach((tenantEntry, tenantId) => {
+    const hasItem = (tenantEntry.marketplaceItems || []).some(
+      (i) => i.name === item.name && i.domain === item.domain,
     );
-    tenantsMap.set(item.tenant, tenant);
-  }
+    if (hasItem) tenantsWithItem.push(tenantId);
+  });
+
+  if (tenantsWithItem.length === 0) return;
+
+  await Promise.all(
+    tenantsWithItem.map(async (tenantId) => {
+      try {
+        const response = await makeGlobalWebSocketRequest(
+          "marketplace:artifact_schema",
+          {
+            tenant: tenantId,
+            module: item.name,
+            version: item.version,
+            domain: item.domain,
+            artifact: item.artifact,
+          },
+          30000,
+          "GET",
+          tenantId,
+        );
+
+        const data = response?.data;
+        if (!data) return;
+
+        const nameKeys = Object.keys(data);
+        const schema = processMarketplaceSchemaResponse(data[nameKeys[0]], nameKeys[0]);
+
+        const tenantEntry = tenantsMap.get(tenantId);
+        if (tenantEntry) {
+          tenantEntry.marketplaceItems = tenantEntry.marketplaceItems.map((i) =>
+            i.name === item.name && i.domain === item.domain ? { ...i, schema } : i,
+          );
+          tenantsMap.set(tenantId, tenantEntry);
+        }
+      } catch (error) {
+        console.error(`Error loading schema for tenant ${tenantId}:`, error);
+      }
+    }),
+  );
+
   rebuildHierarchy();
   await updateUserWithPlatformInfo();
-};
+};