@pagerduty/backstage-plugin-backend 0.10.3 → 0.12.0

package/dist/service/router.cjs.js

@@ -2,10 +2,14 @@
 
 var backendCommon = require('@backstage/backend-common');
 var pagerduty = require('../apis/pagerduty.cjs.js');
+var dataLoader = require('../services/dataLoader.cjs.js');
+var matchingEngine = require('../services/matchingEngine.cjs.js');
 var backstagePluginCommon = require('@pagerduty/backstage-plugin-common');
 var auth = require('../auth/auth.cjs.js');
 var express = require('express');
 var Router = require('express-promise-router');
+var mappingsController = require('../controllers/mappings-controller.cjs.js');
+var catalogEntity = require('../utils/catalog-entity.cjs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -30,36 +34,6 @@ function _interopNamespaceCompat(e) {
 var express__namespace = /*#__PURE__*/_interopNamespaceCompat(express);
 var Router__default = /*#__PURE__*/_interopDefaultCompat(Router);
 
-async function createComponentEntitiesReferenceDict({
-  items: componentEntities
-}) {
-  const componentEntitiesDict = {};
-  await Promise.all(
-    componentEntities.map(async (entity) => {
-      const serviceId = entity.metadata.annotations?.["pagerduty.com/service-id"];
-      const integrationKey = entity.metadata.annotations?.["pagerduty.com/integration-key"];
-      const account = entity.metadata.annotations?.["pagerduty.com/account"];
-      if (serviceId !== void 0 && serviceId !== "") {
-        componentEntitiesDict[serviceId] = {
-          ref: `${entity.kind}:${entity.metadata.namespace}/${entity.metadata.name}`.toLowerCase(),
-          name: entity.metadata.name
-        };
-      } else if (integrationKey !== void 0 && integrationKey !== "") {
-        const service = await pagerduty.getServiceByIntegrationKey(
-          integrationKey,
-          account
-        ).catch(() => void 0);
-        if (service !== void 0) {
-          componentEntitiesDict[service.id] = {
-            ref: `${entity.kind}:${entity.metadata.namespace}/${entity.metadata.name}`.toLowerCase(),
-            name: entity.metadata.name
-          };
-        }
-      }
-    })
-  );
-  return componentEntitiesDict;
-}
 async function buildEntityMappingsResponse(entityMappings, componentEntitiesDict, componentEntities, pagerDutyServices) {
   const result = {
     mappings: []
@@ -183,6 +157,9 @@ async function createRouter(options) {
   if (!auth$1) {
     auth$1 = backendCommon.createLegacyAuthAdapters(options).auth;
   }
+  if (!catalogApi) {
+    throw new Error("Catalog API is required to start the PagerDuty plugin backend");
+  }
   await auth.loadAuthConfig(config, logger);
   pagerduty.loadPagerDutyEndpointsFromConfig(config, logger);
   const router = Router__default.default();
@@ -437,6 +414,128 @@ async function createRouter(options) {
         response.status(error.status).json({
           errors: [`${error.message}`]
         });
+      } else {
+        logger.error(
+          `Unexpected error occurred while processing request: ${error}`
+        );
+        response.status(500).json({
+          errors: [error instanceof Error ? error.message : String(error)]
+        });
+      }
+    }
+  });
+  router.post("/mapping/entities/bulk", async (request, response) => {
+    try {
+      const { mappings } = request.body;
+      if (!Array.isArray(mappings)) {
+        response.status(400).json({
+          error: "Bad Request: 'mappings' must be an array"
+        });
+        return;
+      }
+      const existingMappings = await store.getAllEntityMappings();
+      const existingServiceIds = new Set(
+        existingMappings.map((m) => m.serviceId)
+      );
+      const newMappings = [];
+      const skipped = [];
+      const errors = [];
+      for (const entity of mappings) {
+        if (!entity.serviceId) {
+          errors.push({
+            entityRef: entity.entityRef,
+            error: "Missing serviceId"
+          });
+          continue;
+        }
+        if (existingServiceIds.has(entity.serviceId)) {
+          skipped.push(entity);
+          continue;
+        }
+        if (entity.entityRef !== "" && (entity.integrationKey === "" || entity.integrationKey === void 0)) {
+          try {
+            const backstageVendorId = "PRO19CT";
+            const service = await pagerduty.getServiceById(
+              entity.serviceId,
+              entity.account
+            );
+            const backstageIntegration = service.integrations?.find(
+              (integration) => integration.vendor?.id === backstageVendorId
+            );
+            if (!backstageIntegration) {
+              const integrationKey = await pagerduty.createServiceIntegration({
+                serviceId: entity.serviceId,
+                vendorId: backstageVendorId,
+                account: entity.account
+              });
+              entity.integrationKey = integrationKey;
+            } else {
+              entity.integrationKey = backstageIntegration.integration_key;
+            }
+          } catch (error) {
+            errors.push({
+              entityRef: entity.entityRef,
+              serviceId: entity.serviceId,
+              error: error instanceof Error ? `Failed to create integration: ${error.message}` : "Failed to create integration"
+            });
+            continue;
+          }
+        }
+        newMappings.push(entity);
+      }
+      let insertedIds = [];
+      if (newMappings.length > 0) {
+        try {
+          insertedIds = await store.bulkInsertEntityMappings(newMappings);
+          await Promise.all(
+            newMappings.map(async (entity) => {
+              if (entity.entityRef !== "") {
+                await catalogApi?.refreshEntity(entity.entityRef);
+              }
+            })
+          );
+        } catch (error) {
+          logger.error(`Bulk insert failed: ${error}`);
+          response.status(500).json({
+            errors: ["Bulk insert failed"]
+          });
+          return;
+        }
+      }
+      const results = newMappings.map((entity, index) => ({
+        id: insertedIds[index],
+        entityRef: entity.entityRef,
+        integrationKey: entity.integrationKey,
+        serviceId: entity.serviceId,
+        status: entity.status,
+        account: entity.account
+      }));
+      response.json({
+        success: results,
+        skipped: skipped.map((entity) => ({
+          entityRef: entity.entityRef,
+          serviceId: entity.serviceId,
+          reason: "Mapping already exists for this service ID"
+        })),
+        errors,
+        total: mappings.length,
+        successCount: results.length,
+        skippedCount: skipped.length,
+        errorCount: errors.length
+      });
+    } catch (error) {
+      if (error instanceof backstagePluginCommon.HttpError) {
+        logger.error(
+          `Error occurred while processing bulk mappings: ${error.message}`
+        );
+        response.status(error.status).json({
+          errors: [`${error.message}`]
+        });
+      } else {
+        logger.error(`Unexpected error: ${error}`);
+        response.status(500).json({
+          errors: ["Internal server error"]
+        });
       }
     }
   });
@@ -448,7 +547,7 @@ async function createRouter(options) {
           kind: "Component"
         }
       });
