@nitin15j/plugin-dora-backend/dist/api/router.cjs.js

This plugin backend was templated using the Backstage CLI. You should replace this text with a description of your plugin backend.

'use strict';

var express = require('express');
var zod = require('zod');

function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }

var express__default = /*#__PURE__*/_interopDefaultCompat(express);

async function createRouter(options) {
  const { metricsService, logger } = options;
  const router = express.Router();
  router.use(express__default.default.json());
  const MetricsQuerySchema = zod.z.object({
    timeRange: zod.z.string().regex(/^last\d+days$/i, "Time range must be in format: lastXdays (e.g., last7days)"),
    environment: zod.z.string().min(1, "Environment is required"),
    deploymentId: zod.z.string().min(1, "Deployment ID is required")
  });
  const OrgTrendMetricsQuerySchema = MetricsQuerySchema.pick({ timeRange: true });
  router.get("/metrics/:projectSlug", async (req, res) => {
    try {
      const { projectSlug } = req.params;
      const queryResult = MetricsQuerySchema.safeParse(req.query);
      if (!queryResult.success) {
        logger.warn("Invalid metrics request parameters", {
          errors: queryResult.error.errors.map((e) => ({
            path: e.path.join("."),
            message: e.message
          }))
        });
        return res.status(400).json({
          error: "Invalid request parameters",
          details: queryResult.error.errors
        });
      }
      const { timeRange, environment, deploymentId } = queryResult.data;
      logger.info("Received metrics request", {
        projectSlug,
        timeRange,
        environment,
        deploymentId,
        path: req.path,
        url: req.url,
        method: req.method
      });
      const metrics = await metricsService.getProjectMetrics(
        projectSlug,
        environment,
        deploymentId,
        timeRange
      );
      return res.json(metrics);
    } catch (error) {
      logger.error("Failed to fetch metrics", {
        error: error instanceof Error ? error.message : String(error),
        projectId: req.params.projectSlug
      });
      if (error instanceof Error && error.message === "No metrics data available") {
        return res.status(404).json({ error: "No metrics data available" });
      }
      return res.status(500).json({ error: "Failed to fetch metrics" });
    }
  });
  router.get("/metrics-insights/:projectId", async (req, res) => {
    try {
      const { projectId } = req.params;
      const queryResult = MetricsQuerySchema.safeParse(req.query);
      if (!queryResult.success) {
        logger.warn("Invalid metrics insights request parameters", {
          errors: queryResult.error.errors.map((e) => ({
            path: e.path.join("."),
            message: e.message
          }))
        });
        return res.status(400).json({
          error: "Invalid request parameters",
          details: queryResult.error.errors
        });
      }
      const { timeRange, environment, deploymentId } = queryResult.data;
      logger.info("Received metrics insights request", {
        projectId,
        timeRange,
        environment,
        deploymentId,
        path: req.path,
        url: req.url,
        method: req.method
      });
      const metrics = await metricsService.getProjectMetricsInsights(
        projectId,
        environment,
        deploymentId,
        timeRange
      );
      return res.json(metrics);
    } catch (error) {
      logger.error("Failed to fetch metrics", {
        error: error instanceof Error ? error.message : String(error),
        projectId: req.params.projectId
      });
      if (error instanceof Error && error.message === "No metrics insights data available") {
        return res.status(404).json({ error: "No metrics insights data available" });
      }
      return res.status(500).json({ error: "Failed to fetch metrics insights" });
    }
  });
  router.get("/org-trend-metrics", async (req, res) => {
    try {
      const queryResult = OrgTrendMetricsQuerySchema.safeParse(req.query);
      if (!queryResult.success) {
        logger.warn("Invalid Org Trend metric request parameters", {
          errors: queryResult.error.errors.map((e) => ({
            path: e.path.join("."),
            message: e.message
          }))
        });
        return res.status(400).json({
          error: "Invalid request parameters",
          details: queryResult.error.errors
        });
      }
      const { timeRange } = queryResult.data;
      logger.info("Received Org Trend metrics request", {
        timeRange,
        path: req.path,
        url: req.url,
        method: req.method
      });
      const result = await metricsService.getOrganizationTrendMetrics(
        timeRange
      );
      return res.json(result);
    } catch (error) {
      logger.error("Failed to fetch organization trend metrics", {
        error: error instanceof Error ? error.message : String(error)
      });
      return res.status(500).json({ error: "Failed to fetch organization trend metrics" });
    }
  });
  router.get("/team-metrics/:teamSlug", async (req, res) => {
    try {
      const { teamSlug } = req.params;
      const queryResult = MetricsQuerySchema.safeParse(req.query);
      if (!queryResult.success) {
        logger.warn("Invalid team metrics request parameters", {
          errors: queryResult.error.errors.map((e) => ({
            path: e.path.join("."),
            message: e.message
          }))
        });
        return res.status(400).json({
          error: "Invalid request parameters",
          details: queryResult.error.errors
        });
      }
      const { timeRange, environment, deploymentId } = queryResult.data;
      logger.info("Received team metrics request", {
        teamSlug,
        timeRange,
        environment,
        deploymentId,
        path: req.path,
        url: req.url,
        method: req.method
      });
      const metrics = await metricsService.getTeamMetrics(
        teamSlug,
        environment,
        timeRange
      );
      return res.json(metrics);
    } catch (error) {
      logger.error("Failed to fetch team metrics", {
        error: error instanceof Error ? error.message : String(error),
        teamSlug: req.params.teamSlug
      });
      if (error instanceof Error && error.message === "No team metrics data available") {
        return res.status(404).json({ error: "No team metrics data available" });
      }
      return res.status(500).json({ error: "Failed to fetch team metrics" });
    }
  });
  router.get("/team-metrics-insights/:teamSlug", async (req, res) => {
    try {
      const { teamSlug } = req.params;
      const queryResult = MetricsQuerySchema.safeParse(req.query);
      if (!queryResult.success) {
        logger.warn("Invalid team metrics insights request parameters", {
          errors: queryResult.error.errors.map((e) => ({
            path: e.path.join("."),
            message: e.message
          }))
        });
        return res.status(400).json({
          error: "Invalid request parameters",
          details: queryResult.error.errors
        });
      }
      const { timeRange, environment, deploymentId } = queryResult.data;
      logger.info("Received team metrics insights request", {
        teamSlug,
        timeRange,
        environment,
        deploymentId,
        path: req.path,
        url: req.url,
        method: req.method
      });
      const metrics = await metricsService.getTeamMetricsInsights(
        teamSlug,
        environment,
        deploymentId,
        timeRange
      );
      return res.json(metrics);
    } catch (error) {
      logger.error("Failed to fetch team metrics insights", {
        error: error instanceof Error ? error.message : String(error),
        teamSlug: req.params.teamSlug
      });
      if (error instanceof Error && error.message === "No team metrics insights data available") {
        return res.status(404).json({ error: "No team metrics insights data available" });
      }
      return res.status(500).json({ error: "Failed to fetch team metrics insights" });
    }
  });
  router.post("/batch-team-metrics", async (req, res) => {
    try {
      const { teamSlugs, timeRange, environment, deploymentId } = req.body;
      if (!teamSlugs || !Array.isArray(teamSlugs) || teamSlugs.length === 0) {
        return res.status(400).json({
          error: "teamSlugs is required and must be a non-empty array"
        });
      }
      if (!timeRange || !environment || !deploymentId) {
        return res.status(400).json({
          error: "timeRange, environment, and deploymentId are required"
        });
      }
      logger.info("Received batch team metrics request", {
        teamSlugs,
        timeRange,
        environment,
        deploymentId,
        path: req.path,
        url: req.url,
        method: req.method
      });
      const metrics = await metricsService.getBatchTeamMetrics(
        teamSlugs,
        environment,
        deploymentId,
        timeRange
      );
      return res.json(metrics);
    } catch (error) {
      logger.error("Failed to fetch batch team metrics", {
        error: error instanceof Error ? error.message : String(error),
        teamSlugs: req.body.teamSlugs
      });
      if (error instanceof Error && error.message === "No batch team metrics data available") {
        return res.status(404).json({ error: "No batch team metrics data available" });
      }
      return res.status(500).json({ error: "Failed to fetch batch team metrics" });
    }
  });
  return router;
}

exports.createRouter = createRouter;
//# sourceMappingURL=router.cjs.js.map