metis-desk/modules/assets/src/api/infrastructure/http/asset.routes.ts

import type { Application, RequestHandler, Response } from "express";
import { Router } from "express";
import { z } from "zod/v4";

import {
  AssetParamsSchema,
  InventoryParamsSchema,
  SaveAssetRequestSchema,
} from "../../../common/inventory";
import type { AssetUseCases } from "../../application/asset.use-cases";
import { buildRelationshipResponse } from "../../application/asset-relationship-response.builder";
import { buildAssetResponse } from "../../application/asset-response.builder";
import { buildWorkstationResponse } from "../../application/workstation-response.builder";

function fail(response: Response, code: string) {
  response
    .status(code === "INVALID_REQUEST" ? 400 : code.endsWith("NOT_FOUND") ? 404 : 409)
    .json({ code, requestId: response.getHeader("x-request-id") });
}

export function registerAssetRoutes(
  app: Application,
  useCases: AssetUseCases,
  authenticate: RequestHandler
) {
  const router = Router();

  router.get("/:companyId", (request, response, next) => {
    const params = InventoryParamsSchema.safeParse(request.params);

    if (!(params.success && z.strictObject({}).safeParse(request.query).success)) {
      fail(response, "INVALID_REQUEST");

      return;
    }
    useCases
      .get(params.data.companyId)
      .then((result) => {
        if (!result.isSuccess) {
          fail(response, result.error.code);

          return;
        }
        response.json({
          workstations: result.data.workstations.map((item) =>
            buildWorkstationResponse(item, result.data.actorNames)
          ),
          relationships: result.data.relationships.map((item) =>
            buildRelationshipResponse(item, result.data.actorNames)
          ),
          assets: result.data.assets.map((asset) =>
            buildAssetResponse(asset, result.data.actorNames, result.data.workstations)
          ),
        });
      })
      .catch(next);
  });
  router.post("/:companyId/:id/delete", (request, response, next) => {
    const params = AssetParamsSchema.safeParse(request.params);

    if (
      !(
        params.success &&
        z.strictObject({}).safeParse(request.query).success &&
        z.strictObject({}).safeParse(request.body).success
      )
    ) {
      fail(response, "INVALID_REQUEST");

      return;
    }
    useCases
      .remove(params.data.companyId, params.data.id)
      .then((result) => {
        if (!result.isSuccess) {
          fail(response, result.error.code);

          return;
        }
        response.json({
          asset: buildAssetResponse(
            result.data.asset,
            result.data.actorNames,
            result.data.workstations
          ),
        });
      })
      .catch(next);
  });
  for (const path of ["/:companyId", "/:companyId/:id/update"]) {
    router.post(path, (request, response, next) => {
      const params = (
        path.endsWith("update") ? AssetParamsSchema : InventoryParamsSchema
      ).safeParse(request.params);
      const body = SaveAssetRequestSchema.safeParse(request.body);
      const actor = z
        .object({ userId: z.uuid() })
        .safeParse("session" in request ? request.session : undefined);

      if (!(params.success && body.success && actor.success)) {
        fail(response, "INVALID_REQUEST");

        return;
      }
      const id =
        "id" in params.data && typeof params.data.id === "string" ? params.data.id : undefined;

      useCases
        .save(params.data.companyId, id, body.data.values, actor.data.userId)
        .then((result) => {
          if (!result.isSuccess) {
            fail(response, result.error.code);

            return;
          }
          response.status(id ? 200 : 201).json({
            asset: buildAssetResponse(
              result.data.asset,
              result.data.actorNames,
              result.data.workstations
            ),
          });
        })
        .catch(next);
    });
  }
  app.use("/api/assets", authenticate, router);
}