@kumori/aurora-backend-handler 1.0.0

package/helpers/tenant-helper.ts

@@ -0,0 +1,191 @@
+
+import { Tenant, tenantRole, User, UserData } from "@hestekumori/aurora-interfaces";
+import { parseKeyPath } from "../utils/utils";
+
+export const handleTenantEvent: (
+  entityId: string,
+  eventData: any,
+  userData: UserData,
+) => Tenant = (entityId: string, eventData: any, userData: User) => {
+  const organizationIds = eventData.spec.organization
+    ? Array.isArray(eventData.spec.organization)
+      ? eventData.spec.organization.map((org: any) => org.name).filter(Boolean)
+      : [eventData.spec.organization.name].filter(Boolean)
+    : [];
+  const tenantUsers: { id: string; status: string; role: tenantRole }[] = [];
+  if (eventData.spec.users) {
+    Object.entries(eventData.spec.users).forEach(([userId, userRole]) => {
+      const userStatus = eventData.status?.users?.[userId] || "unknown";
+      let role: tenantRole;
+      switch (userRole as string) {
+        case "owner":
+          role = tenantRole.OWNER;
+          break;
+        case "admin":
+          role = tenantRole.ADMIN;
+          break;
+        case "plain":
+          role = tenantRole.PLAIN;
+          break;
+        default:
+          role = tenantRole.PLAIN;
+      }
+      tenantUsers.push({
+        id: userId,
+        status: userStatus,
+        role: role,
+      });
+    });
+  }
+
+  const newTenant: Tenant = {
+    id: entityId,
+    name: entityId,
+    organizationsIds: organizationIds,
+    services: [],
+    accounts: [],
+    environments: [],
+    marketplaceItems: [],
+    resources: [],
+    role: Object.keys(eventData.spec.users).includes(userData.id)
+      ? eventData.spec.users[userData.id]
+      : "",
+    status: eventData.meta?.deleted ? "deleting" : "",
+    users: tenantUsers,
+    registry: [],
+    created: eventData.meta.created,
+    freemium: eventData.spec.primary === "playground",
+    npmRegistry: {
+      endpoint: "",
+      domain: "",
+      credentials: "",
+      public: false,
+    },
+  };
+
+  if (eventData.spec.plan) {
+    const planParent = eventData.spec.plan.parent
+      ? parseKeyPath(eventData.spec.plan.parent.name)
+      : {};
+    newTenant.plan = {
+      name: eventData.spec.plan.name,
+      provider: planParent.planprovider || "",
+    };
+  }
+
+  const registries = eventData?.spec?.registries?.registries;
+
+  if (
+    registries &&
+    Object.keys(registries).length > 0 &&
+    newTenant.npmRegistry
+  ) {
+    const tenantRegistry = Object.keys(registries)[0];
+    const tenantOptions = registries[tenantRegistry]?.options;
+
+    if (tenantOptions?.endpoint) {
+      newTenant.npmRegistry.endpoint = tenantOptions.endpoint;
+    }
+    if (tenantOptions?.credentials) {
+      newTenant.npmRegistry.credentials = tenantOptions.credentials;
+    }
+    if (typeof tenantOptions?.public === "boolean") {
+      newTenant.npmRegistry.public = tenantOptions.public;
+    }
+    if (
+      eventData?.spec?.domains &&
+      Object.keys(eventData.spec.domains).length > 0
+    ) {
+      newTenant.npmRegistry.domain = Object.keys(eventData.spec.domains)[0];
+    }
+  } else {
+    console.warn(
+      `No se encontró información de registry en eventData para el tenant ${newTenant.name}`,
+    );
+  }
+  return newTenant;
+};
+export const handleTenantOperationSuccess: (
+  entityName: string,
+  eventData: any,
+  userData: UserData,
+) => Tenant = (entityName: string, eventData: any, userData: UserData) => {
+  const tenantUsers: {
+    id: string;
+    status: string;
+    role: tenantRole;
+  }[] = [];
+
+  if (eventData.spec.users) {
+    Object.entries(eventData.spec.users).forEach(([userId, userRole]) => {
+      const userStatus = eventData.status?.users?.[userId] || "unknown";
+      let role: tenantRole;
+      switch (userRole as string) {
+        case "owner":
+          role = tenantRole.OWNER;
+          break;
+        case "admin":
+          role = tenantRole.ADMIN;
+          break;
+        case "plain":
+          role = tenantRole.PLAIN;
+          break;
+        default:
+          role = tenantRole.PLAIN;
+      }
+      tenantUsers.push({
+        id: userId,
+        status: userStatus,
+        role: role,
+      });
+    });
+  }
+  const newTenant: Tenant = {
+    id: entityName,
+    name: entityName,
+    organizationsIds: [],
+    services: [],
+    accounts: [],
+    environments: [],
+    marketplaceItems: [],
+    resources: [],
+    role: Object.keys(eventData.spec.users).includes(userData.id)
+      ? eventData.spec.users[userData.id]
+      : "",
+    status: "active",
+    users: tenantUsers,
+    registry: [],
+    npmRegistry: {
+      endpoint: "",
+      domain: "",
+      credentials: "",
+      public: false,
+    },
+  };
+  const registries = eventData?.spec?.registries?.registries;
+  if (
+    registries &&
+    Object.keys(registries).length > 0 &&
+    newTenant.npmRegistry
+  ) {
+    const tenantRegistry = Object.keys(registries)[0];
+    const tenantOptions = registries[tenantRegistry]?.options;
+
+    if (tenantOptions?.endpoint) {
+      newTenant.npmRegistry.endpoint = tenantOptions.endpoint;
+    }
+    if (tenantOptions?.credentials) {
+      newTenant.npmRegistry.credentials = tenantOptions.credentials;
+    }
+    if (typeof tenantOptions?.public === "boolean") {
+      newTenant.npmRegistry.public = tenantOptions.public;
+    }
+    if (
+      eventData?.spec?.domains &&
+      Object.keys(eventData.spec.domains).length > 0
+    ) {
+      newTenant.npmRegistry.domain = Object.keys(eventData.spec.domains)[0];
+    }
+  }
+  return newTenant;
+};

