@pagerduty/backstage-plugin-backend 0.9.5 → 0.9.7

package/dist/service/router.cjs.js

@@ -0,0 +1,694 @@
+'use strict';
+
+var backendCommon = require('@backstage/backend-common');
+var pagerduty = require('../apis/pagerduty.cjs.js');
+var common = require('common');
+var auth = require('../auth/auth.cjs.js');
+var express = require('express');
+var Router = require('express-promise-router');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+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: []
+  };
+  pagerDutyServices.forEach((service) => {
+    const entityRef = componentEntitiesDict[service.id]?.ref;
+    const entityName = componentEntitiesDict[service.id]?.name;
+    const entityMapping = entityMappings.find((mapping) => mapping.serviceId === service.id);
+    if (entityMapping) {
+      if (entityRef === void 0) {
+        if (entityMapping.entityRef === "" || entityMapping.entityRef === void 0) {
+          result.mappings.push({
+            entityRef: "",
+            entityName: "",
+            integrationKey: entityMapping.integrationKey,
+            serviceId: entityMapping.serviceId,
+            status: "NotMapped",
+            serviceName: service.name,
+            team: service.teams?.[0]?.name ?? "",
+            escalationPolicy: service.escalation_policy !== void 0 ? service.escalation_policy.name : "",
+            serviceUrl: service.html_url,
+            account: service.account
+          });
+        } else {
+          const entityRefName = componentEntities.items.find((entity) => `${entity.kind}:${entity.metadata.namespace}/${entity.metadata.name}`.toLowerCase() === entityMapping.entityRef)?.metadata.name ?? "";
+          result.mappings.push({
+            entityRef: entityMapping.entityRef,
+            entityName: entityRefName,
+            serviceId: entityMapping.serviceId,
+            integrationKey: entityMapping.integrationKey,
+            status: "OutOfSync",
+            serviceName: service.name,
+            team: service.teams?.[0]?.name ?? "",
+            escalationPolicy: service.escalation_policy !== void 0 ? service.escalation_policy.name : "",
+            serviceUrl: service.html_url,
+            account: service.account
+          });
+        }
+      } else if (entityRef !== entityMapping.entityRef) {
+        const entityRefName = componentEntities.items.find((entity) => `${entity.kind}:${entity.metadata.namespace}/${entity.metadata.name}`.toLowerCase() === entityMapping.entityRef)?.metadata.name ?? "";
+        result.mappings.push({
+          entityRef: entityMapping.entityRef !== "" ? entityMapping.entityRef : "",
+          entityName: entityMapping.entityRef !== "" ? entityRefName : "",
+          serviceId: entityMapping.serviceId,
+          integrationKey: entityMapping.integrationKey,
+          status: "OutOfSync",
+          serviceName: service.name,
+          team: service.teams?.[0]?.name ?? "",
+          escalationPolicy: service.escalation_policy !== void 0 ? service.escalation_policy.name : "",
+          serviceUrl: service.html_url,
+          account: service.account
+        });
+      } else if (entityRef === entityMapping.entityRef) {
+        result.mappings.push({
+          entityRef: entityMapping.entityRef !== "" ? entityMapping.entityRef : "",
+          entityName: entityMapping.entityRef !== "" ? entityName : "",
+          serviceId: entityMapping.serviceId,
+          integrationKey: entityMapping.integrationKey,
+          status: "InSync",
+          serviceName: service.name,
+          team: service.teams?.[0]?.name ?? "",
+          escalationPolicy: service.escalation_policy !== void 0 ? service.escalation_policy.name : "",
+          serviceUrl: service.html_url,
+          account: service.account
+        });
+      }
+    } else {
+      const backstageVendorId = "PRO19CT";
+      const backstageIntegrationKey = service.integrations?.find((integration) => integration.vendor?.id === backstageVendorId)?.integration_key ?? "";
+      if (entityRef !== void 0) {
+        result.mappings.push({
+          entityRef,
+          entityName,
+          serviceId: service.id,
+          integrationKey: backstageIntegrationKey,
+          status: "InSync",
+          serviceName: service.name,
+          team: service.teams?.[0]?.name ?? "",
+          escalationPolicy: service.escalation_policy !== void 0 ? service.escalation_policy.name : "",
+          serviceUrl: service.html_url,
+          account: service.account
+        });
+      } else {
+        result.mappings.push({
+          entityRef: "",
+          entityName: "",
+          serviceId: service.id,
+          integrationKey: backstageIntegrationKey,
+          status: "NotMapped",
+          serviceName: service.name,
+          team: service.teams?.[0]?.name ?? "",
+          escalationPolicy: service.escalation_policy !== void 0 ? service.escalation_policy.name : "",
+          serviceUrl: service.html_url,
+          account: service.account
+        });
+      }
+    }
+  });
+  const sortedResult = result.mappings.sort((a, b) => {
+    if (a.serviceName < b.serviceName) {
+      return -1;
+    } else if (a.serviceName > b.serviceName) {
+      return 1;
+    }
+    return 0;
+  });
+  result.mappings = sortedResult;
+  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;
+  }
+  await auth.loadAuthConfig(config, logger);
+  pagerduty.loadPagerDutyEndpointsFromConfig(config, logger);
+  const router = Router__default.default();
+  router.use(express__namespace.json());
+  router.delete("/dependencies/service/:serviceId", async (request, response) => {
+    try {
+      const serviceId = request.params.serviceId || "";
+      const account = request.query.account || "";
+      if (serviceId === "") {
+        response.status(400).json("Bad Request: ':serviceId' must be provided as part of the path");
+        return;
+      }
+      const dependencies = Object.keys(request.body).length === 0 ? [] : request.body;
+      if (!dependencies || dependencies.length === 0) {
+        response.status(400).json("Bad Request: 'dependencies' must be provided as part of the request body");
+        return;
+      }
+      const serviceRelations = [];
+      dependencies.forEach(async (dependency) => {
+        serviceRelations.push({
+          supporting_service: {
+            id: dependency,
+            type: "service"
+          },
+          dependent_service: {
+            id: serviceId,
+            type: "service"
+          }
+        });
+      });
+      await pagerduty.removeServiceRelationsFromService(serviceRelations, account);
+      response.sendStatus(200);
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        logger.error(`Error occurred while processing request: ${error.message}`);
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.post("/dependencies/service/:serviceId", async (request, response) => {
+    try {
+      const serviceId = request.params.serviceId || "";
+      const account = request.query.account || "";
+      if (serviceId === "") {
+        response.status(400).json("Bad Request: ':serviceId' must be provided as part of the path");
+        return;
+      }
+      const dependencies = Object.keys(request.body).length === 0 ? [] : request.body;
+      if (!dependencies || dependencies.length === 0) {
+        response.status(400).json("Bad Request: 'dependencies' must be provided as part of the request body");
+        return;
+      }
+      const serviceRelations = [];
+      dependencies.forEach(async (dependency) => {
+        serviceRelations.push({
+          supporting_service: {
+            id: dependency,
+            type: "service"
+          },
+          dependent_service: {
+            id: serviceId,
+            type: "service"
+          }
+        });
+      });
+      await pagerduty.addServiceRelationsToService(serviceRelations, account);
+      response.sendStatus(200);
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        logger.error(`Error occurred while processing request: ${error.message}`);
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/dependencies/service/:serviceId", async (request, response) => {
+    try {
+      const serviceId = request.params.serviceId;
+      const account = request.query.account || "";
+      if (serviceId) {
+        const serviceRelationships = await pagerduty.getServiceRelationshipsById(serviceId, account);
+        if (serviceRelationships) {
+          response.json({
+            relationships: serviceRelationships
+          });
+        }
+      } else {
+        response.status(400).json("Bad Request: ':serviceId' must be provided as part of the path");
+      }
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/catalog/entity/:type/:namespace/:name", async (request, response) => {
+    const type = request.params.type;
+    const namespace = request.params.namespace;
+    const name = request.params.name;
+    try {
+      if (type && namespace && name) {
+        const entityRef = `${type}:${namespace}/${name}`.toLowerCase();
+        const foundEntity = await catalogApi?.getEntityByRef(entityRef);
+        if (foundEntity) {
+          response.json(foundEntity.metadata.annotations?.["pagerduty.com/service-id"]);
+        } else {
+          response.status(404);
+        }
+      } else {
+        response.status(400).json("Bad Request: ':entityRef' must be provided as part of the path");
+      }
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.post("/settings", async (request, response) => {
+    try {
+      const settings = request.body;
+      await Promise.all(settings.map(async (setting) => {
+        if (setting.id === void 0 || setting.value === void 0) {
+          response.status(400).json("Bad Request: 'id' and 'value' are required");
+          return;
+        }
+        if (!isValidSetting(setting.value)) {
+          response.status(400).json("Bad Request: 'value' is invalid. Valid options are 'backstage', 'pagerduty', 'both' or 'disabled'");
+          return;
+        }
+        await store.updateSetting(setting);
+      }));
+      response.sendStatus(200);
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        logger.error(`Error occurred while processing request: ${error.message}`);
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/settings/:settingId", async (request, response) => {
+    try {
+      const settingId = request.params.settingId;
+      const setting = await store.findSetting(settingId);
+      if (!setting) {
+        response.status(404).json({});
+        return;
+      }
+      response.json(setting);
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  function isValidSetting(value) {
+    if (value === "backstage" || value === "pagerduty" || value === "both" || value === "disabled") {
+      return true;
+    }
+    return false;
+  }
+  router.post("/mapping/entity", async (request, response) => {
+    try {
+      const entity = request.body;
+      if (!entity.serviceId) {
+        response.status(400).json("Bad Request: 'serviceId' must be provided as part of the request body");
+        return;
+      }
+      const entityMappings = await store.getAllEntityMappings();
+      const oldMapping = entityMappings.find((mapping) => mapping.serviceId === entity.serviceId);
+      if (entity.entityRef !== "" && (entity.integrationKey === "" || entity.integrationKey === void 0)) {
+        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;
+        }
+      }
+      const entityMappingId = await store.insertEntityMapping(entity);
+      if (entity.entityRef !== "") {
+        await catalogApi?.refreshEntity(entity.entityRef);
+      }
+      if (oldMapping && oldMapping.entityRef !== "") {
+        await catalogApi?.refreshEntity(oldMapping.entityRef);
+      }
+      response.json({
+        id: entityMappingId,
+        entityRef: entity.entityRef,
+        integrationKey: entity.integrationKey,
+        serviceId: entity.serviceId,
+        status: entity.status,
+        account: entity.account
+      });
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        logger.error(`Error occurred while processing request: ${error.message}`);
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/mapping/entity", async (_, response) => {
+    try {
+      const entityMappings = await store.getAllEntityMappings();
+      const componentEntities = await catalogApi.getEntities({
+        filter: {
+          kind: "Component"
+        }
+      });
+      const componentEntitiesDict = await createComponentEntitiesReferenceDict(componentEntities);
+      const pagerDutyServices = await pagerduty.getAllServices();
+      const result = await buildEntityMappingsResponse(entityMappings, componentEntitiesDict, componentEntities, pagerDutyServices);
+      response.json(result);
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/mapping/entity/:type/:namespace/:name", async (request, response) => {
+    try {
+      const entityType = request.params.type || "";
+      const entityNamespace = request.params.namespace || "";
+      const entityName = request.params.name || "";
+      if (entityType === "" || entityNamespace === "" || entityName === "") {
+        response.status(400).json("Required params not specified.");
+        return;
+      }
+      const entityRef = `${entityType}:${entityNamespace}/${entityName}`.toLowerCase();
+      const entityMapping = await store.findEntityMappingByEntityRef(entityRef);
+      if (!entityMapping) {
+        response.status(404).json(`Mapping for entityRef ${entityRef} not found.`);
+        return;
+      }
+      response.json({
+        mapping: entityMapping
+      });
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/mapping/entity/service/:serviceId", async (request, response) => {
+    try {
+      const serviceId = request.params.serviceId ?? "";
+      if (serviceId === "") {
+        response.status(400).json("Required params not specified.");
+        return;
+      }
+      const entityMapping = await store.findEntityMappingByServiceId(serviceId);
+      if (!entityMapping) {
+        response.status(404).json(`Mapping for serviceId ${serviceId} not found.`);
+        return;
+      }
+      response.json({
+        mapping: entityMapping
+      });
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/escalation_policies", async (_, response) => {
+    try {
+      let escalationPolicyList = await pagerduty.getAllEscalationPolicies();
+      escalationPolicyList = escalationPolicyList.sort((a, b) => {
+        if (a.account === b.account) {
+          return a.name.localeCompare(b.name);
+        }
+        return a.account.localeCompare(b.account);
+      });
+      const escalationPolicyDropDownOptions = escalationPolicyList.map((policy) => {
+        let policyLabel = policy.name;
+        if (policy.account && policy.account !== "default") {
+          policyLabel = `(${policy.account}) ${policy.name}`;
+        }
+        return {
+          label: policyLabel,
+          value: policy.id
+        };
+      });
+      response.json(escalationPolicyDropDownOptions);
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/oncall-users", async (request, response) => {
+    try {
+      const escalationPolicyId = request.query.escalation_policy_ids || "";
+      const account = request.query.account || "";
+      if (escalationPolicyId === "") {
+        response.status(400).json("Bad Request: 'escalation_policy_ids[]' is required");
+        return;
+      }
+      const oncallUsers = await pagerduty.getOncallUsers(escalationPolicyId, account);
+      const onCallUsersResponse = {
+        users: oncallUsers
+      };
+      response.json(onCallUsersResponse);
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/services/:serviceId", async (request, response) => {
+    try {
+      const serviceId = request.params.serviceId || "";
+      const account = request.query.account || "";
+      if (serviceId === "") {
+        response.status(400).json("Bad Request: ':serviceId' must be provided as part of the path or 'integration_key' as a query parameter");
+        return;
+      }
+      const service = await pagerduty.getServiceById(serviceId, account);
+      const serviceResponse = {
+        service
+      };
+      response.json(serviceResponse);
+    } catch (error) {
+      if (error instanceof common.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 service = await pagerduty.getServiceByIntegrationKey(integrationKey, account);
+        const serviceResponse = {
+          service
+        };
+        response.json(serviceResponse);
+      } else {
+        const services = await pagerduty.getAllServices();
+        const servicesResponse = {
+          services
+        };
+        response.json(servicesResponse);
+      }
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.post("/services/:serviceId/integration/:vendorId", async (request, response) => {
+    try {
+      const serviceId = request.params.serviceId || "";
+      const vendorId = request.params.vendorId || "";
+      const account = request.query.account || "";
+      if (serviceId === "" || vendorId === "") {
+        response.status(400).json("Bad Request: ':serviceId' and ':vendorId' must be provided as part of the path");
+        return;
+      }
+      const integrationKey = await pagerduty.createServiceIntegration({
+        serviceId,
+        vendorId,
+        account
+      });
+      response.json(integrationKey);
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        logger.error(`Error occurred while processing request: ${error.message}`);
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/services/:serviceId/change-events", async (request, response) => {
+    try {
+      const serviceId = request.params.serviceId || "";
+      const account = request.query.account || "";
+      const changeEvents = await pagerduty.getChangeEvents(serviceId, account);
+      const changeEventsResponse = {
+        change_events: changeEvents
+      };
+      response.json(changeEventsResponse);
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/services/:serviceId/incidents", async (request, response) => {
+    try {
+      const serviceId = request.params.serviceId || "";
+      const account = request.query.account || "";
+      const incidents = await pagerduty.getIncidents(serviceId, account);
+      const incidentsResponse = {
+        incidents
+      };
+      response.json(incidentsResponse);
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/services/:serviceId/standards", async (request, response) => {
+    try {
+      const serviceId = request.params.serviceId || "";
+      const account = request.query.account || "";
+      const serviceStandards = await pagerduty.getServiceStandards(serviceId, account);
+      const serviceStandardsResponse = {
+        standards: serviceStandards
+      };
+      response.json(serviceStandardsResponse);
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/services/:serviceId/metrics", async (request, response) => {
+    try {
+      const serviceId = request.params.serviceId || "";
+      const account = request.query.account || "";
+      const metrics = await pagerduty.getServiceMetrics(serviceId, account);
+      const metricsResponse = {
+        metrics
+      };
+      response.json(metricsResponse);
+    } catch (error) {
+      if (error instanceof common.HttpError) {
+        response.status(error.status).json({
+          errors: [
+            `${error.message}`
+          ]
+        });
+      }
+    }
+  });
+  router.get("/health", async (_, response) => {
+    response.status(200).json({ status: "ok" });
+  });
+  router.use(backendCommon.errorHandler());
+  return router;
+}
+
+exports.buildEntityMappingsResponse = buildEntityMappingsResponse;
+exports.createComponentEntitiesReferenceDict = createComponentEntitiesReferenceDict;
+exports.createRouter = createRouter;
+//# sourceMappingURL=router.cjs.js.map