@kumori/aurora-backend-handler 1.0.35 → 1.0.36

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,
@@ -462,132 +462,33 @@ export const handleRevisionEvent = ({
   };
 };
 
-const collectNamedTypes = (schema: any): string[] => {
-  if (!schema || typeof schema !== "object") return [];
-  const names: string[] = [];
-  if (schema.$kdsl?.const?.NamedType?.Name)
-    names.push(schema.$kdsl.const.NamedType.Name as string);
-  if (Array.isArray(schema.oneOf)) {
-    for (const branch of schema.oneOf) names.push(...collectNamedTypes(branch));
-  }
-  return names;
-};
-
-const namedTypeToResourceType = (
-  namedTypes: string[],
-): { type: Resource["type"]; kind?: Resource["kind"] } | null => {
-  for (const name of namedTypes) {
-    switch (name) {
-      case "Secret":
-        return { type: "secret" };
-      case "Domain":
-        return { type: "domain" };
-      case "Port":
-        return { type: "port" };
-      case "Certificate":
-        return { type: "certificate" };
-      case "CA":
-        return { type: "ca" };
-      case "Volatile":
-      case "Ephemeral":
-        return { type: "volume", kind: "volatile" };
-      case "NonReplicated":
-        return { type: "volume", kind: "nonReplicated" };
-      case "Persisted":
-      case "Persistent":
-        return { type: "volume", kind: "persistent" };
-      case "Registered":
-        return { type: "volume" };
-    }
-  }
-  return null;
-};
-
-const extractResourcesFromSchema = (
-  configSchema: any,
-  resourceValues: Record<string, any> = {},
-  tenant = "",
-): Resource[] => {
-  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,
-      };
-      if (kind) resource.kind = kind;
-      return resource;
-    },
-  );
-};
-
-const extractParametersFromSchema = (
-  configSchema: any,
-  parameterValues: Record<string, any> = {},
-): { [key: string]: string }[] => {
-  const schemaConfigProps: Record<string, any> =
-    configSchema?.properties?.config?.properties ?? {};
-
-  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 };
-  });
-};
-
 export const processRevisionData = (
   service: Service,
   revisionData: any,
 ): Service => {
   const { solution } = revisionData;
-  const configSchema = revisionData?.configSchema;
+
+  const config = revisionData?.config?.config || {};
+  const parameters = extractParametersFromConfig(config.parameter || {});
+  const resources = extractResources(config.resource || {});
 
   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 +507,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 +520,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 +532,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 +550,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 +559,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 +583,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 +592,6 @@ export const extractParametersFromConfig = (
       } else {
         value = String(paramValue);
       }
-
       const parameter: { [key: string]: string } = {
         name: paramName,
         value,
@@ -768,7 +661,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 +734,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 +783,114 @@ const extractResourceName = (resourcePath: string): string => {
   }
   return resourcePath;
 };
+
+const collectNamedTypes = (schema: any): string[] => {
+  if (!schema || typeof schema !== "object") return [];
+  const names: string[] = [];
+  if (schema.$kdsl?.const?.NamedType?.Name)
+    names.push(schema.$kdsl.const.NamedType.Name as string);
+  if (Array.isArray(schema.oneOf)) {
+    for (const branch of schema.oneOf) names.push(...collectNamedTypes(branch));
+  }
+  return names;
+};
+
+const namedTypeToResourceKind = (
+  namedTypes: string[],
+): { type: string; kind?: string } => {
+  for (const name of namedTypes) {
+    switch (name) {
+      case "Secret":
+        return { type: "secret" };
+      case "Domain":
+        return { type: "domain" };
+      case "Port":
+        return { type: "port" };
+      case "Certificate":
+        return { type: "certificate" };
+      case "CA":
+        return { type: "ca" };
+      case "Volatile":
+      case "Ephemeral":
+        return { type: "volume", kind: "volatile" };
+      case "NonReplicated":
+        return { type: "volume", kind: "nonReplicated" };
+      case "Persisted":
+      case "Persistent":
+        return { type: "volume", kind: "persistent" };
+      case "Registered":
+        return { type: "volume" };
+    }
+  }
+  return { type: "secret" };
+};
+
+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 ?? {};
+
+  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),
+      };
+      const currentValue = parameterValues[name];
+      if (currentValue !== undefined) entry.defaultValue = currentValue;
+      else if (propSchema?.default !== undefined)
+        entry.defaultValue = propSchema.default;
+      return entry;
+    },
+  );
+
+  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 { parameters, resources };
+};

package/package.json

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