package/helpers/token-helper.ts

@@ -0,0 +1,107 @@
+import { ClusterToken, Token, UserData } from "@hestekumori/aurora-interfaces";
+
+
+interface HandleTokenEventParams {
+  eventData: any;
+  tokenMap: Map<string, Token>;
+  userData: UserData;
+}
+
+interface HandleTokenEventResult {
+  isUserToken: boolean;
+  isClusterToken: boolean;
+  userToken: Token | null;
+  clusterToken: ClusterToken | null;
+  updatedUserTokens: Token[];
+  tokenId: string;
+}
+
+/**
+ * Handles the "token" event from WebSocket messages
+ * Processes both user tokens and cluster tokens
+ */
+export const handleTokenEvent = ({
+  eventData,
+  tokenMap,
+  userData,
+}: HandleTokenEventParams): HandleTokenEventResult => {
+  const tokenParentKind = eventData.id.parent?.kind;
+  const tokenId = eventData.id.name;
+
+  if (tokenParentKind === "user") {
+    const tokenInMap = tokenMap.get(tokenId);
+    
+    const newUserToken: Token = {
+      name: tokenId,
+      tenant: eventData.meta?.labels?.tenant || eventData.spec?.tenant || "",
+      description: eventData.meta?.description || "",
+      lastUsed: tokenInMap?.lastUsed || "",
+      expiration: eventData.meta?.expiration
+        ? new Date(eventData.meta.expiration * 1000).toISOString()
+        : "",
+      token: tokenInMap?.token || "",
+    };
+    const updatedUserTokens = [...userData.tokens];
+    const existingTokenIndex = updatedUserTokens.findIndex(
+      (t) => t.name === tokenId
+    );
+
+    if (existingTokenIndex !== -1) {
+      updatedUserTokens[existingTokenIndex] = newUserToken;
+    } else {
+      updatedUserTokens.push(newUserToken);
+    }
+
+    return {
+      isUserToken: true,
+      isClusterToken: false,
+      userToken: newUserToken,
+      clusterToken: null,
+      updatedUserTokens,
+      tokenId,
+    };
+  } else {
+    const clusterTokenValue = eventData.spec.jwt;
+    const clusterToken: ClusterToken = {
+      token: clusterTokenValue,
+    };
+
+    return {
+      isUserToken: false,
+      isClusterToken: true,
+      userToken: null,
+      clusterToken,
+      updatedUserTokens: userData.tokens,
+      tokenId: clusterTokenValue,
+    };
+  }
+};
+
+interface HandleTokenOperationSuccessParams {
+  responsePayload: any;
+}
+
+interface HandleTokenOperationSuccessResult {
+  token: Token;
+}
+
+/**
+ * Handles successful token creation operation
+ * Returns the token with full data from the response
+ */
+export const handleTokenOperationSuccess = ({
+  responsePayload,
+}: HandleTokenOperationSuccessParams): HandleTokenOperationSuccessResult => {
+  const tokenWithData: Token = {
+    name: responsePayload.data.jti,
+    tenant: "",
+    description: responsePayload.data.description || "",
+    expiration: "",
+    token: responsePayload.data.token,
+    lastUsed: new Date().toISOString(),
+  };
+
+  return {
+    token: tokenWithData,
+  };
+};

