server.mjs

import express from "express";
import cors from "cors";
import helmet from "helmet";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { seedReleases } from "./src/data/releases.mjs";
import {
  enrichRelease,
  buildReleaseSummary,
  buildStakeholderUpdate
} from "./src/releaseEngine.mjs";

const app = express();
const PORT = process.env.PORT || 8080;

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const publicDirectory = path.join(__dirname, "public");

let releases = seedReleases.map((release) => structuredClone(release));

app.use(helmet({
  contentSecurityPolicy: false
}));

app.use(cors());
app.use(express.json({ limit: "1mb" }));
app.use(express.static(publicDirectory));

app.get("/api/health", (request, response) => {
  response.json({
    status: "healthy",
    service: "ReleaseOps Cloud Delivery & Launch Readiness Console",
    version: "2.0.0",
    timestamp: new Date().toISOString()
  });
});

app.get("/api/releases", (request, response) => {
  const { state, environment, q } = request.query;

  let result = releases.map(enrichRelease);

  if (state && state !== "All") {
    result = result.filter((release) => release.launchState === state);
  }

  if (environment && environment !== "All") {
    result = result.filter((release) => release.environment === environment);
  }

  if (q) {
    const search = String(q).toLowerCase();

    result = result.filter((release) =>
      release.id.toLowerCase().includes(search) ||
      release.name.toLowerCase().includes(search) ||
      release.product.toLowerCase().includes(search) ||
      release.owner.toLowerCase().includes(search)
    );
  }

  result.sort((a, b) => {
    if (b.totalRisk !== a.totalRisk) {
      return b.totalRisk - a.totalRisk;
    }

    return a.readinessScore - b.readinessScore;
  });

  response.json({
    count: result.length,
    releases: result
  });
});

app.get("/api/releases/:id", (request, response) => {
  const release = releases.find((item) => item.id === request.params.id);

  if (!release) {
    return response.status(404).json({
      error: "Release not found."
    });
  }

  response.json(enrichRelease(release));
});

app.patch("/api/releases/:id/blockers/:blockerId", (request, response) => {
  const release = releases.find((item) => item.id === request.params.id);

  if (!release) {
    return response.status(404).json({
      error: "Release not found."
    });
  }

  const blocker = release.blockers.find((item) => item.id === request.params.blockerId);

  if (!blocker) {
    return response.status(404).json({
      error: "Blocker not found."
    });
  }

  const nextStatus = request.body?.status;
  const allowedStatuses = ["Open", "Resolved"];

  if (!allowedStatuses.includes(nextStatus)) {
    return response.status(400).json({
      error: "Invalid blocker status.",
      allowedStatuses
    });
  }

  blocker.status = nextStatus;

  response.json(enrichRelease(release));
});

app.patch("/api/releases/:id/checks/:checkName", (request, response) => {
  const release = releases.find((item) => item.id === request.params.id);

  if (!release) {
    return response.status(404).json({
      error: "Release not found."
    });
  }

  const checkName = request.params.checkName;

  if (!(checkName in release.checks)) {
    return response.status(404).json({
      error: "Readiness check not found."
    });
  }

  release.checks[checkName] = Boolean(request.body?.value);

  response.json(enrichRelease(release));
});

app.get("/api/release-summary", (request, response) => {
  response.json(buildReleaseSummary(releases));
});

app.get("/api/stakeholder-update", (request, response) => {
  response.json(buildStakeholderUpdate(releases));
});

app.post("/api/reset", (request, response) => {
  releases = seedReleases.map((release) => structuredClone(release));

  response.json({
    status: "reset",
    releases: releases.map(enrichRelease)
  });
});

app.use((request, response) => {
  response.sendFile(path.join(publicDirectory, "index.html"));
});

app.listen(PORT, () => {
  console.log(`ReleaseOps running at http://localhost:${PORT}`);
});