-      const componentEntitiesDict = await createComponentEntitiesReferenceDict(componentEntities);
+      const componentEntitiesDict = await catalogEntity.createComponentEntitiesReferenceDict(componentEntities);
       const pagerDutyServices = await pagerduty.getAllServices();
       const result = await buildEntityMappingsResponse(
         entityMappings,
@@ -465,6 +564,7 @@ async function createRouter(options) {
       }
     }
   });
+  router.post("/mapping/entities", mappingsController.getMappingEntities(store, catalogApi));
   router.get(
     "/mapping/entity/:type/:namespace/:name",
     async (request, response) => {
@@ -524,6 +624,94 @@ async function createRouter(options) {
       }
     }
   );
+  router.post("/mapping/entity/auto-match", async (request, response) => {
+    try {
+      const threshold = request.body.threshold ?? 100;
+      const account = request.body.account;
+      if (typeof threshold !== "number" || threshold < 0 || threshold > 100) {
+        response.status(400).json({
+          error: "Invalid threshold. Must be a number between 0 and 100."
+        });
+        return;
+      }
+      const bestOnly = request.body.bestOnly ?? false;
+      const loadStartTime = Date.now();
+      const { pdServices, bsComponents } = await dataLoader.loadBothSources({
+        catalogApi
+      });
+      const filteredPdServices = account ? pdServices.filter((service) => service.account === account) : pdServices;
+      const loadTime = Date.now() - loadStartTime;
+      const matchStartTime = Date.now();
+      const matchingConfig = { threshold };
+      let matches = matchingEngine.findMatches(filteredPdServices, bsComponents, matchingConfig);
+      if (bestOnly) {
+        matches = matchingEngine.filterToBestMatchPerService(matches);
+      }
+      const matchTime = Date.now() - matchStartTime;
+      const totalComparisons = filteredPdServices.length * bsComponents.length;
+      const exactMatches = matches.filter((m) => m.score === 100).length;
+      const highConfidence = matches.filter(
+        (m) => m.score >= 90 && m.score < 100
+      ).length;
+      const mediumConfidence = matches.filter(
+        (m) => m.score >= 80 && m.score < 90
+      ).length;
+      const getConfidenceLevel = (score) => {
+        if (score === 100) return "exact";
+        if (score >= 90) return "high";
+        if (score >= 80) return "medium";
+        return "low";
+      };
+      response.json({
+        matches: matches.map((m) => ({
+          pagerDutyService: {
+            serviceId: m.pagerDutyService.sourceId,
+            name: m.pagerDutyService.rawName,
+            team: m.pagerDutyService.teamName,
+            account: m.pagerDutyService.account
+          },
+          backstageComponent: {
+            entityRef: m.backstageComponent.sourceId,
+            name: m.backstageComponent.rawName,
+            owner: m.backstageComponent.teamName
+          },
+          score: m.score,
+          confidence: getConfidenceLevel(m.score),
+          scoreBreakdown: m.scoreBreakdown
+        })),
+        statistics: {
+          totalPagerDutyServices: filteredPdServices.length,
+          totalBackstageComponents: bsComponents.length,
+          totalPossibleComparisons: totalComparisons,
+          matchesFound: matches.length,
+          exactMatches,
+          highConfidenceMatches: highConfidence,
+          mediumConfidenceMatches: mediumConfidence,
+          threshold,
+          loadTimeMs: loadTime,
+          matchTimeMs: matchTime,
+          totalTimeMs: loadTime + matchTime
+        }
+      });
+    } catch (error) {
+      logger.error(`Auto-match failed: ${error}`);
+      if (error instanceof backstagePluginCommon.HttpError) {
+        response.status(error.status).json({
+          errors: [`${error.message}`]
+        });
+      } else if (error instanceof dataLoader.ServiceLoadError) {
+        response.status(503).json({
+          error: "Service temporarily unavailable",
+          message: error.message
+        });
+      } else {
+        response.status(500).json({
+          error: "Auto-match failed",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  });
   router.get("/escalation_policies", async (_, response) => {
     try {
       let escalationPolicyList = await pagerduty.getAllEscalationPolicies();
@@ -598,31 +786,65 @@ async function createRouter(options) {
       }
     }
   });
+  router.get("/teams", async (request, response) => {
+    try {
+      const account = request.query.account;
+      const teams = await pagerduty.getAllTeams(account);
+      response.json(teams);
+    } catch (error) {
+      if (error instanceof backstagePluginCommon.HttpError) {
+        response.status(error.status).json({
+          errors: [`${error.message}`]
+        });
+      }
+    }
+  });
   router.get("/services", async (request, response) => {
     try {
-      const integrationKey = request.query.integration_key || "";
-      const account = request.query.account || "";
-      if (integrationKey !== "") {
+      const integrationKey = request.query.integration_key;
+      const teamId = request.query.team_id;
+      const query = request.query.query;
+      const limit = request.query.limit ? parseInt(request.query.limit, 10) : void 0;
+      const account = request.query.account;
+      if (integrationKey) {
         const service = await pagerduty.getServiceByIntegrationKey(
           integrationKey,
-          account
+          account || ""
         );
         const serviceResponse = {
           service
         };
         response.json(serviceResponse);
-      } else {
-        const services = await pagerduty.getAllServices();
-        const servicesResponse = {
-          services
-        };
-        response.json(servicesResponse);
+        return;
       }
+      if (teamId || query || limit) {
+        const teamIdsArray = teamId ? [teamId] : void 0;
+        const services2 = await pagerduty.getFilteredServices(
+          teamIdsArray,
+          query,
+          limit || 100,
+          account
+        );
+        response.json(services2);
+        return;
+      }
+      const services = await pagerduty.getAllServices();
+      const servicesResponse = {
+        services
+      };
+      response.json(servicesResponse);
     } catch (error) {
       if (error instanceof backstagePluginCommon.HttpError) {
         response.status(error.status).json({
           errors: [`${error.message}`]
         });
+      } else {
+        logger.error(
+          `Unexpected error occurred while processing request: ${error}`
+        );
+        response.status(500).json({
+          errors: [error instanceof Error ? error.message : String(error)]
+        });
       }
     }
   });
@@ -728,6 +950,23 @@ async function createRouter(options) {
       }
     }
   });
+  router.get("/accounts", async (_, response) => {
+    try {
+      const accountsConfig = config.getOptional("pagerDuty.accounts");
+      if (accountsConfig && accountsConfig.length > 0) {
+        const accounts = accountsConfig.map((account) => ({
+          id: account.id,
+          isDefault: account.isDefault || false
+        }));
+        response.status(200).json({ accounts });
+      } else {
+        response.status(200).json({ accounts: [] });
+      }
+    } catch (error) {
+      logger.error(`Failed to get accounts: ${error}`);
+      response.status(500).json({ error: "Failed to get accounts" });
+    }
+  });
   router.get("/health", async (_, response) => {
     response.status(200).json({ status: "ok" });
   });
@@ -736,6 +975,5 @@ async function createRouter(options) {
 }
 
 exports.buildEntityMappingsResponse = buildEntityMappingsResponse;
-exports.createComponentEntitiesReferenceDict = createComponentEntitiesReferenceDict;
 exports.createRouter = createRouter;
 //# sourceMappingURL=router.cjs.js.map