package/helpers/user-helper.ts

@@ -0,0 +1,140 @@
+import { Notification, Plan, Tenant, UserData } from "@hestekumori/aurora-interfaces";
+
+
+
+interface HandleUserEventParams {
+  eventData: any;
+  tenantsMap: Map<string, Tenant>;
+  currentUserData: UserData;
+  currentUserNotifications: Notification[];
+  plansMap: Map<string, Plan>;
+  parseKeyPath: (key: string) => { [entity: string]: string };
+  eventHelper: any;
+}
+
+interface HandleUserEventResult {
+  userData: UserData;
+  tempProviders: Record<string, string>;
+  deletedTenantKeys: string[];
+}
+
+/**
+ * Handles the "user" event from WebSocket messages
+ * Processes user data updates, tenant deletions, and plan assignments
+ */
+export const handleUserEvent = ({
+  eventData,
+  tenantsMap,
+  currentUserData,
+  currentUserNotifications,
+  plansMap,
+  parseKeyPath,
+  eventHelper,
+}: HandleUserEventParams): HandleUserEventResult => {
+  const userId = eventData.id.name;
+  const userTenants = Object.keys(eventData.status.tenants);
+  const deletedTenantKeys: string[] = [];
+  for (const key of tenantsMap.keys()) {
+    if (!userTenants.includes(key)) {
+      const tenantToDelete = tenantsMap.get(key);
+      if (tenantToDelete) {
+        eventHelper.tenant.publish.deleted(tenantToDelete);
+        const tenantDeletedNotification: Notification = {
+          type: "success",
+          subtype: "tenant-deleted",
+          date: Date.now().toString(),
+          callToAction: false,
+          status: "unread",
+          data: {
+            tenant: tenantToDelete.name,
+          },
+        };
+        eventHelper.notification.publish.creation(tenantDeletedNotification);
+        deletedTenantKeys.push(key);
+      }
+    }
+  }
+
+  const existingNotifications =
+    currentUserData.notifications || currentUserNotifications || [];
+  const userPlans: Plan[] = [];
+  if (eventData.spec.plans) {
+    Object.entries(eventData.spec.plans).forEach(
+      ([planPath, role]: [string, any]) => {
+        const planPathParts = parseKeyPath(planPath);
+        const planProvider = planPathParts.planprovider;
+        const planInstance = planPathParts.planinstance;
+        const planKey = `${planProvider}/${planInstance}`;
+        const plan = plansMap.get(planKey);
+        if (plan) {
+          userPlans.push({
+            ...plan,
+          });
+        } else {
+          const basicPlan: Plan = {
+            name: planInstance,
+            provider: planProvider,
+          };
+          userPlans.push(basicPlan);
+        }
+      }
+    );
+  }
+  const tempProviders: Record<string, string> = eventData.spec.providers || {};
+  const providers: { name: string; email: string; password?: string }[] = [];
+
+  const existingProvidersMap = new Map(
+    (currentUserData.provider || []).map((p) => [p.name, p])
+  );
+
+  for (const [providerName, providerId] of Object.entries(tempProviders)) {
+    const existingProvider = existingProvidersMap.get(providerName);
+
+    if (existingProvider && existingProvider.email) {
+      providers.push(existingProvider);
+    } else {
+      providers.push({
+        name: providerName,
+        email: existingProvider?.email || "",
+      });
+    }
+  }
+  const userData: UserData = {
+    id: userId,
+    name: eventData.spec.userinfo.name,
+    surname: eventData.spec.userinfo.surname,
+    provider: providers,
+    notificationsEnabled: "",
+    organizations: [],
+    clusterTokens: [],
+    tokens: [],
+    tenants: [],
+    axebowPlan: "freemium",
+    companyName: eventData.spec.userinfo.companyName,
+    rol: eventData.spec.userinfo.companyRole,
+    notifications: existingNotifications,
+    plans: userPlans,
+  };
+
+  return {
+    userData,
+    tempProviders,
+    deletedTenantKeys,
+  };
+};
+export const handleUserOperationError = (): UserData => {
+    return {
+        id: "",
+        name: "",
+        surname: "",
+        provider: [],
+        notificationsEnabled: "",
+        organizations: [],
+        clusterTokens: [],
+        tokens: [],
+        tenants: [],
+        axebowPlan: "freemium",
+        companyName: "",
+        rol: "",
+    };
+};

