@digital-ai/plugin-dai-release-backend/dist/service/router.cjs.js

Backend functionalities for the dai-release backstage plugin

'use strict';

var errors = require('@backstage/errors');
var pluginDaiReleaseCommon = require('@digital-ai/plugin-dai-release-common');
var apiConfig = require('../api/apiConfig.cjs.js');
var pluginPermissionCommon = require('@backstage/plugin-permission-common');
var CategoriesApi = require('../api/CategoriesApi.cjs.js');
var FoldersApi = require('../api/FoldersApi.cjs.js');
var rootHttpRouter = require('@backstage/backend-defaults/rootHttpRouter');
var releaseInstanceConfig = require('./releaseInstanceConfig.cjs.js');
var ReleaseOverviewApi = require('../api/ReleaseOverviewApi.cjs.js');
var Router = require('express-promise-router');
var TemplatesOverviewApi = require('../api/TemplatesOverviewApi.cjs.js');
var WorkflowsOverviewApi = require('../api/WorkflowsOverviewApi.cjs.js');
var pluginPermissionNode = require('@backstage/plugin-permission-node');
var express = require('express');
var responseUtil = require('../api/responseUtil.cjs.js');

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

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

async function createRouter(options) {
  const { logger, config, permissions, httpAuth } = options;
  const releaseOverviewApi = ReleaseOverviewApi.ReleaseOverviewApi.fromConfig(
    releaseInstanceConfig.ReleaseConfig.fromConfig(config),
    logger
  );
  const templatesOverviewApi = TemplatesOverviewApi.TemplatesOverviewApi.fromConfig(
    releaseInstanceConfig.ReleaseConfig.fromConfig(config),
    logger
  );
  const categoriesApi = CategoriesApi.CategoriesApi.fromConfig(
    releaseInstanceConfig.ReleaseConfig.fromConfig(config),
    logger
  );
  const workflowsOverviewApi = WorkflowsOverviewApi.WorkflowsOverviewApi.fromConfig(
    releaseInstanceConfig.ReleaseConfig.fromConfig(config),
    logger
  );
  const foldersApi = FoldersApi.FoldersApi.fromConfig(
    releaseInstanceConfig.ReleaseConfig.fromConfig(config),
    logger
  );
  if (config.subscribe) {
    config.subscribe(() => {
      releaseInstanceConfig.ReleaseConfig.fromConfig(config);
    });
  }
  const permissionIntegrationRouter = pluginPermissionNode.createPermissionIntegrationRouter({
    permissions: pluginDaiReleaseCommon.daiReleasePermissions
  });
  const router = Router__default.default();
  router.use(express__default.default.json());
  router.use(permissionIntegrationRouter);
  router.get("/health", (_, response) => {
    logger.info("PONG!");
    response.json({ status: "ok" });
  });
  router.get("/releases", async (req, res) => {
    if (permissions && httpAuth) {
      const decision = await permissions.authorize(
        [{ permission: pluginDaiReleaseCommon.daiReleaseViewPermission }],
        { credentials: await httpAuth.credentials(req) }
      );
      const { result } = decision[0];
      if (result === pluginPermissionCommon.AuthorizeResult.DENY) {
        throw new errors.NotAllowedError(
          "Access Denied: Unauthorized to access the Backstage Release plugin"
        );
      }
    }
    const failing = apiConfig.getEncodedQueryVal(req.query.failing?.toString());
    const planned = apiConfig.getEncodedQueryVal(req.query.planned?.toString());
    const completed = apiConfig.getEncodedQueryVal(req.query.completed?.toString());
    const paused = apiConfig.getEncodedQueryVal(req.query.paused?.toString());
    const aborted = apiConfig.getEncodedQueryVal(req.query.aborted?.toString());
    const inProgress = apiConfig.getEncodedQueryVal(req.query.inProgress?.toString());
    const failed = apiConfig.getEncodedQueryVal(req.query.failed?.toString());
    const title = apiConfig.getDecodedQueryVal(req.query.title?.toString());
    const fromDate = apiConfig.getEncodedQueryVal(req.query.fromDate?.toString());
    const toDate = apiConfig.getEncodedQueryVal(req.query.toDate?.toString());
    const orderBy = apiConfig.getEncodedQueryVal(req.query.orderBy?.toString());
    const pageNumber = apiConfig.getEncodedQueryVal(req.query.pageNumber?.toString());
    const resultsPerPage = apiConfig.getEncodedQueryVal(
      req.query.resultsPerPage?.toString()
    );
    const instanceName = req.query.instanceName?.toString() || "";
    const releases = await releaseOverviewApi.getReleases(
      failing,
      planned,
      completed,
      paused,
      aborted,
      inProgress,
      failed,
      title,
      fromDate,
      toDate,
      orderBy,
      pageNumber,
      resultsPerPage,
      instanceName
    );
    res.status(200).json(releases);
  });
  router.get("/templates", async (req, res) => {
    if (permissions && httpAuth) {
      const decision = await permissions.authorize(
        [{ permission: pluginDaiReleaseCommon.daiReleaseViewPermission }],
        { credentials: await httpAuth.credentials(req) }
      );
      const { result } = decision[0];
      if (result === pluginPermissionCommon.AuthorizeResult.DENY) {
        throw new errors.NotAllowedError(
          "Access Denied: Unauthorized to access the Backstage Release plugin"
        );
      }
    }
    const title = apiConfig.getDecodedQueryVal(req.query.title?.toString());
    const tags = req.query.tag ? req.query.tag.toString().split(",").map((tag) => apiConfig.getDecodedQueryVal(tag)) : [];
    const pageNumber = apiConfig.getEncodedQueryVal(req.query.pageNumber?.toString());
    const resultsPerPage = apiConfig.getEncodedQueryVal(
      req.query.resultsPerPage?.toString()
    );
    const instanceName = req.query.instanceName?.toString() || "";
    const templates = await releaseOverviewApi.getTemplates(
      title,
      tags,
      pageNumber,
      resultsPerPage,
      instanceName
    );
    res.status(200).json(templates);
  });
  router.get("/instances", async (req, res) => {
    if (permissions && httpAuth) {
      const decision = await permissions.authorize(
        [{ permission: pluginDaiReleaseCommon.daiReleaseViewPermission }],
        { credentials: await httpAuth.credentials(req) }
      );
      const { result } = decision[0];
      if (result === pluginPermissionCommon.AuthorizeResult.DENY) {
        throw new errors.NotAllowedError(
          "Access Denied: Unauthorized to access the Backstage Release plugin"
        );
      }
    }
    const instancesList = await releaseOverviewApi.getReleaseInstances();
    if (!responseUtil.validateInstanceRes(instancesList)) {
      throw new errors.InputError(
        "Invalid or Missing DaiRelease instance configuration"
      );
    }
    res.status(200).json(instancesList);
  });
  router.get("/template/meta", async (req, res) => {
    if (permissions && httpAuth) {
      const decision = await permissions.authorize(
        [{ permission: pluginDaiReleaseCommon.daiReleaseViewPermission }],
        { credentials: await httpAuth.credentials(req) }
      );
      const { result } = decision[0];
      if (result === pluginPermissionCommon.AuthorizeResult.DENY) {
        throw new errors.NotAllowedError(
          "Access Denied: Unauthorized to access the Backstage Release plugin"
        );
      }
    }
    const instanceName = req.query.instanceName?.toString() || "";
    const folderId = apiConfig.getDecodedQueryVal(req.query.folderId?.toString() || "");
    const metaInformation = await templatesOverviewApi.getTemplateMetaInfo(
      instanceName,
      folderId
    );
    res.status(200).json(metaInformation);
  });
  router.get("/categories", async (req, res) => {
    if (permissions && httpAuth) {
      const decision = await permissions.authorize(
        [{ permission: pluginDaiReleaseCommon.daiReleaseViewPermission }],
        { credentials: await httpAuth.credentials(req) }
      );
      const { result } = decision[0];
      if (result === pluginPermissionCommon.AuthorizeResult.DENY) {
        throw new errors.NotAllowedError(
          "Access Denied: Unauthorized to access the Backstage Release plugin"
        );
      }
    }
    const instanceName = req.query.instanceName?.toString() || "";
    const metaInformation = await categoriesApi.getCategoriesApi(instanceName);
    res.status(200).json(metaInformation);
  });
  router.post("/workflows", async (req, res) => {
    if (permissions && httpAuth) {
      const decision = await permissions.authorize(
        [{ permission: pluginDaiReleaseCommon.daiReleaseViewPermission }],
        { credentials: await httpAuth.credentials(req) }
      );
      const { result } = decision[0];
      if (result === pluginPermissionCommon.AuthorizeResult.DENY) {
        throw new errors.NotAllowedError(
          "Access Denied: Unauthorized to access the Backstage Release plugin"
        );
      }
    }
    const instanceName = req.query.instanceName?.toString() || "";
    const pageNumber = apiConfig.getEncodedQueryVal(req.query.pageNumber?.toString());
    const resultsPerPage = apiConfig.getEncodedQueryVal(
      req.query.resultsPerPage?.toString()
    );
    const searchInput = req.body.searchInput?.toString() || "";
    const categories = req.body.categories || [];
    const author = req.body.author?.toString() || "";
    const workflows = await workflowsOverviewApi.getWorkflowsOverviewApi(
      instanceName,
      pageNumber,
      resultsPerPage,
      searchInput,
      categories,
      author
    );
    res.status(200).json(workflows);
  });
  router.post("/workflow/redirect", async (req, res) => {
    if (permissions && httpAuth) {
      const decision = await permissions.authorize(
        [{ permission: pluginDaiReleaseCommon.daiReleaseViewPermission }],
        { credentials: await httpAuth.credentials(req) }
      );
      const { result } = decision[0];
      if (result === pluginPermissionCommon.AuthorizeResult.DENY) {
        throw new errors.NotAllowedError(
          "Access Denied: Unauthorized to access the Backstage Release plugin"
        );
      }
    }
    const instanceName = req.query.instanceName?.toString() || "";
    const { templateId, folderId, releaseTitle } = req.body;
    const redirectUrl = await workflowsOverviewApi.redirectToWorkflowRunPage(
      instanceName,
      templateId,
      releaseTitle,
      folderId
    );
    res.status(200).json({ url: redirectUrl });
  });
  router.get("/folders", async (req, res) => {
    if (permissions && httpAuth) {
      const decision = await permissions.authorize(
        [{ permission: pluginDaiReleaseCommon.daiReleaseViewPermission }],
        { credentials: await httpAuth.credentials(req) }
      );
      const { result } = decision[0];
      if (result === pluginPermissionCommon.AuthorizeResult.DENY) {
        throw new errors.NotAllowedError(
          "Access Denied: Unauthorized to access the Backstage Release plugin"
        );
      }
    }
    const instanceName = req.query.instanceName?.toString() || "";
    const folderList = await foldersApi.getFoldersListApi(instanceName);
    res.status(200).json(folderList);
  });
  const middleware = rootHttpRouter.MiddlewareFactory.create({ logger, config });
  router.use(middleware.error());
  return router;
}

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