@kumori/aurora-backend-handler 1.0.35 → 1.0.37

package/helpers/revision-helper.ts

@@ -7,8 +7,8 @@ import {
   Service,
   Usage,
 } from "@kumori/aurora-interfaces";
-import { Revision } from "@kumori/aurora-interfaces/interfaces/revision-interface";
 import { convertToGigabytes, getTimestamp } from "../utils/utils";
+import { Revision } from "@kumori/aurora-interfaces/interfaces/revision-interface";
 
 interface Role {
   name: string;
@@ -138,7 +138,7 @@ const processRolesAndInstances = (
           cost: 0,
         },
         logs: [],
-        containers: containers,
+        containers,
       };
 
       roleInstances.push(instance);
@@ -167,7 +167,7 @@ const createRevision = (
 ): Revision => {
   return {
     id: entityId,
-    schema: eventData.spec || {},
+    schema: {},
     usage: {
       current: {
         cpu: usedCpu,
@@ -473,9 +473,9 @@ const collectNamedTypes = (schema: any): string[] => {
   return names;
 };
 
-const namedTypeToResourceType = (
+const namedTypeToResourceKind = (
   namedTypes: string[],
-): { type: Resource["type"]; kind?: Resource["kind"] } | null => {
+): { type: string; kind?: string } => {
   for (const name of namedTypes) {
     switch (name) {
       case "Secret":
@@ -500,94 +500,158 @@ const namedTypeToResourceType = (
         return { type: "volume" };
     }
   }
-  return null;
+  return { type: "secret" };
 };
 
-const extractResourcesFromSchema = (
-  configSchema: any,
-  resourceValues: Record<string, any> = {},
-  tenant = "",
-): Resource[] => {
+export const extractStructuredSchema = (
+  revisionData: any,
+): {
+  parameters: {
+    name: string;
+    type: string;
+    required: boolean;
+    defaultValue?: any;
+  }[];
+  resources: { name: string; type: string; kind?: string; required: boolean }[];
+} => {
+  const configSchema = revisionData?.configSchema;
+  const deploymentName = revisionData?.solution?.top;
+  const deployment = deploymentName
+    ? revisionData?.solution?.deployments?.[deploymentName]
+    : Object.values(revisionData?.solution?.deployments ?? {})[0];
+
+  const parameterValues: Record<string, any> =
+    (deployment as any)?.config?.parameter ?? {};
+  const requiredParams: string[] =
+    configSchema?.properties?.config?.required ?? [];
+  const requiredResources: string[] =
+    configSchema?.properties?.resource?.required ?? [];
+  const schemaConfigProps: Record<string, any> =
+    configSchema?.properties?.config?.properties ?? {};
   const schemaResourceProps: Record<string, any> =
     configSchema?.properties?.resource?.properties ?? {};
 
-  return Object.entries(schemaResourceProps).map(
-    ([resourceName, resourceSchema]) => {
-      const namedTypes = collectNamedTypes(resourceSchema);
-      const resolved = namedTypeToResourceType(namedTypes);
-      const type: Resource["type"] = resolved?.type ?? "secret";
-      const kind = resolved?.kind;
-
-      const rawValue = resourceValues[resourceName];
-      let value = "";
-      if (rawValue) {
-        if (rawValue.secret) value = rawValue.secret;
-        else if (rawValue.domain) value = rawValue.domain;
-        else if (rawValue.port) value = rawValue.port;
-        else if (rawValue.certificate?.cert) value = rawValue.certificate.cert;
-        else if (rawValue.ca) value = rawValue.ca;
-        else if (rawValue.volume) {
-          const v = rawValue.volume;
-          value = v.size !== undefined ? `${v.size}${v.unit ?? ""}` : "";
-        }
-      }
-
-      const resource: Resource = {
-        type,
-        name: resourceName,
-        value,
-        status: "available",
-        tenant,
+  const parameters = Object.entries(schemaConfigProps).map(
+    ([name, propSchema]) => {
+      const entry: {
+        name: string;
+        type: string;
+        required: boolean;
+        defaultValue?: any;
+      } = {
+        name,
+        type: propSchema?.type ?? "string",
+        required: requiredParams.includes(name),
       };
-      if (kind) resource.kind = kind;
-      return resource;
+      const currentValue = parameterValues[name];
+      if (currentValue !== undefined) entry.defaultValue = currentValue;
+      else if (propSchema?.default !== undefined)
+        entry.defaultValue = propSchema.default;
+      return entry;
     },
   );
-};
 
-const extractParametersFromSchema = (
-  configSchema: any,
-  parameterValues: Record<string, any> = {},
-): { [key: string]: string }[] => {
-  const schemaConfigProps: Record<string, any> =
-    configSchema?.properties?.config?.properties ?? {};
+  const resources = Object.entries(schemaResourceProps).map(
+    ([name, propSchema]) => {
+      const namedTypes = collectNamedTypes(propSchema);
+      const resolved = namedTypeToResourceKind(namedTypes);
+      const entry: {
+        name: string;
+        type: string;
+        kind?: string;
+        required: boolean;
+      } = {
+        name,
+        type: resolved.type,
+        required: requiredResources.includes(name),
+      };
+      if (resolved.kind) entry.kind = resolved.kind;
+      return entry;
+    },
+  );
 
-  return Object.entries(schemaConfigProps).map(([paramName, paramSchema]) => {
-    const schemaType: string = paramSchema?.type ?? "string";
-    const rawValue = parameterValues[paramName];
-    const value = rawValue !== undefined ? String(rawValue) : "";
-    return { name: paramName, value, type: schemaType, configKey: paramName };
-  });
+  return { parameters, resources };
 };
 
 export const processRevisionData = (
   service: Service,
   revisionData: any,
+  revisionsMap?: Map<string, Revision>,
+  serviceId?: string,
 ): Service => {
   const { solution } = revisionData;
-  const configSchema = revisionData?.configSchema;
+
+  const config = revisionData?.config?.config || {};
+  const parameters = extractParametersFromConfig(config.parameter || {});
+  const resources = extractResources(config.resource || {});
+
+  if (revisionsMap && serviceId && revisionData.revision) {
+    const revisionId: string = revisionData.revision;
+    const revisionKey = `${serviceId}-${revisionId}`;
+    const schema = extractStructuredSchema(revisionData);
+    const existing = revisionsMap.get(revisionKey);
+    if (existing) {
+      revisionsMap.set(revisionKey, { ...existing, schema });
+    } else {
+      revisionsMap.set(revisionKey, {
+        id: revisionId,
+        schema,
+        usage: {
+          current: {
+            cpu: 0,
+            memory: 0,
+            storage: 0,
+            volatileStorage: 0,
+            nonReplicatedStorage: 0,
+            persistentStorage: 0,
+          },
+          limit: {
+            cpu: { max: revisionData.intensives?.vcpu / 1000 || 0, min: 0 },
+            memory: { max: revisionData.intensives?.ram / 1000 || 0, min: 0 },
+            storage: {
+              max: revisionData.intensives?.shared_disk / 1000 || 0,
+              min: 0,
+            },
+            volatileStorage: {
+              max: revisionData.intensives?.volatile_disk / 1000 || 0,
+              min: 0,
+            },
+            nonReplicatedStorage: {
+              max: revisionData.intensives?.nrpersistent_disk / 1000 || 0,
+              min: 0,
+            },
+            persistentStorage: {
+              max: revisionData.intensives?.persistent_disk / 1000 || 0,
+              min: 0,
+            },
+          },
+          cost: 0,
+        },
+        status: { code: "", message: "", timestamp: "", args: [] },
+        errorCode: "",
+        errorMsg: "",
+        createdAt: "",
+      });
+    }
+  }
 
   const deploymentName = solution.top || service.name;
-  const deployment =
-    solution.deployments[deploymentName] ??
-    solution.deployments[Object.keys(solution.deployments)[0]];
+  const deployment = solution.deployments[deploymentName];
 
   if (!deployment) {
-    return { ...service };
+    const firstDeploymentKey = Object.keys(solution.deployments)[0];
+    if (firstDeploymentKey) {
+      return processDeployment(
+        service,
+        solution.deployments[firstDeploymentKey],
+        revisionData,
+        parameters,
+        resources,
+      );
+    }
+    return { ...service, parameters, resources };
   }
 
-  const deploymentConfig = deployment.config ?? {};
-  const parameterValues = deploymentConfig.parameter ?? {};
-  const resourceValues = deploymentConfig.resource ?? {};
-
-  const parameters = configSchema
-    ? extractParametersFromSchema(configSchema, parameterValues)
-    : extractParametersFromConfig(parameterValues);
-
-  const resources = configSchema
-    ? extractResourcesFromSchema(configSchema, resourceValues, service.tenant)
-    : extractResources(resourceValues);
-
   return processDeployment(
     service,
     deployment,
@@ -606,7 +670,6 @@ export const processDeployment = (
 ): Service => {
   const artifact = deployment.artifact;
   const deploymentConfig = deployment.config || {};
-
   const rolesDefinition = artifact.description?.role || {};
   const hasRoles = Object.keys(rolesDefinition).length > 0;
   let updatedRoles: Role[] = [];
@@ -620,13 +683,11 @@ export const processDeployment = (
           hsize = roleData.config.scale.hsize;
         if (deploymentConfig.scale?.detail?.[roleName]?.hsize !== undefined)
           hsize = deploymentConfig.scale.detail[roleName].hsize;
-
         const hasDuplex =
           roleData.artifact?.description?.srv?.duplex?.length > 0;
         const hasVolumeResource = Object.values(
           roleData.artifact?.description?.config?.resource || {},
         ).some((resourceData: any) => resourceData.volume);
-
         const role: Role = {
           name: roleName,
           instances: existingRole?.instances || [],
@@ -634,17 +695,15 @@ export const processDeployment = (
           description:
             roleData.artifact?.ref?.module || roleData.ref?.module || "",
           resource: resources,
-          parameters: parameters,
-          hsize: hsize,
+          parameters,
+          hsize,
           category: hasDuplex || hasVolumeResource ? "stateful" : "",
         };
-
         if (
           deployment.meta?.scaling &&
           Object.keys(deployment.meta.scaling.simple || {}).length > 0
         )
           role.scalling = processScalingConfig(deployment.meta);
-
         updatedRoles.push(role);
       },
     );
@@ -654,7 +713,6 @@ export const processDeployment = (
       hsize = deploymentConfig.scale.hsize;
     if (deploymentConfig.scale?.detail?.[""]?.hsize !== undefined)
       hsize = deploymentConfig.scale.detail[""].hsize;
-
     updatedRoles = [
       {
         name: service.name,
@@ -664,8 +722,8 @@ export const processDeployment = (
           artifact.ref?.module ||
           (artifact.description?.builtin ? "Builtin Service" : ""),
         resource: resources,
-        parameters: parameters,
-        hsize: hsize,
+        parameters,
+        hsize,
         ...(deployment.meta?.scaling &&
           Object.keys(deployment.meta.scaling.simple || {}).length > 0 && {
             scalling: processScalingConfig(deployment.meta),
@@ -688,7 +746,6 @@ export const extractParametersFromConfig = (
     ([paramName, paramValue]: [string, any]) => {
       let value: string;
       let description: string | undefined;
-
       if (typeof paramValue === "object" && paramValue !== null) {
         if (paramValue.value !== undefined) value = paramValue.value;
         else if (paramValue.default !== undefined)
@@ -698,7 +755,6 @@ export const extractParametersFromConfig = (
       } else {
         value = String(paramValue);
       }
-
       const parameter: { [key: string]: string } = {
         name: paramName,
         value,
@@ -768,7 +824,6 @@ export const extractResourcesFromFilesystem = (
 
 export const extractResources = (resourceConfig: any): Resource[] => {
   const resources: Resource[] = [];
-
   Object.entries(resourceConfig).forEach(
     ([resourceName, resourceData]: [string, any]) => {
       let resource: Resource;
@@ -842,36 +897,29 @@ export const extractResources = (resourceConfig: any): Resource[] => {
         if (resourceData.key) resource.key = resourceData.key;
         if (resourceData.maxItems) resource.maxItems = resourceData.maxItems;
       }
-
       resources.push(resource);
     },
   );
-
   return resources;
 };
 
 const processScalingConfig = (meta: any): any => {
-  if (!meta?.scaling?.simple || Object.keys(meta.scaling.simple).length === 0) {
+  if (!meta?.scaling?.simple || Object.keys(meta.scaling.simple).length === 0)
     return {
       cpu: { up: "80%", down: "20%" },
       memory: { up: "80%", down: "20%" },
       instances: { max: 1, min: 1 },
       histeresys: "5",
     };
-  }
-
   const firstRoleName = Object.keys(meta.scaling.simple)[0];
   const roleScaling = meta.scaling.simple[firstRoleName];
-
-  if (!roleScaling) {
+  if (!roleScaling)
     return {
       cpu: { up: "80%", down: "20%" },
       memory: { up: "80%", down: "20%" },
       instances: { max: 1, min: 1 },
       histeresys: "5",
     };
-  }
-
   return {
     cpu: {
       up: `${roleScaling.scale_up?.cpu || 80}%`,
@@ -898,3 +946,4 @@ const extractResourceName = (resourcePath: string): string => {
   }
   return resourcePath;
 };
+

package/package.json

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

package/websocket-manager.ts

@@ -1218,6 +1218,8 @@ const handleOperationSuccess = (operation: PendingOperation, response: any) => {
             const updatedService = processRevisionData(
               svcSuccessResult.updatedService!,
               svcSuccessResult.revisionData,
+              revisionsMap,
+              svcSuccessResult.serviceId,
             );
 
             if (svcSuccessResult.revisionData.revision_error) {