package/jest.config.ts

@@ -0,0 +1,40 @@
+import type { Config } from '@jest/types';
+
+const config: Config.InitialOptions = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  setupFiles: ['./jest.setup.js'],
+  extensionsToTreatAsEsm: ['.ts'], 
+  transform: {
+    '^.+\\.[tj]sx?$': [
+      'ts-jest',
+      {
+        useESM: true,
+      },
+    ],
+  },  
+  transformIgnorePatterns: [
+    '/node_modules/(?!@lit|lit|@lit-labs)/',
+  ],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  collectCoverage: true,
+  collectCoverageFrom: [
+    "**/backend-handler.ts",
+    "**/event-helper.ts",
+    "**/event-names.ts",
+    "**/deploy-service-helper.ts"
+  ],
+  coverageReporters: ["html", "text", "text-summary", "cobertura"],
+  testMatch: ["**/*.test.ts"],
+  reporters: [
+    "default",
+    ["jest-junit", {
+      outputDirectory: ".",
+      outputName: "report.xml"
+    }]
+  ],
+};
+
+export default config;

package/jest.setup.js

@@ -0,0 +1,4 @@
+const { Blob } = require('buffer');
+const { FormData } = require('formdata-node');
+globalThis.Blob = Blob;
+globalThis.FormData = FormData;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "scripts": {
+    "test": "jest --config jest.config.ts"
+  },
+  "dependencies": {
+    "@hestekumori/aurora-interfaces": "^1.0.17",
+    "@jest/globals": "^29.7.0",
+    "@kumori/kumori-dsl-generator": "^1.0.3",
+    "@kumori/kumori-module-generator": "^1.1.6",
+    "jest": "^29.7.0",
+    "ts-node": "^10.9.2",
+    "uuid": "^11.1.0",
+    "ws": "^8.18.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/ws": "^8.18.1",
+    "formdata-node": "^6.0.3",
+    "jest-junit": "^16.0.0",
+    "ts-jest": "^29.3.0",
+    "typescript": "~5.6.2",
+    "uuid": "^11.1.0",
+    "ws": "^8.18.2"
+  },
+  "name": "@kumori/aurora-backend-handler",
+  "version": "1.0.0",
+  "description": "backend handler",
+  "main": "backend-handler.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/kumori/axebow/libraries/wui/backend-handler"
+  },
+  "author": "Hugo",
+  "license": "ISC",
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "globals": {
+      "ts-jest": {
+        "useESM": true
+      }
+    },
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    }
+  }
+}