@kumori/aurora-backend-handler 1.0.0

package/api/marketplace-api-service.ts

@@ -0,0 +1,1031 @@
+import { Link, MarketplaceItem, MarketplaceService, Notification, Service } from "@hestekumori/aurora-interfaces";
+import { eventHelper } from "../backend-handler";
+import { environment } from "../environment";
+
+import {
+  getWebSocketStatus,
+  initializeGlobalWebSocketClient,
+  makeGlobalWebSocketRequest,
+} from "../websocket-manager";
+import { deployServiceHelper } from "./deploy-service-helper";
+
+interface DeploymentParameter {
+  name: string;
+  value: string | number | boolean;
+  type: "string" | "number" | "boolean";
+}
+interface DeploymentResourceSpec {
+  name: string;
+  resource: string;
+}
+interface DeploymentVolatileVolumeSpec {
+  name: string;
+  volume: {
+    kind: string;
+    size: number;
+    unit: "G";
+  };
+}
+interface Secret<VARIANT> {
+  secret: VARIANT;
+}
+interface CA<VARIANT> {
+  ca: VARIANT;
+}
+interface Volume<VARIANT> {
+  volume: VARIANT;
+}
+interface Domain<VARIANT> {
+  domain: VARIANT;
+}
+interface Port<VARIANT> {
+  port: VARIANT;
+}
+interface Certificate<VARIANT> {
+  certificate: VARIANT;
+}
+type DeploymentResource =
+  | CA<DeploymentResourceSpec>
+  | Secret<DeploymentResourceSpec>
+  | Volume<DeploymentResourceSpec>
+  | Volume<DeploymentVolatileVolumeSpec>
+  | Domain<DeploymentResourceSpec>
+  | Port<DeploymentResourceSpec>
+  | Certificate<DeploymentResourceSpec>;
+let pendingLinks = new Map<string, Link[]>();
+/**
+ * Function to deploy a marketplace item
+ * @param item A MarketplaceService object containing the item to deploy
+ */
+export const deployMarketplaceItem = async (item: MarketplaceService) => {
+  const complexDeployment = item.deploymentData.serverChannels.find(
+    (channel) => channel.isPublic
+  );
+  if (complexDeployment !== undefined) {
+    try {
+      const formData = await deployServiceHelper(item.deploymentData, item);
+
+      const url = new URL(
+        `${environment.apiServer.baseUrl}/api/${environment.apiServer.apiVersion}/tenant/${item.deploymentData.tenant}/service/${item.deploymentData.name}`
+      );
+      url.searchParams.append("dryrun", "false");
+      url.searchParams.append("accept", "true");
+      url.searchParams.append("wait", "30000");
+      url.searchParams.append("validate", "true");
+      url.searchParams.append("dsl", "true");
+
+      const response = await fetch(url.toString(), {
+        method: "POST",
+        body: formData,
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+
+      const jsonResponse = await response.json();
+
+      const isTimeout = jsonResponse?.events?.some(
+        (event: any) => event.content === "_timeout_"
+      );
+
+      if (isTimeout) {
+        console.error("Timeout en la petición:", {
+          isOk: false,
+          code: "TIMEOUT",
+          error: "_timeout_",
+        });
+      } else {
+        if (item.deploymentData.links.length > 0) {
+          pendingLinks.set(item.deploymentData.name, item.deploymentData.links);
+          linkPendingServices(item.deploymentData, "");
+        }
+      }
+    } catch (err) {
+      console.error("Error en la petición de despliegue de servicio:", err);
+    }
+  } else {
+    const deploymentConfigParameters: DeploymentParameter[] = item.parameterList
+      .filter(
+        (resource) =>
+          resource.type === "string" ||
+          resource.type === "integer" ||
+          resource.type === "number" ||
+          resource.type === "bool" ||
+          resource.type === "boolean" ||
+          resource.type === "fileContent" ||
+          resource.type === "array"
+      )
+      .map((resource) => {
+        if (resource.type === "string") {
+          return {
+            name: resource.name || "",
+            value: (resource as any).value as string,
+            type: "string",
+          };
+        }
+        if (resource.type === "fileContent") {
+          return {
+            name: resource.name || "",
+            value: (resource as any).value as string,
+            type: "string",
+          };
+        }
+        if (resource.type === "bool" || resource.type === "boolean") {
+          return {
+            name: resource.name || "",
+            value:
+              (resource as any).value === "true" ||
+              (resource as any).value === true,
+            type: "boolean",
+          };
+        }
+        if (resource.type === "number" || resource.type === "integer") {
+          return {
+            name: resource.name || "",
+            value: Number((resource as any).value),
+            type: "number",
+          };
+        }
+        if (resource.type === "array") {
+          return {
+            name: resource.name || "",
+            value: (resource as any).value || [],
+            type: "string",
+          };
+        }
+        return {
+          name: resource.name || "",
+          value: (resource as any).value as string,
+          type: "string",
+        };
+      });
+
+    const deploymentData: Service = item.deploymentData as unknown as Service;
+    const url = new URL(
+      `${environment.apiServer.baseUrl}/api/${environment.apiServer.apiVersion}/tenant/${item.deploymentData.tenant}/service/${deploymentData.name}`
+    );
+    url.searchParams.append("dsl", "true");
+    const parametersObj = deploymentConfigParameters.reduce((acc, param) => {
+      const paramMetadata = item.parameterList.find(
+        (p) => p.name === param.name
+      );
+      if (paramMetadata && (paramMetadata as any).parent === "accesspolicies") {
+        if (!acc.accesspolicies) {
+          acc.accesspolicies = {};
+        }
+        acc.accesspolicies[param.name] = param.value;
+      } else {
+        acc[param.name] = param.value;
+      }
+      return acc;
+    }, {} as { [key: string]: any });
+
+    const resourcesObj = item.resourceList.reduce((acc, resource: any) => {
+      if (resource.type === "secret") {
+        acc[resource.name] = {
+          secret: resource.value as string,
+        } as unknown as DeploymentResource;
+      } else if (resource.type === "volume") {
+        acc[resource.name] = {
+          volume: {
+            kind: "storage",
+            type: resource.kind,
+            size: Number(resource.value || 1),
+            unit: "G",
+          },
+        } as unknown as DeploymentResource;
+      } else if (resource.type === "domain") {
+        acc[resource.name] = {
+          domain: resource.value,
+        } as unknown as DeploymentResource;
+      } else if (resource.type === "certificate") {
+        acc[resource.name] = {
+          certificate: resource.value,
+        } as unknown as DeploymentResource;
+      } else if (resource.type === "ca") {
+        acc[resource.name] = {
+          ca: resource.value,
+        } as unknown as DeploymentResource;
+      }
+      else if (resource.type === "port") {
+        acc[resource.name] = {
+          port: resource.value,
+        } as unknown as DeploymentResource;
+      }
+
+      return acc;
+    }, {} as { [key: string]: DeploymentResource });
+
+    const isInbound = item.module === "builtins/inbound";
+
+    if (isInbound) {
+      const hasCertificate = item.resourceList.some(
+        (resource) =>
+          resource.type === "certificate" ||
+          resource.name.toLowerCase().includes("cert") ||
+          resource.name === "servercert"
+      );
+
+      const hasDomain = item.resourceList.some(
+        (resource) =>
+          resource.type === "domain" ||
+          resource.name.toLowerCase().includes("domain") ||
+          resource.name === "serverdomain"
+      );
+      const hasPort = item.resourceList.some(
+        (resource) =>
+          resource.type === "port" ||
+          resource.name.toLowerCase().includes("port")
+      );
+      let correctType = "tcp";
+      let requiredParameters: { [key: string]: any } = {};
+
+      if (hasCertificate && hasDomain) {
+        correctType = "https";
+        requiredParameters = {
+          type: "https",
+          clientcert: false,
+          websocket: false,
+          remoteaddressheader: parametersObj.remoteaddressheader || "",
+          cleanxforwardedfor: false,
+        };
+      } else if (hasPort && !hasDomain && !hasCertificate) {
+        correctType = "tcp";
+        requiredParameters = {
+          type: "tcp",
+        };
+      } else {
+        console.warn(
+          "Inbound configuration doesn't match any valid schema variant:",
+          {
+            hasCertificate,
+            hasDomain,
+            hasPort,
+            resources: item.resourceList.map((r) => ({
+              name: r.name,
+              type: r.type,
+            })),
+          }
+        );
+      }
+      Object.assign(parametersObj, requiredParameters);
+    }
+
+    const serviceName = item.serviceName.startsWith("./")
+      ? item.serviceName.split("./")[1]
+      : item.serviceName.startsWith(".")
+      ? item.serviceName.split(".")[1]
+      : item.serviceName;
+
+    const scale =
+      item.type === "component" || item.serviceName === ""
+        ? { hsize: 1 }
+        : item.schema?.name === "builtins/inbound"
+        ? { detail: {} }
+        : item.type === "service" && item.roles && Array.isArray(item.roles)
+        ? {
+            detail: item.roles.reduce(
+              (acc, role) => ({
+                ...acc,
+                [role]: { hsize: 1 },
+              }),
+              {}
+            ),
+          }
+        : { detail: { [`${item.artifactName}`]: { hsize: 1 } } };
+
+    const scaling: {
+      simple: {
+        [key: string]: {
+          scale_up: { cpu: number; memory: number };
+          scale_down: { cpu: number; memory: number };
+          hysteresis: number;
+          min_replicas: number;
+          max_replicas: number;
+        };
+      };
+    } = {
+      simple: {},
+    };
+
+    scaling.simple[item.serviceName] = {
+      scale_up: {
+        cpu: parseInt(item.scaling?.cpu.up || "") || 0,
+        memory: parseInt(item.scaling?.memory.up || "") || 0,
+      },
+      scale_down: {
+        cpu: parseInt(item.scaling?.cpu.down || "") || 0,
+        memory: parseInt(item.scaling?.memory.down || "") || 0,
+      },
+      hysteresis: parseInt(item.scaling?.histeresys || "") || 0,
+      min_replicas: item.scaling?.instances.min || 0,
+      max_replicas: item.scaling?.instances.max || 0,
+    };
+    const itemBody = {
+      type: "deployment",
+      deployment: {
+        name: deploymentData.name,
+        up: null,
+        meta: {},
+        config: {
+          parameter: parametersObj,
+          resource: resourcesObj,
+          resilience: 0,
+          scale: scale,
+        },
+        artifact: {
+          ref: {
+            version: [
+              Number(item.version.split(".")[0]),
+              Number(item.version.split(".")[1]),
+              Number(item.version.split(".")[2]),
+            ],
+            kind: item.type,
+            domain: item.domain,
+            module: item.module,
+            name: item.artifact,
+            package: serviceName,
+          },
+        },
+      },
+      comment: " ",
+      meta: {
+        targetAccount: deploymentData.account,
+        targetEnvironment: deploymentData.environment,
+        scaling: scaling,
+      },
+    };
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(itemBody),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const jsonResponse = await response.json();
+
+    const isTimeout = jsonResponse?.events?.some(
+      (event: any) => event.content === "_timeout_"
+    );
+
+    if (isTimeout) {
+      console.error("Timeout en la petición:", {
+        isOk: false,
+        code: "TIMEOUT",
+        error: "_timeout_",
+      });
+    }
+
+    if (deploymentData.links && deploymentData.links.length > 0) {
+      pendingLinks.set(deploymentData.name, deploymentData.links);
+
+      try {
+        await linkPendingServices(deploymentData, "");
+      } catch (linkError) {
+        console.error("⭐ Error en linkPendingServices:", linkError);
+      }
+    }
+  }
+};
+
+export const getMarketplaceItems = async (
+  tenants: string[],
+  security: string
+) => {
+  await initializeGlobalWebSocketClient(security);
+  const promises = tenants.map(async (tenant) => {
+    try {
+      const response = await makeGlobalWebSocketRequest(
+        "marketplace:search_marketplace",
+        { tenant },
+        30000,
+        "GET",
+        tenant
+      );
+
+      const tenantItems: MarketplaceItem[] = [];
+
+      const itemPromises = Object.entries(response.data.items).map(
+        async ([key, value]) => {
+          let cpu = 0;
+          let memory = 0;
+
+          (value as any).tags.forEach((tag: string) => {
+            if (tag.includes("cpu")) {
+              cpu = Number(tag.split("::")[1].split("vCPU")[0]);
+            } else if (tag.includes("memory")) {
+              const value = tag.split("::")[1]?.trim();
+              if (value?.includes("GB")) {
+                const memStr = value.split("GB")[0].trim();
+                memory = Number(memStr);
+              } else if (value?.includes("MB")) {
+                const memStr = value.split("MB")[0].trim();
+                memory = Number(memStr) / 1024;
+              }
+            }
+          });
+          const item: MarketplaceItem = {
+            tenant: tenant.toString(),
+            name: (value as any).name,
+            logo: "https://gitlab.com/uploads/-/system/group/avatar/86481133/Axebow-Logo-2.jpeg?width=96",
+            description: (value as any).name,
+            version: (value as any).version,
+            requirements: { cpu, memory },
+            status: "",
+            instances: [],
+            links: [],
+            resources: [],
+            domain: (value as any).domain,
+            type: (value as any).artifactTypes[0],
+            artifact: (value as any).artifact,
+          };
+
+          try {
+            const schemaData = await getMarketplaceSchema(
+              tenant,
+              item,
+              security
+            );
+            item.schema = schemaData;
+          } catch (schemaError) {
+            console.error(
+              `Error cargando schema para ${item.name}:`,
+              schemaError
+            );
+            item.schema = undefined;
+          }
+
+          return item;
+        }
+      );
+
+      const processedItems = await Promise.all(itemPromises);
+      tenantItems.push(...processedItems);
+      return tenantItems;
+    } catch (error) {
+      console.error(`Error al obtener items para el tenant ${tenant}:`, error);
+      return [];
+    }
+  });
+
+  const itemsArrays = await Promise.all(promises);
+  const items = itemsArrays.flat();
+  return { items };
+};
+
+export const getMarketplaceSchema = async (
+  tenant: string,
+  marketplaceItem: MarketplaceItem,
+  security: string
+): Promise<
+  | {
+      resources: {
+        name: string;
+        type: string;
+        required: boolean;
+        protocol?: string;
+        defaultValue?: string;
+      }[];
+      parameters: {
+        name: string;
+        type: string;
+        required: boolean;
+        protocol?: string;
+        pattern?: string;
+        parent?: string;
+        defaultValue?: string | number;
+      }[];
+      channels: {
+        name: string;
+        type: "client" | "server" | "duplex";
+        resource?: { type: "port" | "domain"; value: string };
+        protocol?: string;
+      }[];
+      name?: string;
+      roleName?: string;
+      roles?: string[];
+      hasVariants?: boolean;
+      variants?: any[];
+    }
+  | undefined
+> => {
+  await initializeGlobalWebSocketClient(security);
+  try {
+    const requestPayload = {
+      tenant,
+      module: marketplaceItem.name,
+      version: marketplaceItem.version,
+      domain: marketplaceItem.domain,
+      artifact: marketplaceItem.artifact,
+    };
+
+    const response = await makeGlobalWebSocketRequest(
+      "marketplace:artifact_schema",
+      requestPayload,
+      30000,
+      "GET",
+      tenant
+    );
+
+    const nameKeys = Object.keys(response.data);
+    const schemaData = response.data[nameKeys[0]];
+
+    let roleName = "";
+    let roles: string[] = [];
+    if (nameKeys[0] !== ".") {
+      roles = schemaData.roles || [];
+      roleName = roles.join(", ");
+    }
+
+    const schemas = schemaData.schemas || [];
+    if (schemas.length > 0 && schemas[0].oneOf) {
+      const schemaOptions = schemas[0].oneOf;
+      const processedSchemas: any[] = [];
+
+      for (const schemaRef of schemaOptions) {
+        const refKey = schemaRef.$ref?.replace("#/$defs/", "");
+        const actualSchema = schemas[0].$defs?.[refKey];
+
+        if (actualSchema) {
+          const schemaResult = processSchema(actualSchema, refKey);
+          if (schemaResult) {
+            processedSchemas.push({
+              name: nameKeys[0],
+              roleName,
+              roles,
+              variant: refKey,
+              ...schemaResult,
+            });
+          }
+        }
+      }
+      return {
+        parameters: processedSchemas[0]?.parameters || [],
+        resources: processedSchemas[0]?.resources || [],
+        channels: processedSchemas[0]?.channels || [],
+        name: nameKeys[0],
+        roleName,
+        roles,
+        hasVariants: true,
+        variants: processedSchemas,
+      } as any;
+    }
+
+    const singleSchema = schemas[0];
+    if (singleSchema) {
+      const schemaResult = processSchema(singleSchema, "default");
+      return {
+        parameters: schemaResult?.parameters || [],
+        resources: schemaResult?.resources || [],
+        channels: schemaResult?.channels || [],
+        name: nameKeys[0],
+        roleName,
+        roles,
+        hasVariants: false,
+      } as any;
+    }
+
+    return {
+      parameters: [],
+      resources: [],
+      channels: [],
+      name: nameKeys[0],
+      roleName,
+      roles,
+      hasVariants: false,
+    } as any;
+  } catch (error) {
+    console.error("Error obteniendo el schema del item:", error);
+    throw error;
+  }
+};
+
+function processSchema(schema: any, schemaType: string) {
+  let resources: {
+    name: string;
+    type: string;
+    required: boolean;
+    defaultValue?: string;
+  }[] = [];
+  let parameters: {
+    name: string;
+    type: string;
+    required: boolean;
+    defaultValue?: string | number;
+    pattern?: string;
+    parent?: string;
+  }[] = [];
+  let channels: {
+    name: string;
+    type: "client" | "server" | "duplex";
+    resource?: {
+      type: "port" | "domain";
+      value: string;
+    };
+  }[] = [];
+
+  const configProps = schema.properties?.config?.properties;
+
+  if (configProps) {
+    Object.entries(configProps).forEach(([key, value]) => {
+      const param = value as any;
+      parameters.push({
+        name: key,
+        type: param.type || "string",
+        required: schema.properties?.config?.required?.includes(key) || false,
+        defaultValue:
+          param.default !== undefined
+            ? param.default
+            : param.enum
+            ? param.enum[0]
+            : param.const
+            ? param.const
+            : undefined,
+      });
+    });
+  }
+
+  const resourceProps = schema.properties?.resource;
+  if (resourceProps?.properties) {
+    Object.entries(resourceProps.properties).forEach(([key, value]) => {
+      if (
+        key.toLowerCase() === "data" ||
+        key.toLowerCase() === "jetstreamdata" ||
+        key.toLowerCase() === "shared"
+      ) {
+        resources.push({
+          name: key,
+          type: "volume",
+          required: resourceProps.required?.includes(key) || false,
+          defaultValue: undefined,
+        });
+      } else {
+        const resourceValue = value as any;
+        let resourceType = "";
+        let defaultValue: string | undefined = undefined;
+
+        if (resourceValue.properties?.["$kdsl"]?.const?.NamedType?.Name) {
+          const typeName =
+            resourceValue.properties["$kdsl"].const.NamedType.Name;
+          resourceType = typeName.toLowerCase();
+        } else {
+          resourceType = Object.keys(resourceValue.properties || {})[0];
+        }
+
+        if (resourceValue.properties) {
+          const innerResource =
+            resourceValue.properties[resourceType] ||
+            resourceValue.properties.inner;
+          if (innerResource) {
+            if (innerResource.default !== undefined) {
+              defaultValue = String(innerResource.default);
+            } else if (innerResource.enum && innerResource.enum.length > 0) {
+              defaultValue = String(innerResource.enum[0]);
+            } else if (resourceType === "volume" && innerResource.oneOf) {
+              const firstOption = innerResource.oneOf[0];
+              if (firstOption?.properties?.volume?.properties) {
+                const sizeDefault =
+                  firstOption.properties.volume.properties.size?.default;
+                const unitDefault =
+                  firstOption.properties.volume.properties.unit?.enum?.[0];
+                if (sizeDefault !== undefined && unitDefault) {
+                  defaultValue = `${sizeDefault}${unitDefault}`;
+                }
+              }
+            }
+          }
+        }
+
+        resources.push({
+          name: key,
+          type: resourceType || "string",
+          required: resourceProps.required?.includes(key) || false,
+          defaultValue: defaultValue,
+        });
+      }
+    });
+  }
+
+  const srvProps = schema.properties?.srv?.properties;
+  if (srvProps) {
+    if (srvProps.client?.properties) {
+      Object.entries(srvProps.client.properties).forEach(
+        ([channelName, channelData]) => {
+          const channelInfo = channelData as any;
+          let resource: { type: "port" | "domain"; value: string } | undefined;
+
+          if (channelInfo.properties) {
+            const port =
+              channelInfo.properties.port?.const ||
+              channelInfo.properties.port?.enum?.[0];
+            const protocol =
+              channelInfo.properties.protocol?.const ||
+              channelInfo.properties.protocol?.enum?.[0];
+
+            if (port && protocol) {
+              resource = {
+                type: "port",
+                value: `${protocol}:${port}`,
+              };
+            }
+          }
+
+          channels.push({
+            name: channelName,
+            type: "client",
+            resource,
+          });
+        }
+      );
+    }
+    if (srvProps.server?.properties) {
+      Object.entries(srvProps.server.properties).forEach(
+        ([channelName, channelData]) => {
+          const channelInfo = channelData as any;
+          let resource: { type: "port" | "domain"; value: string } | undefined;
+
+          if (channelInfo.properties) {
+            const port =
+              channelInfo.properties.port?.const ||
+              channelInfo.properties.port?.enum?.[0];
+            const protocol =
+              channelInfo.properties.protocol?.const ||
+              channelInfo.properties.protocol?.enum?.[0];
+
+            if (port && protocol) {
+              resource = {
+                type: "port",
+                value: `${protocol}:${port}`,
+              };
+            }
+          }
+
+          channels.push({
+            name: channelName,
+            type: "server",
+            resource,
+          });
+        }
+      );
+    }
+    if (srvProps.duplex?.properties) {
+      Object.entries(srvProps.duplex.properties).forEach(
+        ([channelName, channelData]) => {
+          const channelInfo = channelData as any;
+          let resource: { type: "port" | "domain"; value: string } | undefined;
+
+          if (channelInfo.properties) {
+            const port =
+              channelInfo.properties.port?.const ||
+              channelInfo.properties.port?.enum?.[0];
+            const protocol =
+              channelInfo.properties.protocol?.const ||
+              channelInfo.properties.protocol?.enum?.[0];
+
+            if (port && protocol) {
+              resource = {
+                type: "port",
+                value: `${protocol}:${port}`,
+              };
+            }
+          }
+
+          channels.push({
+            name: channelName,
+            type: "duplex",
+            resource,
+          });
+        }
+      );
+    }
+  }
+
+  return {
+    parameters,
+    resources,
+    channels,
+  };
+}
+const generateLinkBody = (data: Service, link: Link) => {
+  let linkBody;
+
+  if (link.origin === data.name) {
+    const originInClient = data.clientChannels.find(
+      (channel) =>
+        channel.name === link.originChannel ||
+        channel.from === link.originChannel
+    );
+    const originInServer = data.serverChannels.find(
+      (channel) =>
+        channel.name === link.originChannel ||
+        channel.from === link.originChannel
+    );
+    const originInDuplex = data.duplexChannels.find(
+      (channel) =>
+        channel.name === link.originChannel ||
+        channel.from === link.originChannel
+    );
+
+    if (originInClient) {
+      linkBody = {
+        client_tenant: data.tenant,
+        client_service: data.name,
+        client_channel: link.originChannel,
+        server_tenant: data.tenant,
+        server_service: link.target,
+        server_channel: link.targetChannel,
+      };
+    } else if (originInServer || originInDuplex) {
+      linkBody = {
+        client_tenant: data.tenant,
+        client_service: link.target,
+        client_channel: link.targetChannel,
+        server_tenant: data.tenant,
+        server_service: data.name,
+        server_channel: link.originChannel,
+      };
+    }
+  } else if (link.target === data.name) {
+    const targetInClient = data.clientChannels.find(
+      (channel) =>
+        channel.name === link.targetChannel ||
+        channel.from === link.targetChannel
+    );
+    const targetInServer = data.serverChannels.find(
+      (channel) =>
+        channel.name === link.targetChannel ||
+        channel.from === link.targetChannel
+    );
+    const targetInDuplex = data.duplexChannels.find(
+      (channel) =>
+        channel.name === link.targetChannel ||
+        channel.from === link.targetChannel
+    );
+
+    if (targetInClient) {
+      linkBody = {
+        client_tenant: data.tenant,
+        client_service: data.name,
+        client_channel: link.targetChannel,
+        server_tenant: data.tenant,
+        server_service: link.origin,
+        server_channel: link.originChannel,
+      };
+    } else if (targetInServer || targetInDuplex) {
+      linkBody = {
+        client_tenant: data.tenant,
+        client_service: link.origin,
+        client_channel: link.originChannel,
+        server_tenant: data.tenant,
+        server_service: data.name,
+        server_channel: link.targetChannel,
+      };
+    }
+  } else {
+    console.warn(
+      `Servicio actual no involucrado en el enlace: current=${data.name}, origin=${link.origin}, target=${link.target}`
+    );
+    linkBody = {
+      client_tenant: data.tenant,
+      client_service: link.origin,
+      client_channel: link.originChannel,
+      server_tenant: data.tenant,
+      server_service: link.target,
+      server_channel: link.targetChannel,
+    };
+  }
+  return linkBody;
+};
+const linkPendingServices = async (service: Service, token: string) => {
+  const links = pendingLinks.get(service.name);
+
+  if (links) {
+    await Promise.all(
+      service.links.map(async (link, index) => {
+        try {
+          await initializeGlobalWebSocketClient(token);
+          const status = getWebSocketStatus();
+          const linkBody = generateLinkBody(service, link);
+
+          const linkResponse = await makeGlobalWebSocketRequest(
+            "link:link_service",
+            linkBody,
+            30000,
+            "LINK",
+            service.name
+          );
+
+          const notification: Notification = {
+            type: "success",
+            subtype: "service-linked",
+            date: Date.now().toString(),
+            status: "unread",
+            callToAction: false,
+            data: {
+              service: service.name,
+              tenant: service.tenant,
+            },
+          };
+
+          eventHelper.notification.publish.creation(notification);
+        } catch (linkErr) {
+          const notification: Notification = {
+            type: "error",
+            subtype: "error-service-link",
+            date: Date.now().toString(),
+            info_content: {
+              code: (linkErr as any).error.code,
+              message: (linkErr as any).error.content,
+            },
+            status: "unread",
+            callToAction: false,
+            data: {
+              service: service.name,
+              tenant: service.tenant,
+            },
+          };
+          eventHelper.notification.publish.creation(notification);
+        }
+      })
+    );
+  }
+};
+/**
+ * Function to load marketplace items for a specific tenant
+ * @param tenant Tenant ID
+ * @param security Authorization token
+ */
+export const loadMarketplaceItemsForTenant = async (
+  tenant: string,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+
+    const response = await makeGlobalWebSocketRequest(
+      "marketplace:search_marketplace",
+      { tenant },
+      30000,
+      "GET",
+      tenant
+    );
+    const items = response.data?.items || [];
+    if (!Array.isArray(items) || items.length === 0) {
+      return [];
+    }
+
+    const itemPromises = items.map(async (item: any) => {
+      const marketplaceItem: MarketplaceItem = {
+        tenant: tenant,
+        name: item.module,
+        logo: "https://gitlab.com/uploads/-/system/group/avatar/86481133/Axebow-Logo-2.jpeg?width=96",
+        description: item.description,
+        version: item.version,
+        requirements: {
+          cpu: item.requirements?.cpu || 0,
+          memory: item.requirements?.memory || 0,
+        },
+        status: "",
+        instances: [],
+        links: [],
+        resources: [],
+        domain: item.domain,
+        type: item.artifactTypes?.[0],
+        artifact: item.artifact,
+        package: item.package,
+        categories: item.categories || [],
+      };
+
+      try {
+        const schemaData = await getMarketplaceSchema(
+          tenant,
+          marketplaceItem,
+          security
+        );
+        marketplaceItem.schema = schemaData;
+      } catch (schemaError) {
+        console.error(
+          `Error loading schema for ${marketplaceItem.name}:`,
+          schemaError
+        );
+        marketplaceItem.schema = undefined;
+      }
+
+      return marketplaceItem;
+    });
+
+    return await Promise.all(itemPromises);
+  } catch (error) {
+    console.error(
+      `Error loading marketplace items for tenant ${tenant}:`,
+      error
+    );
+    return [];
+  }
+};