@kumori/aurora-backend-handler 1.1.24 → 1.1.26

package/event-helper.ts

@@ -406,6 +406,9 @@ export class EventHelper {
         deletionError: this.createEvent<Service>(EventNames.MarketplaceItemDeletionError).publish,
         loadItems: this.createEvent<string[]>(EventNames.LoadMarketplaceItems).publish,
         itemsLoaded: this.createEvent<MarketplaceItem[]>(EventNames.MarketplaceItemsLoaded).publish,
+        loadSchema: this.createEvent<string>(EventNames.LoadMarketplaceSchema).publish,
+        schemaLoaded: this.createEvent<MarketplaceItem>(EventNames.MarketplaceSchemaLoaded).publish,
+        schemaLoadError: this.createEvent<string>(EventNames.MarketplaceSchemaLoadError).publish,
       },
       subscribe: {
         deployItem: this.createEvent<MarketplaceService>(EventNames.DeployMarketplaceItem).subscribe,
@@ -419,6 +422,9 @@ export class EventHelper {
         deletionError: this.createEvent<Service>(EventNames.MarketplaceItemDeletionError).subscribe,
         loadItems: this.createEvent<string[]>(EventNames.LoadMarketplaceItems).subscribe,
         itemsLoaded: this.createEvent<MarketplaceItem[]>(EventNames.MarketplaceItemsLoaded).subscribe,
+        loadSchema: this.createEvent<string>(EventNames.LoadMarketplaceSchema).subscribe,
+        schemaLoaded: this.createEvent<MarketplaceItem>(EventNames.MarketplaceSchemaLoaded).subscribe,
+        schemaLoadError: this.createEvent<string>(EventNames.MarketplaceSchemaLoadError).subscribe,
       },
       unsubscribe: {
         deployItem: this.createEvent<MarketplaceService>(EventNames.DeployMarketplaceItem).unsubscribe,
@@ -432,6 +438,9 @@ export class EventHelper {
         deletionError: this.createEvent<Service>(EventNames.MarketplaceItemDeletionError).unsubscribe,
         loadItems: this.createEvent<string[]>(EventNames.LoadMarketplaceItems).unsubscribe,
         itemsLoaded: this.createEvent<MarketplaceItem[]>(EventNames.MarketplaceItemsLoaded).unsubscribe,
+        loadSchema: this.createEvent<string>(EventNames.LoadMarketplaceSchema).unsubscribe,
+        schemaLoaded: this.createEvent<MarketplaceItem>(EventNames.MarketplaceSchemaLoaded).unsubscribe,
+        schemaLoadError: this.createEvent<string>(EventNames.MarketplaceSchemaLoadError).unsubscribe,
       },
     };
   }

package/event-names.ts

@@ -117,6 +117,9 @@ export enum EventNames {
 	MarketplaceItemDeletionError = "marketplaceItemDeletionError",
 	LoadMarketplaceItems = "loadMarketplaceItems",
 	MarketplaceItemsLoaded = "marketplaceItemsLoaded",
+	LoadMarketplaceSchema = "loadMarketplaceSchema",
+	MarketplaceSchemaLoaded = "marketplaceSchemaLoaded",
+	MarketplaceSchemaLoadError = "marketplaceSchemaLoadError",
 	// * Resource
 	CreateResource = "createResource",
 	ResourceCreated = "resourceCreated",

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.24",
+  "version": "1.1.26",
   "description": "backend handler",
   "main": "backend-handler.ts",
   "scripts": {

package/websocket-manager.ts

@@ -6,6 +6,7 @@ import {
   ClusterToken,
   Environment,
   Instance,
+  MarketplaceItem,
   Notification,
   Organization,
   Plan,
@@ -73,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;
 
@@ -2038,3 +2040,55 @@ const resolveServiceStatus = (service: Service): Service => {
     status: currentRevision.status,
   };
 };
+export const fetchAndStoreMarketplaceSchema = async (
+  item: MarketplaceItem,
+): Promise<void> => {
+  const tenantsWithItem: string[] = [];
+  tenantsMap.forEach((tenantEntry, tenantId) => {
+    const hasItem = (tenantEntry.marketplaceItems || []).some(
+      (i) => i.name === item.name && i.domain === item.domain,
+    );
+    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();
+};