@backstage-community/plugin-mend-backend 0.1.0 → 0.2.0

package/dist/index.cjs.js

@@ -2,748 +2,18 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var express = require('express');
-var Router = require('express-promise-router');
-var rootHttpRouter = require('@backstage/backend-defaults/rootHttpRouter');
-var catalogClient = require('@backstage/catalog-client');
-var pluginPermissionCommon = require('@backstage/plugin-permission-common');
-var pathToRegexp = require('path-to-regexp');
-var jwt = require('jsonwebtoken');
-var pluginPermissionNode = require('@backstage/plugin-permission-node');
-var zod = require('zod');
-var backendPluginApi = require('@backstage/backend-plugin-api');
+var router = require('./service/router.cjs.js');
+var plugin = require('./plugin.cjs.js');
+var permissions = require('./permission/permissions.cjs.js');
+var conditions = require('./permission/conditions.cjs.js');
+require('./permission/rules.cjs.js');
 
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
-var express__default = /*#__PURE__*/_interopDefaultCompat(express);
-var Router__default = /*#__PURE__*/_interopDefaultCompat(Router);
-var jwt__default = /*#__PURE__*/_interopDefaultCompat(jwt);
 
-var StatisticsEngine = /* @__PURE__ */ ((StatisticsEngine2) => {
-  StatisticsEngine2["DEPENDENCIES"] = "dependencies";
-  StatisticsEngine2["CODE"] = "code";
-  StatisticsEngine2["CONTAINERS"] = "containers";
-  return StatisticsEngine2;
-})(StatisticsEngine || {});
-
-const dataProjectParser = (projectStatistics, organizationProjects) => {
-  const organizationData = organizationProjects.reduce((prev, next) => {
-    prev[next.uuid] = next;
-    return prev;
-  }, {});
-  const projectData = projectStatistics.reduce(
-    (prev, next) => {
-      const dependenciesCritical = next.statistics["ALERTS" /* DEPENDENCIES */].criticalSeverityVulnerabilities;
-      const dependenciesHigh = next.statistics["ALERTS" /* DEPENDENCIES */].highSeverityVulnerabilities;
-      const dependenciesMedium = next.statistics["ALERTS" /* DEPENDENCIES */].mediumSeverityVulnerabilities;
-      const dependenciesLow = next.statistics["ALERTS" /* DEPENDENCIES */].lowSeverityVulnerabilities;
-      const dependeciesTotal = dependenciesCritical + dependenciesHigh + dependenciesMedium + dependenciesLow;
-      const codeHigh = next.statistics["SAST_VULNERABILITIES_BY_SEVERITY" /* CODE */].sastHighVulnerabilities;
-      const codeMedium = next.statistics["SAST_VULNERABILITIES_BY_SEVERITY" /* CODE */].sastMediumVulnerabilities;
-      const codeLow = next.statistics["SAST_VULNERABILITIES_BY_SEVERITY" /* CODE */].sastLowVulnerabilities;
-      const codeTotal = codeHigh + codeMedium + codeLow;
-      const containersCritical = next.statistics["IMG_SECURITY" /* CONTAINERS */].imgCriticalVulnerabilities;
-      const containersHigh = next.statistics["IMG_SECURITY" /* CONTAINERS */].imgHighVulnerabilities;
-      const containersMedium = next.statistics["IMG_SECURITY" /* CONTAINERS */].imgMediumVulnerabilities;
-      const containersLow = next.statistics["IMG_SECURITY" /* CONTAINERS */].imgLowVulnerabilities;
-      const containersTotal = containersCritical + containersHigh + containersMedium + containersLow;
-      const criticalTotal = dependenciesCritical + containersCritical;
-      const highTotal = dependenciesHigh + codeHigh + containersHigh;
-      const mediumTotal = dependenciesMedium + codeMedium + containersMedium;
-      const lowTotal = dependenciesLow + codeLow + containersLow;
-      const total = dependeciesTotal + codeTotal + containersTotal;
-      const statistics = {
-        [StatisticsEngine.DEPENDENCIES]: {
-          critical: dependenciesCritical,
-          high: dependenciesHigh,
-          medium: dependenciesMedium,
-          low: dependenciesLow,
-          total: dependeciesTotal
-        },
-        [StatisticsEngine.CODE]: {
-          critical: null,
-          high: codeHigh,
-          medium: codeMedium,
-          low: codeLow,
-          total: codeTotal
-        },
-        [StatisticsEngine.CONTAINERS]: {
-          critical: containersCritical,
-          high: containersHigh,
-          medium: containersMedium,
-          low: containersLow,
-          total: containersTotal
-        },
-        critical: criticalTotal,
-        high: highTotal,
-        medium: mediumTotal,
-        low: lowTotal,
-        total
-      };
-      const project = {
-        statistics,
-        uuid: next.uuid,
-        name: next.name,
-        path: next.path,
-        entity: next.entity,
-        applicationName: organizationData[next.uuid].applicationName,
-        applicationUuid: next.applicationUuid,
-        lastScan: next.statistics["LAST_SCAN" /* LAST_SCAN */].lastScanTime,
-        languages: Object.entries(next.statistics.LIBRARY_TYPE_HISTOGRAM).sort(
-          (a, b) => b[1] - a[1]
-        )
-      };
-      prev.projectList.unshift(project);
-      return prev;
-    },
-    {
-      projectList: []
-    }
-  );
-  projectData.projectList.sort(
-    (a, b) => b.statistics.critical - a.statistics.critical
-  );
-  return projectData;
-};
-const parseEntityURL = (entityUrl) => {
-  try {
-    if (!entityUrl) {
-      return null;
-    }
-    const matches = entityUrl.match(
-      /https?:\/\/[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,}(:[0-9]{1,5})?(\/.*)?/g
-    );
-    if (!matches) {
-      return null;
-    }
-    const url = new URL(matches[0]);
-    const fn = pathToRegexp.match("/:org/:repo", { end: false });
-    return fn(url.pathname);
-  } catch (error) {
-    return null;
-  }
-};
-const dataMatcher = (entities, projects) => {
-  return entities.reduce(
-    (prev, next) => {
-      const entityURL = parseEntityURL(
-        next?.metadata?.annotations?.["backstage.io/source-location"]
-      );
-      if (!entityURL) {
-        return prev;
-      }
-      const project = projects.find(
-        (item) => item.path.match(/^GH_(.*)/)?.[1] === entityURL?.params.repo
-      );
-      if (!project) {
-        return prev;
-      }
-      const entity = {
-        path: entityURL.path,
-        params: entityURL.params,
-        namespace: next.metadata.namespace,
-        kind: "component",
-        source: "catalog"
-      };
-      prev.push({ ...project, entity });
-      return prev;
-    },
-    []
-  );
-};
-const getIssueStatus = (engine, finding) => {
-  if (engine === StatisticsEngine.CODE) {
-    if (finding?.suppressed)
-      return "suppressed";
-    if (finding?.almIssues?.jiraPlatform?.issueStatus)
-      return "created";
-    if (finding?.reviewed)
-      return "reviewed";
-  }
-  if (engine === StatisticsEngine.DEPENDENCIES) {
-    if (finding?.findingInfo?.status === "IGNORED")
-      return "suppressed";
-  }
-  return "unreviewed";
-};
-const dataFindingParser = (code = [], dependencies = [], containers = []) => {
-  let codeFindings = [];
-  let dependenciesFindings = [];
-  let containersFindings = [];
-  if (code.length) {
-    codeFindings = code.map((finding) => {
-      return {
-        kind: StatisticsEngine.CODE,
-        level: finding.severity.toLowerCase(),
-        name: finding.type.cwe.title,
-        origin: `${finding.sharedStep.file}:${finding.sharedStep.line}`,
-        time: finding?.createdTime,
-        issue: {
-          issueStatus: finding.almIssues.jiraPlatform.issueStatus,
-          reporter: finding.almIssues.jiraPlatform.createdByName,
-          creationDate: finding.almIssues.jiraPlatform.createdTime,
-          ticketName: finding.almIssues.jiraPlatform.issueKey,
-          link: `${finding.almIssues.jiraPlatform.publicLink}/browse/${finding.almIssues.jiraPlatform.issueKey}`,
-          status: getIssueStatus(StatisticsEngine.CODE, finding)
-        }
-      };
-    });
-  }
-  if (dependencies.length) {
-    dependenciesFindings = dependencies.map((finding) => {
-      return {
-        kind: StatisticsEngine.DEPENDENCIES,
-        level: finding.vulnerability.severity.toLowerCase(),
-        name: finding.vulnerability.name,
-        origin: finding.component.name,
-        time: finding.vulnerability.modifiedDate,
-        issue: {
-          issueStatus: "",
-          reporter: "",
-          creationDate: "",
-          ticketName: "",
-          link: "",
-          status: getIssueStatus(StatisticsEngine.DEPENDENCIES, finding)
-        }
-      };
-    });
-  }
-  if (containers.length) {
-    containersFindings = containers.map((finding) => {
-      return {
-        kind: StatisticsEngine.CONTAINERS,
-        level: finding.severity.toLowerCase(),
-        name: finding.vulnerabilityId,
-        origin: finding.packageName,
-        time: finding.detectionDate,
-        issue: {
-          issueStatus: "",
-          reporter: "",
-          creationDate: "",
-          ticketName: "",
-          link: "",
-          status: getIssueStatus(StatisticsEngine.CONTAINERS, finding)
-          // NOTE: Currently, issue for finding in containers no exist.
-        }
-      };
-    });
-  }
-  const order = {
-    critical: 1,
-    high: 2,
-    medium: 3,
-    low: 4
-  };
-  return [...codeFindings, ...dependenciesFindings, ...containersFindings].sort(
-    (a, b) => {
-      return order[a.level] - order[b.level];
-    }
-  );
-};
-const parseQueryString = (href = "?") => {
-  const [, queryString] = href.split("?");
-  const queryParams = {};
-  new URLSearchParams(queryString).forEach((val, key) => {
-    queryParams[key] = val;
-  });
-  return queryParams;
-};
-const fetchQueryPagination = async (cb) => {
-  const defaultQueryParams = { limit: "10000", cursor: "0" };
-  const collection = [];
-  const fetchLoop = async (queryParams) => {
-    const result = await cb({ queryParams });
-    collection.push(...result.response);
-    const nextQuery = result.additionalData?.paging?.next;
-    if (nextQuery) {
-      const newQueryParams = parseQueryString(nextQuery);
-      await fetchLoop(newQueryParams);
-    }
-  };
-  await fetchLoop(defaultQueryParams);
-  return collection;
-};
-
-const caesarCipherDecrypt = (activationKey) => {
-  let tmp = "";
-  const OFFSET = 4;
-  for (let i = 0; i < activationKey.length; i++) {
-    tmp += String.fromCharCode(activationKey.charCodeAt(i) - OFFSET);
-  }
-  const reversed = tmp.split("").reverse().join("");
-  return Buffer.from(reversed, "base64").toString();
-};
-
-class MendAuthSevice {
-  static authToken = "";
-  static refreshToken = "";
-  static baseUrl = "";
-  static clientEmail = "";
-  static clientKey = "";
-  static clientUrl = "";
-  static clientName = "";
-  static clientUuid = "";
-  constructor(config) {
-    MendAuthSevice.baseUrl = config.baseUrl;
-    this.getConfig(config.activationKey);
-  }
-  getConfig(activationKey) {
-    const licenseKey = caesarCipherDecrypt(activationKey);
-    const jwtPayload = jwt__default.default.decode(licenseKey);
-    MendAuthSevice.clientEmail = jwtPayload.integratorEmail;
-    MendAuthSevice.clientKey = jwtPayload.userKey;
-    MendAuthSevice.clientUrl = jwtPayload.wsEnvUrl;
-  }
-  static async login() {
-    return post("/login" /* LOGIN */, {
-      body: {
-        email: this.clientEmail,
-        userKey: this.clientKey
-      }
-    }).then((data) => {
-      this.refreshToken = data.response.refreshToken;
-      return Promise.resolve();
-    });
-  }
-  static async refreshAccessToken() {
-    return post(
-      "/login/accessToken" /* REFRESH_TOKEN */,
-      {
-        headers: {
-          "wss-refresh-token": this.refreshToken
-        }
-      }
-    ).then((data) => {
-      this.authToken = data.response.jwtToken;
-      this.clientName = data.response.orgName;
-      this.clientUuid = data.response.orgUuid;
-      return Promise.resolve();
-    });
-  }
-  static async connect() {
-    return MendAuthSevice.login().then(
-      () => MendAuthSevice.refreshAccessToken()
-    );
-  }
-  static async validateAuthToken(url) {
-    if (["/login" /* LOGIN */, "/login/accessToken" /* REFRESH_TOKEN */].includes(url)) {
-      return Promise.resolve();
-    }
-    if (!this.authToken) {
-      return this.connect();
-    }
-    const token = jwt__default.default.decode(this.authToken);
-    if (new Date(Number(`${token.exp}000`)).getTime() - Date.now() < 0) {
-      return this.connect();
-    }
-    return Promise.resolve();
-  }
-  static getAuthToken() {
-    return MendAuthSevice.authToken;
-  }
-  static getBaseUrl() {
-    return MendAuthSevice.baseUrl;
-  }
-  static getOrganizationUuid() {
-    return MendAuthSevice.clientUuid;
-  }
-  static getClientUrl() {
-    return MendAuthSevice.clientUrl;
-  }
-  static getClientName() {
-    return MendAuthSevice.clientName;
-  }
-}
-
-function assembleUri(uri, params) {
-  if (!params) {
-    return uri;
-  }
-  const queryString = new URLSearchParams(params).toString();
-  return `${uri}?${queryString}`;
-}
-function buildHeaders(optionHeaders) {
-  const headers = new Headers();
-  headers.set("Content-Type" /* CONTENT_TYPE */, "application/json");
-  headers.set("agent-name" /* AGENT_NAME */, "pi-backstage");
-  headers.set("agent-version" /* AGENT_VERSION */, "24.8.2");
-  const authToken = MendAuthSevice.getAuthToken();
-  if (authToken) {
-    headers.set("Authorization" /* AUTH_TOKEN */, `Bearer ${authToken}`);
-  }
-  Object.keys(optionHeaders).forEach((header) => {
-    const headerValue = optionHeaders[header];
-    if (headerValue) {
-      headers.set(header, headerValue);
-    }
-  });
-  return headers;
-}
-function fetchRequest(method, path, opts) {
-  return MendAuthSevice.validateAuthToken(path).then(() => {
-    const { params, body, headers } = opts;
-    const url = `${MendAuthSevice.getBaseUrl()}${path}`;
-    const requestURL = params ? assembleUri(url, params) : url;
-    const requestParams = {
-      headers: buildHeaders(headers || {}),
-      method,
-      body
-    };
-    if (body) {
-      requestParams.body = typeof body === "string" ? body : JSON.stringify(body);
-    }
-    const requestObject = new Request(requestURL, requestParams);
-    return fetch(requestObject);
-  });
-}
-function toJson(response) {
-  if (response.status === 204 || response.body === null) {
-    return Promise.resolve({});
-  }
-  return response.json().then((json) => {
-    return response.ok ? json : Promise.reject(json);
-  });
-}
-const defaultOpts = {
-  body: null,
-  headers: {},
-  params: null
-};
-function get(url, opts = defaultOpts) {
-  return fetchRequest("GET" /* GET */, url, opts).then(toJson);
-}
-function post(url, opts = defaultOpts) {
-  return fetchRequest("POST" /* POST */, url, opts).then(toJson);
-}
-
-class MendDataService extends MendAuthSevice {
-  async getOrganizationProject({
-    queryParams
-  }) {
-    return get(`/orgs/${MendAuthSevice.getOrganizationUuid()}/projects`, {
-      params: {
-        ...queryParams
-      }
-    });
-  }
-  async getProjectStatistics({
-    queryParams,
-    bodyParams
-  }) {
-    return post(
-      `/orgs/${MendAuthSevice.getOrganizationUuid()}/projects/summaries`,
-      {
-        params: {
-          ...queryParams
-        },
-        body: {
-          ...bodyParams
-        }
-      }
-    );
-  }
-  async getCodeFinding({
-    pathParams,
-    queryParams
-  }) {
-    return get(`/projects/${pathParams.uuid}/code/findings`, {
-      params: {
-        ...queryParams
-      }
-    });
-  }
-  async getDependenciesFinding({
-    pathParams,
-    queryParams
-  }) {
-    return get(`/projects/${pathParams.uuid}/dependencies/findings/security`, {
-      params: {
-        ...queryParams
-      }
-    });
-  }
-  async getContainersFinding({
-    pathParams,
-    queryParams
-  }) {
-    return get(`/projects/${pathParams.uuid}/images/findings/security`, {
-      params: {
-        ...queryParams
-      }
-    });
-  }
-}
-
-var RESOURCE_TYPE = /* @__PURE__ */ ((RESOURCE_TYPE2) => {
-  RESOURCE_TYPE2["PROJECT"] = "mend-project";
-  return RESOURCE_TYPE2;
-})(RESOURCE_TYPE || {});
-const mendReadPermission = pluginPermissionCommon.createPermission({
-  name: "mend.project.read",
-  attributes: { action: "read" },
-  resourceType: "mend-project" /* PROJECT */
-});
-
-const createProjectPermissionRule = pluginPermissionNode.makeCreatePermissionRule();
-const filter = createProjectPermissionRule({
-  name: "filter",
-  description: "Should allow read-only access to filtered projects.",
-  resourceType: RESOURCE_TYPE.PROJECT,
-  paramsSchema: zod.z.object({
-    ids: zod.z.string().array().describe("Project ID to match resource"),
-    exclude: zod.z.boolean().optional().describe("Exclude or include project")
-  }),
-  apply: (resource, { ids, exclude = true }) => {
-    return exclude ? !ids.includes(resource.resourceRef) : ids.includes(resource.resourceRef);
-  },
-  toQuery: ({ ids, exclude = true }) => {
-    return {
-      ids,
-      exclude
-    };
-  }
-});
-const rules = { filter };
-
-const { conditions, createConditionalDecision } = pluginPermissionNode.createConditionExports({
-  pluginId: "mend",
-  resourceType: RESOURCE_TYPE.PROJECT,
-  rules
-});
-const mendConditions = conditions;
-const createMendProjectConditionalDecision = createConditionalDecision;
-const permissionIntegrationRouter = pluginPermissionNode.createPermissionIntegrationRouter({
-  permissions: [mendReadPermission],
-  getResources: async (resourceRefs) => {
-    return resourceRefs.map((resourceRef) => {
-      return {
-        permission: mendReadPermission,
-        resourceRef
-      };
-    });
-  },
-  resourceType: RESOURCE_TYPE.PROJECT,
-  rules: Object.values(rules)
-});
-const transformConditions = pluginPermissionNode.createConditionTransformer(Object.values(rules));
-
-async function createRouter(options) {
-  const { logger, config, discovery, auth, httpAuth, permissions } = options;
-  const router = Router__default.default();
-  router.use(express__default.default.json());
-  router.use(permissionIntegrationRouter);
-  const checkForAuth = (_request, response, next) => {
-    if (MendAuthSevice.getAuthToken()) {
-      next();
-      return;
-    }
-    MendAuthSevice.connect().then(next).catch(() => {
-      response.status(401).json({ error: "Oops! Unauthorized" });
-    });
-  };
-  const baseUrl = config.getString("mend.baseUrl");
-  const activationKey = config.getString("mend.activationKey");
-  const mendDataService = new MendDataService({
-    baseUrl,
-    activationKey
-  });
-  const catalogClient$1 = new catalogClient.CatalogClient({ discoveryApi: discovery });
-  router.get("/project" /* PROJECT */, checkForAuth, async (request, response) => {
-    try {
-      const credentials = await httpAuth.credentials(request);
-      const { token } = await auth.getPluginRequestToken({
-        onBehalfOf: credentials,
-        targetPluginId: "plugin.catalog.service"
-      });
-      const results = await Promise.all([
-        catalogClient$1.getEntities(
-          { filter: [{ kind: ["Component"] }] },
-          { token }
-        ),
-        fetchQueryPagination(
-          mendDataService.getProjectStatistics
-        ),
-        fetchQueryPagination(
-          mendDataService.getOrganizationProject
-        )
-      ]);
-      const decision = (await permissions.authorizeConditional(
-        [{ permission: mendReadPermission }],
-        {
-          credentials
-        }
-      ))[0];
-      let items;
-      if (decision.result === pluginPermissionCommon.AuthorizeResult.CONDITIONAL) {
-        const filter = transformConditions(decision.conditions);
-        items = results[1].filter(
-          (item) => filter?.exclude ? !filter.ids.includes(item.uuid) : filter.ids.includes(item.uuid)
-        );
-      }
-      const data = dataMatcher(results[0].items, items || results[1]);
-      const projects = dataProjectParser(data, results[2]);
-      response.json({
-        ...projects,
-        clientUrl: MendAuthSevice.getClientUrl(),
-        clientName: MendAuthSevice.getClientName()
-      });
-    } catch (error) {
-      logger.error("/project", error);
-      response.status(500).json({ error: "Oops! Please try again later." });
-    }
-  });
-  router.post("/finding" /* FINDING */, checkForAuth, async (request, response) => {
-    try {
-      const credentials = await httpAuth.credentials(request);
-      const { token } = await auth.getPluginRequestToken({
-        onBehalfOf: credentials,
-        targetPluginId: "plugin.catalog.service"
-      });
-      const uid = request.body.uid;
-      if (!uid) {
-        response.status(401).json({ error: "Oops! No UUID provided" });
-        return;
-      }
-      const projectResult = await Promise.all([
-        catalogClient$1.getEntities(
-          { filter: [{ "metadata.uid": uid }] },
-          { token }
-        ),
-        fetchQueryPagination(
-          mendDataService.getProjectStatistics
-        ),
-        fetchQueryPagination(
-          mendDataService.getOrganizationProject
-        )
-      ]);
-      const decision = (await permissions.authorizeConditional(
-        [{ permission: mendReadPermission }],
-        {
-          credentials
-        }
-      ))[0];
-      let items;
-      if (decision.result === pluginPermissionCommon.AuthorizeResult.CONDITIONAL) {
-        const filter = transformConditions(decision.conditions);
-        items = projectResult[1].filter(
-          (item) => filter?.exclude ? !filter.ids.includes(item.uuid) : filter.ids.includes(item.uuid)
-        );
-      }
-      const data = dataMatcher(
-        projectResult[0].items,
-        items || projectResult[1]
-      );
-      if (!data.length) {
-        response.json({
-          findingList: [],
-          projectName: "",
-          projectUuid: "",
-          clientUrl: MendAuthSevice.getClientUrl(),
-          clientName: MendAuthSevice.getClientName()
-        });
-        return;
-      }
-      const params = {
-        pathParams: {
-          uuid: data[0].uuid
-        }
-      };
-      const findingResult = await Promise.all([
-        fetchQueryPagination(
-          (queryParam) => mendDataService.getCodeFinding({
-            ...params,
-            ...queryParam
-          })
-        ),
-        fetchQueryPagination(
-          (queryParam) => mendDataService.getDependenciesFinding({
-            ...params,
-            ...queryParam
-          })
-        ),
-        fetchQueryPagination(
-          (queryParam) => mendDataService.getContainersFinding({
-            ...params,
-            ...queryParam
-          })
-        )
-      ]);
-      const project = dataProjectParser(data, projectResult[2]);
-      const findingList = dataFindingParser(
-        findingResult[0].filter((item) => !item.suppressed),
-        // NOTE: Do not show suppressed item
-        findingResult[1].filter(
-          (item) => !(item.findingInfo.status === "IGNORED")
-        ),
-        // NOTE: Do not show ignored item
-        findingResult[2]
-        // ESC-51: Follow Jira activity
-      );
-      response.json({
-        findingList,
-        projectName: project.projectList[0].entity.params.repo,
-        projectUuid: project.projectList[0].uuid,
-        clientUrl: MendAuthSevice.getClientUrl(),
-        clientName: MendAuthSevice.getClientName()
-      });
-    } catch (error) {
-      logger.error("/finding", error);
-      response.status(500).json({ error: "Oops! Please try again later." });
-    }
-  });
-  router.get("/health", (_, response) => {
-    logger.info("PONG!");
-    response.json({ status: "ok" });
-  });
-  const middleware = rootHttpRouter.MiddlewareFactory.create({ logger, config });
-  router.use(middleware.error());
-  return router;
-}
-
-const mendPlugin = backendPluginApi.createBackendPlugin({
-  pluginId: "mend",
-  register(env) {
-    env.registerInit({
-      deps: {
-        auth: backendPluginApi.coreServices.auth,
-        config: backendPluginApi.coreServices.rootConfig,
-        discovery: backendPluginApi.coreServices.discovery,
-        httpAuth: backendPluginApi.coreServices.httpAuth,
-        httpRouter: backendPluginApi.coreServices.httpRouter,
-        logger: backendPluginApi.coreServices.logger,
-        permissions: backendPluginApi.coreServices.permissions
-      },
-      async init({
-        auth,
-        config,
-        discovery,
-        httpAuth,
-        httpRouter,
-        logger,
-        permissions
-      }) {
-        httpRouter.use(
-          await createRouter({
-            auth,
-            config,
-            discovery,
-            httpAuth,
-            logger,
-            permissions
-          })
-        );
-        httpRouter.addAuthPolicy({
-          path: "/health",
-          allow: "unauthenticated"
-        });
-      }
-    });
-  }
-});
-
-exports.createMendProjectConditionalDecision = createMendProjectConditionalDecision;
-exports.createRouter = createRouter;
-exports.default = mendPlugin;
-exports.mendConditions = mendConditions;
-exports.mendReadPermission = mendReadPermission;
+exports.createRouter = router.createRouter;
+exports.default = plugin.mendPlugin;
+exports.RESOURCE_TYPE = permissions.RESOURCE_TYPE;
+exports.mendReadPermission = permissions.mendReadPermission;
+exports.createMendProjectConditionalDecision = conditions.createMendProjectConditionalDecision;
+exports.mendConditions = conditions.mendConditions;
 //# sourceMappingURL=index.cjs.js.map