@pagerduty/backstage-plugin-backend 0.11.0 → 0.13.0

package/dist/service/router.cjs.js

@@ -1,13 +1,15 @@
 'use strict';
 
-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 autoMatchRunner = require('../services/autoMatchRunner.cjs.js');
+var autoMatchJobs = require('../services/autoMatchJobs.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');
+var rootHttpRouter = require('@backstage/backend-defaults/rootHttpRouter');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -32,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: []
@@ -180,15 +152,19 @@ async function buildEntityMappingsResponse(entityMappings, componentEntitiesDict
   return result;
 }
 async function createRouter(options) {
-  const { logger, config, store, catalogApi } = options;
-  let { auth: auth$1 } = options;
-  if (!auth$1) {
-    auth$1 = backendCommon.createLegacyAuthAdapters(options).auth;
+  const { logger, config, store, catalogApi, cache } = options;
+  if (!catalogApi) {
+    throw new Error("Catalog API is required to start the PagerDuty plugin backend");
+  }
+  if (!cache) {
+    throw new Error("Cache service is required to start the PagerDuty plugin backend");
   }
   await auth.loadAuthConfig(config, logger);
   pagerduty.loadPagerDutyEndpointsFromConfig(config, logger);
   const router = Router__default.default();
   router.use(express__namespace.json());
+  const runAutoMatch = autoMatchRunner.createAutoMatchRunner(catalogApi);
+  const autoMatchJobs$1 = new autoMatchJobs.AutoMatchJobRegistry(cache, runAutoMatch);
   router.delete(
     "/dependencies/service/:serviceId",
     async (request, response) => {
@@ -439,6 +415,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"]
+        });
       }
     }
   });
@@ -450,7 +548,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,
@@ -467,6 +565,7 @@ async function createRouter(options) {
       }
     }
   });
+  router.post("/mapping/entities", mappingsController.getMappingEntities(store, catalogApi));
   router.get(
     "/mapping/entity/:type/:namespace/:name",
     async (request, response) => {
@@ -526,90 +625,45 @@ async function createRouter(options) {
       }
     }
   );
-  router.post("/mapping/entity/auto-match", async (request, response) => {
-    try {
-      const threshold = request.body.threshold ?? 100;
-      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
+  router.post("/mapping/entity/auto-match/start", async (request, response) => {
+    const threshold = request.body.threshold ?? 100;
+    if (typeof threshold !== "number" || threshold < 0 || threshold > 100) {
+      response.status(400).json({
+        error: "Invalid threshold. Must be a number between 0 and 100."
       });
-      const loadTime = Date.now() - loadStartTime;
-      const matchStartTime = Date.now();
-      const matchingConfig = { threshold };
-      let matches = matchingEngine.findMatches(pdServices, bsComponents, matchingConfig);
-      if (bestOnly) {
-        matches = matchingEngine.filterToBestMatchPerService(matches);
-      }
-      const matchTime = Date.now() - matchStartTime;
-      const totalComparisons = pdServices.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
-          },
-          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: pdServices.length,
-          totalBackstageComponents: bsComponents.length,
-          totalPossibleComparisons: totalComparisons,
-          matchesFound: matches.length,
-          exactMatches,
-          highConfidenceMatches: highConfidence,
-          mediumConfidenceMatches: mediumConfidence,
-          threshold,
-          loadTimeMs: loadTime,
-          matchTimeMs: matchTime,
-          totalTimeMs: loadTime + matchTime
-        }
+      return;
+    }
+    const bestOnly = request.body.bestOnly ?? false;
+    const team = request.body.team;
+    const account = request.body.account;
+    const job = await autoMatchJobs$1.start({
+      threshold,
+      bestOnly,
+      team,
+      account
+    });
+    response.status(202).json({
+      jobId: job.id,
+      status: job.status
+    });
+  });
+  router.get("/mapping/entity/auto-match/:jobId", async (request, response) => {
+    const jobId = request.params.jobId;
+    const job = await autoMatchJobs$1.get(jobId);
+    if (!job) {
+      response.status(404).json({
+        error: `Auto-match job ${jobId} not found.`
       });
-    } 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)
-        });
-      }
+      return;
     }
+    response.json({
+      jobId: job.id,
+      status: job.status,
+      createdAt: job.createdAt,
+      completedAt: job.completedAt,
+      result: job.result,
+      error: job.error
+    });
   });
   router.get("/escalation_policies", async (_, response) => {
     try {
@@ -685,31 +739,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)]
+        });
       }
     }
   });
@@ -815,14 +903,30 @@ 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" });
   });
-  router.use(backendCommon.errorHandler());
+  router.use(rootHttpRouter.MiddlewareFactory.create({ config, logger }).error());
   return router;
 }
 
 exports.buildEntityMappingsResponse = buildEntityMappingsResponse;
-exports.createComponentEntitiesReferenceDict = createComponentEntitiesReferenceDict;
 exports.createRouter = createRouter;
 //# sourceMappingURL=router.cjs.js.map