@axis-backstage/plugin-jira-dashboard-backend 4.3.0 → 4.4.0

package/dist/index.cjs.js

@@ -2,747 +2,16 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var backendPluginApi = require('@backstage/backend-plugin-api');
-var express = require('express');
-var Router = require('express-promise-router');
-var stream = require('stream');
-var rootHttpRouter = require('@backstage/backend-defaults/rootHttpRouter');
-var cache = require('@backstage/backend-defaults/cache');
-var catalogModel = require('@backstage/catalog-model');
-var catalogClient = require('@backstage/catalog-client');
-var pluginJiraDashboardCommon = require('@axis-backstage/plugin-jira-dashboard-common');
-var fetch = require('node-fetch');
-var errors = require('@backstage/errors');
+var plugin = require('./plugin.cjs.js');
+var api = require('./api.cjs.js');
+var config = require('./config.cjs.js');
+var queries = require('./queries.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 stream__default = /*#__PURE__*/_interopDefaultCompat(stream);
-var fetch__default = /*#__PURE__*/_interopDefaultCompat(fetch);
 
-const getAnnotations = (config) => {
-  const prefix = config.annotationPrefix;
-  const projectKeyAnnotation = `${prefix}/${pluginJiraDashboardCommon.PROJECT_KEY_NAME}`;
-  const componentsAnnotation = `${prefix}/${pluginJiraDashboardCommon.COMPONENTS_NAME}`;
-  const filtersAnnotation = `${prefix}/${pluginJiraDashboardCommon.FILTERS_NAME}`;
-  const incomingIssuesAnnotation = `${prefix}/${pluginJiraDashboardCommon.INCOMING_ISSUES_STATUS}`;
-  const componentRoadieAnnotation = `${prefix}/component`;
-  return {
-    projectKeyAnnotation,
-    componentsAnnotation,
-    filtersAnnotation,
-    incomingIssuesAnnotation,
-    componentRoadieAnnotation
-  };
-};
-function splitProjectKey(config, fullProjectKey) {
-  const [instance, projectKey] = fullProjectKey.split("/");
-  if (!projectKey) {
-    return {
-      instance: config.getInstance(),
-      fullProjectKey,
-      projectKey: instance
-    };
-  }
-  return {
-    instance: config.getInstance(instance),
-    fullProjectKey,
-    projectKey
-  };
-}
-
-const jqlQueryBuilder = ({
-  project,
-  components,
-  query
-}) => {
-  const projectList = Array.isArray(project) ? project : [project];
-  let jql = `project in (${projectList.join(",")})`;
-  if (components && components.length > 0) {
-    let componentsInclude = "(";
-    for (let index = 0; index < components.length; index++) {
-      const component = components[index];
-      componentsInclude += `'${component}'`;
-      if (index === components.length - 1) {
-        componentsInclude += ")";
-      } else {
-        componentsInclude += ",";
-      }
-    }
-    jql += ` AND component in ${componentsInclude}`;
-  }
-  if (query) {
-    jql += ` AND ${query}`;
-  }
-  return jql;
-};
-
-const getProjectInfo = async (project) => {
-  const { projectKey, instance } = project;
-  const response = await callApi(
-    instance,
-    `${instance.baseUrl}project/${projectKey}`,
-    {
-      method: "GET",
-      headers: {
-        Accept: "application/json"
-      }
-    }
-  );
-  if (response.status !== 200) {
-    throw Error(
-      `Request failed with status code ${response.status}: ${response.statusText}`
-    );
-  }
-  return response.json();
-};
-const getFilterById = async (id, instance) => {
-  const response = await callApi(instance, `${instance.baseUrl}filter/${id}`, {
-    method: "GET",
-    headers: {
-      Accept: "application/json"
-    }
-  });
-  if (response.status !== 200) {
-    throw Error(`${response.status}`);
-  }
-  const jsonResponse = await response.json();
-  return { name: jsonResponse.name, query: jsonResponse.jql };
-};
-const getIssuesByFilter = async (projects, components, query) => {
-  const issues = [];
-  for (const project of projects) {
-    const { projectKey, instance } = project;
-    const jql = jqlQueryBuilder({ project: [projectKey], components, query });
-    const response = await callApi(
-      instance,
-      `${instance.baseUrl}search?jql=${jql}`,
-      {
-        method: "GET",
-        headers: {
-          Accept: "application/json"
-        }
-      }
-    ).then((resp) => resp.json()).catch(() => null);
-    if (response?.issues) {
-      issues.push(...response.issues);
-    }
-  }
-  return issues;
-};
-const searchJira = async (instance, jqlQuery, options) => {
-  const response = await callApi(instance, `${instance.baseUrl}search`, {
-    method: "POST",
-    body: JSON.stringify({ jql: jqlQuery, ...options }),
-    headers: {
-      Accept: "application/json",
-      "Content-Type": "application/json"
-    }
-  });
-  if (!response.ok) {
-    throw await errors.ResponseError.fromResponse(response);
-  }
-  const jsonResponse = await response.json();
-  return jsonResponse;
-};
-const getIssuesByComponent = async (projects, componentKeys) => {
-  if (projects.length === 0) {
-    return [];
-  }
-  const projectKeys = projects.map((project) => project.projectKey).join(",");
-  const components = componentKeys.split(",").map((component) => `'${component.trim()}'`).join(",");
-  const jql = `project in (${projectKeys}) AND component in (${components})`;
-  const { instance } = projects[0];
-  try {
-    const response = await callApi(
-      instance,
-      `${instance.baseUrl}search?jql=${jql}`,
-      {
-        method: "GET",
-        headers: {
-          Accept: "application/json"
-        }
-      }
-    ).then((resp) => resp.json());
-    if (!response.issues || response.issues.length === 0) {
-      return [];
-    }
-    return response.issues;
-  } catch (error) {
-    if (error.message.includes("does not exist for the field 'project'")) {
-      return [];
-    }
-    throw error;
-  }
-};
-async function getProjectAvatar(url, instance) {
-  return callApi(instance, url);
-}
-async function callApi(instance, url, init) {
-  const requestInit = init ?? { method: "GET" };
-  requestInit.headers = {
-    ...instance.headers,
-    Authorization: instance.token,
-    ...requestInit.headers
-  };
-  return fetch__default.default(url, requestInit);
-}
-
-const getProjectResponse = async (project, cache) => {
-  let projectResponse;
-  projectResponse = await cache.get(project.fullProjectKey);
-  if (projectResponse) {
-    return projectResponse;
-  }
-  try {
-    projectResponse = await getProjectInfo(project);
-    cache.set(project.fullProjectKey, projectResponse);
-  } catch (err) {
-    if (err.message !== 200) {
-      throw Error(
-        `Failed to get project info for project key ${project.fullProjectKey} with error: ${err.message}`
-      );
-    }
-  }
-  return projectResponse;
-};
-const getJqlResponse = async (jql, config, cache, searchOptions) => {
-  let issuesResponse;
-  const cacheKey = `${config.baseUrl} ${jql}`;
-  issuesResponse = await cache.get(cacheKey);
-  if (issuesResponse) {
-    return issuesResponse;
-  }
-  try {
-    issuesResponse = (await searchJira(config, jql, searchOptions)).issues;
-    cache.set(cacheKey, issuesResponse);
-  } catch (err) {
-    if (err.message !== 200) {
-      throw Error(
-        `Failed to get issues for JQL ${jql} with error: ${err.message}`
-      );
-    }
-  }
-  return issuesResponse;
-};
-const getUserIssues = async (username, maxResults, config, cache, filterName) => {
-  let jql = `assignee = "${username}" AND resolution = Unresolved ORDER BY priority DESC, updated DESC`;
-  if (filterName !== "default") {
-    for (const filter of config.defaultFilters || []) {
-      if (filterName === filter.name) {
-        jql = `assignee = "${username}" AND ${filter.query}`;
-      }
-    }
-  }
-  return getJqlResponse(jql, config, cache, {
-    fields: [
-      "key",
-      "issuetype",
-      "summary",
-      "status",
-      "priority",
-      "created",
-      "updated"
-    ],
-    maxResults
-  });
-};
-const getFiltersFromAnnotations = async (annotations, config) => {
-  const filters = [];
-  for (const filter of annotations) {
-    try {
-      const response = await getFilterById(filter, config);
-      filters.push(response);
-    } catch (err) {
-      console.warn(
-        `${err.message} : Could not find filter with filter id ${filter}`
-      );
-    }
-  }
-  return filters;
-};
-async function getJiraProjectsFromKeys(projectKeys, instance, cache) {
-  const jiraProjects = [];
-  for (const key of projectKeys) {
-    const cachedProject = await cache.get(key);
-    let projectInfo;
-    if (cachedProject) {
-      projectInfo = cachedProject;
-    } else {
-      projectInfo = await getProjectInfo({
-        projectKey: key,
-        instance,
-        fullProjectKey: ""
-      });
-      cache.set(key, projectInfo);
-    }
-    jiraProjects.push({
-      instance,
-      fullProjectKey: projectInfo.key,
-      projectKey: projectInfo.key
-    });
-  }
-  return jiraProjects;
-}
-const getIssuesFromFilters = async (projectKeys, components, filters, instance, cache) => {
-  const projects = await getJiraProjectsFromKeys(projectKeys, instance, cache);
-  return await Promise.all(
-    filters.map(async (filter) => ({
-      name: filter.name,
-      query: jqlQueryBuilder({
-        project: projectKeys,
-        components,
-        query: filter.query
-      }),
-      type: "filter",
-      issues: await getIssuesByFilter(projects, components, filter.query)
-    }))
-  );
-};
-const getIssuesFromComponents = async (projectKeys, componentAnnotations, instance, cache) => {
-  const projects = await getJiraProjectsFromKeys(projectKeys, instance, cache);
-  return await Promise.all(
-    componentAnnotations.map(async (componentKey) => ({
-      name: componentKey,
-      query: jqlQueryBuilder({
-        project: projectKeys,
-        components: [componentKey]
-      }),
-      type: "component",
-      issues: await getIssuesByComponent(projects, componentKey)
-    }))
-  );
-};
-
-const DEFAULT_TTL = 1e3 * 60;
-const DEFAULT_MAX_RESULTS_USER_ISSUES = 10;
-
-const openFilter = {
-  name: "Open Issues",
-  shortName: "OPEN",
-  query: "resolution = Unresolved ORDER BY updated DESC"
-};
-const getIncomingFilter = (incomingStatus) => ({
-  name: "Incoming Issues",
-  shortName: "INCOMING",
-  query: `status = '${incomingStatus}' ORDER BY created ASC`
-});
-const getAssigneUser = (instance, userEntity) => {
-  const emailSuffixConfig = instance.userEmailSuffix;
-  return emailSuffixConfig ? `${userEntity.metadata.name}${emailSuffixConfig}` : userEntity.spec?.profile?.email || userEntity.metadata.name;
-};
-const getAssignedToMeFilter = (userEntity, instance) => {
-  const email = getAssigneUser(instance, userEntity);
-  return {
-    name: "Assigned to me",
-    shortName: "ME",
-    query: `assignee = "${email}" AND resolution = Unresolved ORDER BY updated DESC`
-  };
-};
-const getDefaultFiltersForUser = (instance, userEntity, incomingStatus) => {
-  const incomingFilter = getIncomingFilter(incomingStatus ?? "New");
-  const defaultFilters = instance.defaultFilters?.map((filter) => ({
-    name: filter.name,
-    query: filter.query,
-    shortName: filter.shortName
-  })) || [];
-  if (!userEntity) return [openFilter, incomingFilter, ...defaultFilters];
-  const assigneeToMeFilter = getAssignedToMeFilter(userEntity, instance);
-  return [openFilter, incomingFilter, assigneeToMeFilter, ...defaultFilters];
-};
-
-async function createRouter(options) {
-  const { auth, logger, rootConfig, config, discovery, httpAuth, userInfo } = options;
-  const catalogClient$1 = new catalogClient.CatalogClient({ discoveryApi: discovery });
-  const pluginCache = cache.CacheManager.fromConfig(rootConfig).forPlugin("jira-dashboard");
-  const cache$1 = pluginCache.getClient({ defaultTtl: DEFAULT_TTL });
-  logger.info("Initializing Jira Dashboard backend");
-  const router = Router__default.default();
-  router.use(express__default.default.json());
-  router.get("/health", (_, response) => {
-    logger.info("PONG!");
-    response.json({ status: "ok" });
-  });
-  router.get(
-    "/dashboards/by-entity-ref/:kind/:namespace/:name",
-    async (request, response) => {
-      const { kind, namespace, name } = request.params;
-      const entityRef = catalogModel.stringifyEntityRef({ kind, namespace, name });
-      const { token } = await auth.getPluginRequestToken({
-        onBehalfOf: await auth.getOwnServiceCredentials(),
-        targetPluginId: "catalog"
-      });
-      const entity = await catalogClient$1.getEntityByRef(entityRef, { token });
-      const {
-        projectKeyAnnotation,
-        componentsAnnotation,
-        filtersAnnotation,
-        incomingIssuesAnnotation,
-        componentRoadieAnnotation
-      } = getAnnotations(config);
-      if (!entity) {
-        logger.info(`No entity found for ${entityRef}`);
-        response.status(500).json({ error: `No entity found for ${entityRef}` });
-        return;
-      }
-      const fullProjectKeys = entity.metadata.annotations?.[projectKeyAnnotation]?.split(",");
-      if (!fullProjectKeys) {
-        const error = `No jira.com/project-key annotation found for ${entityRef}`;
-        logger.info(error);
-        response.status(404).json(error);
-        return;
-      }
-      const projects = fullProjectKeys.map(
-        (fullProjectKey) => splitProjectKey(config, fullProjectKey)
-      );
-      let projectResponse;
-      try {
-        projectResponse = await getProjectResponse(projects[0], cache$1);
-      } catch (err) {
-        logger.error(
-          `Could not find Jira project ${projects[0].fullProjectKey}: ${err.message}`
-        );
-        response.status(404).json({
-          error: `No Jira project found with key ${projects[0].projectKey}`
-        });
-        return;
-      }
-      let userEntity;
-      try {
-        const credentials = await httpAuth.credentials(request, {
-          allow: ["user"]
-        });
-        const userIdentity = credentials.principal.userEntityRef;
-        userEntity = await catalogClient$1.getEntityByRef(userIdentity, {
-          token
-        });
-      } catch (err) {
-        logger.warn("Could not find user identity");
-      }
-      let filters = [];
-      const incomingStatus = entity.metadata.annotations?.[incomingIssuesAnnotation];
-      filters = getDefaultFiltersForUser(
-        projects[0].instance,
-        userEntity,
-        incomingStatus
-      );
-      const customFilterAnnotations = entity.metadata.annotations?.[filtersAnnotation]?.split(",");
-      if (customFilterAnnotations) {
-        filters.push(
-          ...await getFiltersFromAnnotations(
-            customFilterAnnotations,
-            projects[0].instance
-          )
-        );
-      }
-      const instance = projects[0]?.instance;
-      let components = entity.metadata.annotations?.[componentsAnnotation]?.split(",") ?? [];
-      const projectKeys = projects.map((project) => project.projectKey);
-      let issues = await getIssuesFromFilters(
-        projectKeys,
-        components,
-        filters,
-        instance,
-        cache$1
-      );
-      components = components.concat(
-        entity.metadata.annotations?.[componentRoadieAnnotation]?.split(",") ?? []
-      );
-      if (components.length > 0) {
-        const componentIssues = await getIssuesFromComponents(
-          projectKeys,
-          components,
-          instance,
-          cache$1
-        );
-        issues = issues.concat(componentIssues);
-      }
-      const jiraResponse = {
-        project: projectResponse,
-        data: issues
-      };
-      response.json(jiraResponse);
-    }
-  );
-  router.get("/dashboards/user-issues", async (request, response) => {
-    const { token } = await auth.getPluginRequestToken({
-      onBehalfOf: await auth.getOwnServiceCredentials(),
-      targetPluginId: "catalog"
-    });
-    const credentials = await httpAuth.credentials(request, {
-      allow: ["user"]
-    });
-    if (!auth.isPrincipal(credentials, "user")) {
-      response.status(200).json([]);
-      return;
-    }
-    const info = await userInfo.getUserInfo(credentials);
-    const userEntity = await catalogClient$1.getEntityByRef(info.userEntityRef, {
-      token
-    });
-    if (!userEntity) {
-      const error = `User entity cannot be determined from ${info.userEntityRef}`;
-      logger.info(error);
-      response.status(400).json(error);
-      return;
-    }
-    const getUserIssuesForInstance = async (instance) => {
-      const username = getAssigneUser(instance, userEntity);
-      const maxResults = Number(
-        request.query.maxResults || DEFAULT_MAX_RESULTS_USER_ISSUES
-      );
-      const filterName = request.query?.filterName || "default";
-      try {
-        const issues2 = await getUserIssues(
-          username,
-          maxResults,
-          instance,
-          cache$1,
-          filterName
-        );
-        return { issues: issues2, error: void 0 };
-      } catch (error) {
-        return { error };
-      }
-    };
-    const issuesList = await Promise.all(
-      config.getInstances().map(
-        (instanceName) => getUserIssuesForInstance(config.getInstance(instanceName))
-      )
-    );
-    const issues = issuesList.flatMap((list) => list.issues ?? []);
-    const errors = issuesList.flatMap((list) => list.error).filter((v) => !!v);
-    if (issues.length > 0 || errors.length === 0) {
-      response.status(200).json(issues);
-    } else {
-      const messages = errors.length > 1 ? `
-  ${errors.map((err) => err.message).join("\n  ")}` : ` ${errors[0].message}`;
-      logger.error(`Error during getting user issues:${messages}`);
-      response.status(503).json({
-        error: `Error during getting user issues:${messages}`
-      });
-    }
-  });
-  router.get(
-    "/avatar/by-entity-ref/:kind/:namespace/:name",
-    async (request, response) => {
-      const { kind, namespace, name } = request.params;
-      const entityRef = catalogModel.stringifyEntityRef({ kind, namespace, name });
-      const { token } = await auth.getPluginRequestToken({
-        onBehalfOf: await auth.getOwnServiceCredentials(),
-        targetPluginId: "catalog"
-      });
-      const entity = await catalogClient$1.getEntityByRef(entityRef, { token });
-      const { projectKeyAnnotation } = getAnnotations(config);
-      if (!entity) {
-        logger.info(`No entity found for ${entityRef}`);
-        response.status(500).json({ error: `No entity found for ${entityRef}` });
-        return;
-      }
-      const fullProjectKeys = entity.metadata.annotations?.[projectKeyAnnotation]?.split(",");
-      if (!fullProjectKeys) {
-        const error = `No jira.com/project-key annotation found for ${entityRef}`;
-        logger.info(error);
-        response.status(404).json(error);
-        return;
-      }
-      const projects = fullProjectKeys.map(
-        (fullProjectKey) => splitProjectKey(config, fullProjectKey)
-      );
-      const projectResponse = await getProjectResponse(projects[0], cache$1);
-      if (!projectResponse) {
-        logger.error("Could not find project in Jira");
-        response.status(400).json({
-          error: `No Jira project found for project key ${projects[0].projectKey}`
-        });
-        return;
-      }
-      const url = projectResponse.avatarUrls["48x48"];
-      const avatar = await getProjectAvatar(url, projects[0].instance);
-      const ps = new stream__default.default.PassThrough();
-      const val = avatar.headers.get("content-type");
-      response.setHeader("content-type", val ?? "");
-      stream__default.default.pipeline(avatar.body, ps, (err) => {
-        if (err) {
-          logger.error(`${err}`);
-          response.sendStatus(400);
-        }
-        return;
-      });
-      ps.pipe(response);
-    }
-  );
-  const middleware = rootHttpRouter.MiddlewareFactory.create({ logger, config: rootConfig });
-  router.use(middleware.error());
-  return router;
-}
-
-function parseHeaders(config) {
-  if (!config) {
-    return {};
-  }
-  return Object.fromEntries(
-    config.keys().map((key) => {
-      const value = config.getString(key);
-      return [key, value];
-    })
-  );
-}
-const JIRA_CONFIG_BASE_URL = "baseUrl";
-const JIRA_CONFIG_TOKEN = "token";
-const JIRA_CONFIG_HEADERS = "headers";
-const JIRA_CONFIG_USER_EMAIL_SUFFIX = "userEmailSuffix";
-const JIRA_CONFIG_ANNOTATION = "annotationPrefix";
-const JIRA_FILTERS = "defaultFilters";
-class JiraConfig {
-  instances = {};
-  /**
-   * The annotation prefix to use for Jira annotations
-   */
-  annotationPrefix;
-  constructor(config) {
-    const jira = config.getConfig("jiraDashboard");
-    this.annotationPrefix = jira.getOptionalString(JIRA_CONFIG_ANNOTATION) ?? "jira.com";
-    const instances = jira.getOptionalConfigArray("instances");
-    if (instances) {
-      instances.forEach((inst) => {
-        const name = inst.getString("name");
-        if (Object.getOwnPropertyNames(this.instances).includes(name)) {
-          throw new errors.ConflictError(
-            `Duplicate jiraDashboard instances: '${name}'`
-          );
-        }
-        this.instances[name] = {
-          token: inst.getString(JIRA_CONFIG_TOKEN),
-          headers: parseHeaders(inst.getOptionalConfig(JIRA_CONFIG_HEADERS)),
-          baseUrl: inst.getString(JIRA_CONFIG_BASE_URL),
-          userEmailSuffix: inst.getOptionalString(
-            JIRA_CONFIG_USER_EMAIL_SUFFIX
-          ),
-          defaultFilters: inst.getOptionalConfigArray(JIRA_FILTERS)?.map((filterConfig) => ({
-            name: filterConfig.getString("name"),
-            shortName: filterConfig.getString("shortName"),
-            query: filterConfig.getString("query")
-          }))
-        };
-      });
-    } else {
-      this.instances.default = {
-        token: jira.getString(JIRA_CONFIG_TOKEN),
-        headers: parseHeaders(jira.getOptionalConfig(JIRA_CONFIG_HEADERS)),
-        baseUrl: jira.getString(JIRA_CONFIG_BASE_URL),
-        userEmailSuffix: jira.getOptionalString(JIRA_CONFIG_USER_EMAIL_SUFFIX),
-        defaultFilters: jira.getOptionalConfigArray(JIRA_FILTERS)?.map((filterConfig) => ({
-          name: filterConfig.getString("name"),
-          shortName: filterConfig.getString("shortName"),
-          query: filterConfig.getString("query")
-        }))
-      };
-    }
-  }
-  /**
-   * Create a JiraConfig from the root config
-   */
-  static fromConfig(config) {
-    return new JiraConfig(config);
-  }
-  forInstance(instanceName) {
-    const instance = this.instances[instanceName];
-    if (!instance) {
-      throw new errors.ServiceUnavailableError(
-        `No such jira instance '${instanceName}'`
-      );
-    }
-    return instance;
-  }
-  /**
-   * Returns the configuration all instances
-   */
-  getInstances() {
-    return Object.getOwnPropertyNames(this.instances);
-  }
-  /**
-   * Get the jira config for a specific instance
-   */
-  getInstance(instanceName) {
-    return this.forInstance(instanceName ?? "default");
-  }
-  /**
-   * Get the jira base url for a given instance
-   */
-  resolveJiraBaseUrl(instanceName) {
-    const instance = this.forInstance(instanceName);
-    return instance.baseUrl;
-  }
-  /**
-   * Get the auth token for a given instance
-   */
-  resolveJiraToken(instanceName) {
-    const instance = this.forInstance(instanceName);
-    return instance.token;
-  }
-  /**
-   * Get the email suffice for a given instance
-   */
-  resolveUserEmailSuffix(instanceName) {
-    const instance = this.forInstance(instanceName);
-    return instance.userEmailSuffix;
-  }
-  /**
-   * Get the defined default filters for a given instance
-   */
-  resolveDefaultFilters(instanceName) {
-    const instance = this.forInstance(instanceName);
-    return instance.defaultFilters;
-  }
-}
-
-const jiraDashboardPlugin = backendPluginApi.createBackendPlugin({
-  pluginId: "jira-dashboard",
-  register(env) {
-    env.registerInit({
-      deps: {
-        auth: backendPluginApi.coreServices.auth,
-        httpRouter: backendPluginApi.coreServices.httpRouter,
-        logger: backendPluginApi.coreServices.logger,
-        rootConfig: backendPluginApi.coreServices.rootConfig,
-        discovery: backendPluginApi.coreServices.discovery,
-        httpAuth: backendPluginApi.coreServices.httpAuth,
-        userInfo: backendPluginApi.coreServices.userInfo
-      },
-      async init({
-        auth,
-        httpRouter,
-        logger,
-        rootConfig,
-        discovery,
-        httpAuth,
-        userInfo
-      }) {
-        httpRouter.use(
-          await createRouter({
-            auth,
-            logger,
-            rootConfig,
-            config: JiraConfig.fromConfig(rootConfig),
-            discovery,
-            httpAuth,
-            userInfo
-          })
-        );
-        httpRouter.addAuthPolicy({
-          path: "/health",
-          allow: "unauthenticated"
-        });
-      }
-    });
-  }
-});
-
-exports.JiraConfig = JiraConfig;
-exports.callApi = callApi;
-exports.default = jiraDashboardPlugin;
-exports.jqlQueryBuilder = jqlQueryBuilder;
-exports.searchJira = searchJira;
+exports.default = plugin.jiraDashboardPlugin;
+exports.callApi = api.callApi;
+exports.searchJira = api.searchJira;
+exports.JiraConfig = config.JiraConfig;
+exports.jqlQueryBuilder = queries.jqlQueryBuilder;
 //# sourceMappingURL=index.cjs.js.map