@backstage-community/plugin-code-coverage-backend 0.3.1 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @backstage-community/plugin-code-coverage-backend
 
+## 0.3.2
+
+### Patch Changes
+
+- f5b0d2a: Backstage version bump to v1.32.2
+
 ## 0.3.1
 
 ### Patch Changes

package/dist/index.cjs.js

@@ -2,647 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var express = require('express');
-var Router = require('express-promise-router');
-var BodyParser = require('body-parser');
-var bodyParserXml = require('body-parser-xml');
-var catalogClient = require('@backstage/catalog-client');
-var backendCommon = require('@backstage/backend-common');
-var errors = require('@backstage/errors');
-var integration = require('@backstage/integration');
-var catalogModel = require('@backstage/catalog-model');
-var uuid = require('uuid');
-var rootHttpRouter = require('@backstage/backend-defaults/rootHttpRouter');
-var backendPluginApi = require('@backstage/backend-plugin-api');
+var router = require('./service/router.cjs.js');
+var plugin = require('./plugin.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 BodyParser__default = /*#__PURE__*/_interopDefaultCompat(BodyParser);
-var bodyParserXml__default = /*#__PURE__*/_interopDefaultCompat(bodyParserXml);
 
-const calculatePercentage = (available, covered) => {
-  if (available === 0) {
-    return 0;
-  }
-  return parseFloat((covered / available * 100).toFixed(2));
-};
-const aggregateCoverage = (c) => {
-  let availableLine = 0;
-  let coveredLine = 0;
-  let availableBranch = 0;
-  let coveredBranch = 0;
-  c.files.forEach((f) => {
-    availableLine += Object.keys(f.lineHits).length;
-    coveredLine += Object.values(f.lineHits).filter((l) => l > 0).length;
-    availableBranch += Object.keys(f.branchHits).map((b) => parseInt(b, 10)).map((b) => f.branchHits[b].available).filter(Boolean).reduce((acc, curr) => acc + curr, 0);
-    coveredBranch += Object.keys(f.branchHits).map((b) => parseInt(b, 10)).map((b) => f.branchHits[b].covered).filter(Boolean).reduce((acc, curr) => acc + curr, 0);
-  });
-  return {
-    timestamp: c.metadata.generationTime,
-    branch: {
-      available: availableBranch,
-      covered: coveredBranch,
-      missed: availableBranch - coveredBranch,
-      percentage: calculatePercentage(availableBranch, coveredBranch)
-    },
-    line: {
-      available: availableLine,
-      covered: coveredLine,
-      missed: availableLine - coveredLine,
-      percentage: calculatePercentage(availableLine, coveredLine)
-    }
-  };
-};
-class CoverageUtils {
-  constructor(scm, urlReader) {
-    this.scm = scm;
-    this.urlReader = urlReader;
-  }
-  async processCoveragePayload(entity, req) {
-    const enforceScmFiles = entity.metadata.annotations?.["backstage.io/code-coverage"] === "scm-only" || false;
-    let sourceLocation = void 0;
-    let vcs = void 0;
-    let scmFiles = [];
-    if (enforceScmFiles) {
-      try {
-        const sl = catalogModel.getEntitySourceLocation(entity);
-        sourceLocation = sl.target;
-      } catch (e) {
-      }
-      if (!sourceLocation) {
-        throw new errors.InputError(
-          `No "backstage.io/source-location" annotation on entity ${catalogModel.stringifyEntityRef(
-            entity
-          )}`
-        );
-      }
-      vcs = this.scm.byUrl?.(sourceLocation);
-      if (!vcs) {
-        throw new errors.InputError(`Unable to determine SCM from ${sourceLocation}`);
-      }
-      const scmTree = await this.urlReader.readTree?.(sourceLocation);
-      if (!scmTree) {
-        throw new errors.NotFoundError(`Unable to read tree from ${sourceLocation}`);
-      }
-      scmFiles = (await scmTree.files()).map((f) => f.path);
-    }
-    const body = this.validateRequestBody(req);
-    if (Object.keys(body).length === 0) {
-      throw new errors.InputError("Unable to parse body");
-    }
-    return {
-      sourceLocation,
-      vcs,
-      scmFiles,
-      body
-    };
-  }
-  async buildCoverage(entity, sourceLocation, vcs, files) {
-    return {
-      metadata: {
-        vcs: {
-          type: vcs?.type || "unknown",
-          location: sourceLocation || "unknown"
-        },
-        generationTime: Date.now()
-      },
-      entity: {
-        name: entity.metadata.name,
-        namespace: entity.metadata.namespace || "default",
-        kind: entity.kind
-      },
-      files
-    };
-  }
-  validateRequestBody(req) {
-    const contentType = req.headers["content-type"];
-    if (!contentType) {
-      throw new errors.InputError("Content-Type header missing");
-    } else if (!contentType.match(/^text\/xml|plain($|;)/)) {
-      throw new errors.InputError(
-        `Content-Type header "${contentType}" not supported, expected "text/xml" or "text/plain" possibly followed by a charset`
-      );
-    }
-    const body = req.body;
-    if (!body) {
-      throw new errors.InputError("Missing request body");
-    }
-    return body;
-  }
-}
-
-const migrationsDir = backendCommon.resolvePackagePath(
-  "@backstage-community/plugin-code-coverage-backend",
-  "migrations"
-);
-class CodeCoverageDatabase {
-  constructor(db) {
-    this.db = db;
-  }
-  static async create(database) {
-    const knex = await database.getClient();
-    if (!database.migrations?.skip) {
-      await knex.migrate.latest({
-        directory: migrationsDir
-      });
-    }
-    return new CodeCoverageDatabase(knex);
-  }
-  async insertCodeCoverage(coverage) {
-    const codeCoverageId = uuid.v4();
-    const entity = catalogModel.stringifyEntityRef({
-      kind: coverage.entity.kind,
-      namespace: coverage.entity.namespace,
-      name: coverage.entity.name
-    });
-    await this.db("code_coverage").insert({
-      id: codeCoverageId,
-      entity,
-      coverage: JSON.stringify(coverage)
-    });
-    return { codeCoverageId };
-  }
-  async getCodeCoverage(entity) {
-    const [result] = await this.db("code_coverage").where({ entity }).orderBy("index", "desc").limit(1).select();
-    if (!result) {
-      throw new errors.NotFoundError(
-        `No coverage for entity '${JSON.stringify(entity)}' found`
-      );
-    }
-    try {
-      return JSON.parse(result.coverage);
-    } catch (error) {
-      throw new Error(`Failed to parse coverage for '${entity}', ${error}`);
-    }
-  }
-  async getHistory(entity, limit) {
-    const res = await this.db("code_coverage").where({ entity }).orderBy("index", "desc").limit(limit).select();
-    const history = res.map((r) => JSON.parse(r.coverage)).map((c) => aggregateCoverage(c));
-    const entityName = catalogModel.parseEntityRef(entity);
-    return {
-      entity: {
-        name: entityName.name,
-        kind: entityName.kind,
-        namespace: entityName.namespace
-      },
-      history
-    };
-  }
-}
-
-class Cobertura {
-  constructor(logger) {
-    this.logger = logger;
-    this.logger = logger;
-  }
-  /**
-   * convert cobertura into shared json coverage format
-   *
-   * @param xml - cobertura xml object
-   * @param scmFiles - list of files that are committed to SCM
-   */
-  convert(xml, scmFiles) {
-    const ppc = xml.coverage.packages?.flatMap((p) => p.package).filter(Boolean).flatMap((p) => p.classes);
-    const pc = xml.coverage.package?.filter(Boolean).flatMap((p) => p.classes);
-    const classes = [ppc, pc].flat().filter(Boolean).flatMap((c) => c.class).filter(Boolean);
-    const jscov = [];
-    classes.forEach((c) => {
-      const packageAndFilename = c.$.filename;
-      const lines = this.extractLines(c);
-      const lineHits = {};
-      const branchHits = {};
-      lines.forEach((l) => {
-        if (!lineHits[l.number]) {
-          lineHits[l.number] = 0;
-        }
-        lineHits[l.number] += l.hits;
-        if (l.branch && l["condition-coverage"]) {
-          const bh = this.parseBranch(l["condition-coverage"]);
-          if (bh) {
-            branchHits[l.number] = bh;
-          }
-        }
-      });
-      const currentFile = scmFiles.map((f) => f.trimEnd()).find((f) => f.endsWith(packageAndFilename));
-      this.logger.debug(`matched ${packageAndFilename} to ${currentFile}`);
-      if (scmFiles.length === 0 || Object.keys(lineHits).length > 0 && currentFile) {
-        jscov.push({
-          filename: currentFile || packageAndFilename,
-          branchHits,
-          lineHits
-        });
-      }
-    });
-    return jscov;
-  }
-  /**
-   * Parses branch coverage information from condition-coverage
-   *
-   * @param condition - condition-coverage value from line coverage
-   */
-  parseBranch(condition) {
-    const pattern = /[0-9\.]+\%\s\(([0-9]+)\/([0-9]+)\)/;
-    const match = condition.match(pattern);
-    if (!match) {
-      return null;
-    }
-    const covered = parseInt(match[1], 10);
-    const available = parseInt(match[2], 10);
-    return {
-      covered,
-      missed: available - covered,
-      available
-    };
-  }
-  /**
-   * Extract line hits from a class coverage entry
-   *
-   * @param clz - class coverage information
-   */
-  extractLines(clz) {
-    const classLines = clz.lines.flatMap((l) => l.line);
-    const methodLines = clz.methods?.flatMap((m) => m.method).filter(Boolean).flatMap((m) => m.lines).filter(Boolean).flatMap((l) => l.line).filter(
-      ({ $: methodLine }) => classLines.some(
-        ({ $: classLine }) => methodLine.number === classLine.number
-      ) === false
-    );
-    const lines = [classLines, methodLines].flat().filter(Boolean);
-    const lineHits = lines.map((l) => {
-      return {
-        number: parseInt(l.$.number, 10),
-        hits: parseInt(l.$.hits, 10),
-        "condition-coverage": l.$["condition-coverage"],
-        branch: l.$.branch
-      };
-    });
-    return lineHits;
-  }
-}
-
-class Jacoco {
-  constructor(logger) {
-    this.logger = logger;
-    this.logger = logger;
-  }
-  /**
-   * Converts jacoco into shared json coverage format
-   *
-   * @param xml - jacoco xml object
-   * @param scmFiles - list of files that are committed to SCM
-   */
-  convert(xml, scmFiles) {
-    const jscov = [];
-    xml.report.package.forEach((r) => {
-      const packageName = r.$.name;
-      r.sourcefile.forEach((sf) => {
-        const fileName = sf.$.name;
-        const lines = this.extractLines(sf);
-        const lineHits = {};
-        const branchHits = {};
-        lines.forEach((l) => {
-          if (!lineHits[l.number]) {
-            lineHits[l.number] = 0;
-          }
-          lineHits[l.number] += l.covered_instructions;
-          const ab = l.covered_branches + l.missed_branches;
-          if (ab > 0) {
-            branchHits[l.number] = {
-              covered: l.covered_branches,
-              missed: l.missed_branches,
-              available: ab
-            };
-          }
-        });
-        const packageAndFilename = `${packageName}/${fileName}`;
-        const currentFile = scmFiles.map((f) => f.trimEnd()).find((f) => f.endsWith(packageAndFilename));
-        this.logger.debug(`matched ${packageAndFilename} to ${currentFile}`);
-        if (scmFiles.length === 0 || Object.keys(lineHits).length > 0 && currentFile) {
-          jscov.push({
-            filename: currentFile || packageAndFilename,
-            branchHits,
-            lineHits
-          });
-        }
-      });
-    });
-    return jscov;
-  }
-  extractLines(sourcefile) {
-    const parsed = [];
-    sourcefile.line?.forEach((l) => {
-      parsed.push({
-        number: parseInt(l.$.nr, 10),
-        missed_instructions: parseInt(l.$.mi, 10),
-        covered_instructions: parseInt(l.$.ci, 10),
-        missed_branches: parseInt(l.$.mb, 10),
-        covered_branches: parseInt(l.$.cb, 10)
-      });
-    });
-    return parsed;
-  }
-}
-
-class Lcov {
-  constructor(logger) {
-    this.logger = logger;
-    this.logger = logger;
-  }
-  /**
-   * convert lcov into shared json coverage format
-   *
-   * @param raw - raw lcov report
-   * @param scmFiles - list of files that are committed to SCM
-   */
-  convert(raw, scmFiles) {
-    const lines = raw.split(/\r?\n/);
-    const jscov = [];
-    let currentFile = null;
-    lines.forEach((line) => {
-      const [section, value] = line.split(":");
-      switch (section) {
-        // If the line starts with SF, it's a new file
-        case "SF":
-          currentFile = this.processNewFile(value, scmFiles);
-          break;
-        // If the line starts with DA, it's a line hit
-        case "DA":
-          this.processLineHit(currentFile, value);
-          break;
-        // If the line starts with BRDA, it's a branch line
-        case "BRDA":
-          this.processBranchHit(currentFile, value);
-          break;
-        // If the line starts with end_of_record, it's the end of current file
-        case "end_of_record":
-          if (currentFile) {
-            jscov.push(currentFile);
-            currentFile = null;
-          }
-          break;
-      }
-    });
-    return jscov;
-  }
-  /**
-   * Parses a new file entry
-   *
-   * @param file - file name from coverage report
-   * @param scmFiles - list of files that are committed to SCM
-   */
-  processNewFile(file, scmFiles) {
-    const filename = scmFiles.map((f) => f.trimEnd()).find((f) => file.endsWith(f));
-    this.logger.debug(`matched ${file} to ${filename}`);
-    if (scmFiles.length === 0 || filename) {
-      return {
-        filename: filename || file,
-        lineHits: {},
-        branchHits: {}
-      };
-    }
-    return null;
-  }
-  /**
-   * Parses line coverage information
-   *
-   * @param currentFile - current file entry
-   * @param value - line coverage information
-   */
-  processLineHit(currentFile, value) {
-    if (!currentFile) return;
-    const [lineNumber, hits] = value.split(",");
-    currentFile.lineHits[Number(lineNumber)] = Number(hits);
-  }
-  /**
-   * Parses branch coverage information
-   *
-   * @param currentFile - current file entry
-   * @param value - branch coverage information
-   */
-  processBranchHit(currentFile, value) {
-    if (!currentFile) return;
-    const [lineNumber, , , hits] = value.split(",");
-    const lineNumberNum = Number(lineNumber);
-    const isHit = Number(hits) > 0;
-    const branch = currentFile.branchHits[lineNumberNum] || {
-      covered: 0,
-      available: 0,
-      missed: 0
-    };
-    branch.available++;
-    branch.covered += isHit ? 1 : 0;
-    branch.missed += isHit ? 0 : 1;
-    currentFile.branchHits[lineNumberNum] = branch;
-  }
-}
-
-const makeRouter = async (options) => {
-  const { config, logger, discovery, database, urlReader } = options;
-  const codeCoverageDatabase = await CodeCoverageDatabase.create(database);
-  const codecovUrl = await discovery.getExternalBaseUrl("code-coverage");
-  const catalogApi = options.catalogApi ?? new catalogClient.CatalogClient({ discoveryApi: discovery });
-  const scm = integration.ScmIntegrations.fromConfig(config);
-  const { auth, httpAuth } = backendCommon.createLegacyAuthAdapters(options);
-  const bodySizeLimit = config.getOptionalString("codeCoverage.bodySizeLimit") ?? "100kb";
-  bodyParserXml__default.default(BodyParser__default.default);
-  const router = Router__default.default();
-  router.use(
-    BodyParser__default.default.xml({
-      limit: bodySizeLimit
-    })
-  );
-  router.use(
-    BodyParser__default.default.text({
-      limit: bodySizeLimit
-    })
-  );
-  router.use(express__default.default.json());
-  const utils = new CoverageUtils(scm, urlReader);
-  router.get("/health", async (_req, res) => {
-    res.status(200).json({ status: "ok" });
-  });
-  router.get("/report", async (req, res) => {
-    const { entity } = req.query;
-    const entityLookup = await catalogApi.getEntityByRef(
-      entity,
-      await auth.getPluginRequestToken({
-        onBehalfOf: await httpAuth.credentials(req),
-        targetPluginId: "catalog"
-      })
-    );
-    if (!entityLookup) {
-      throw new errors.NotFoundError(`No entity found matching ${entity}`);
-    }
-    const stored = await codeCoverageDatabase.getCodeCoverage(entity);
-    const aggregate = aggregateCoverage(stored);
-    res.status(200).json({
-      ...stored,
-      aggregate: {
-        line: aggregate.line,
-        branch: aggregate.branch
-      }
-    });
-  });
-  router.get("/history", async (req, res) => {
-    const { entity } = req.query;
-    const entityLookup = await catalogApi.getEntityByRef(
-      entity,
-      await auth.getPluginRequestToken({
-        onBehalfOf: await httpAuth.credentials(req),
-        targetPluginId: "catalog"
-      })
-    );
-    if (!entityLookup) {
-      throw new errors.NotFoundError(`No entity found matching ${entity}`);
-    }
-    const { limit } = req.query;
-    const history = await codeCoverageDatabase.getHistory(
-      entity,
-      parseInt(limit?.toString() || "10", 10)
-    );
-    res.status(200).json(history);
-  });
-  router.get("/file-content", async (req, res) => {
-    const { entity, path } = req.query;
-    const entityLookup = await catalogApi.getEntityByRef(
-      entity,
-      await auth.getPluginRequestToken({
-        onBehalfOf: await httpAuth.credentials(req),
-        targetPluginId: "catalog"
-      })
-    );
-    if (!entityLookup) {
-      throw new errors.NotFoundError(`No entity found matching ${entity}`);
-    }
-    if (!path) {
-      throw new errors.InputError("Need path query parameter");
-    }
-    const sourceLocation = catalogModel.getEntitySourceLocation(entityLookup);
-    if (!sourceLocation) {
-      throw new errors.InputError(
-        `No "backstage.io/source-location" annotation on entity ${entity}`
-      );
-    }
-    const vcs = scm.byUrl(sourceLocation.target);
-    if (!vcs) {
-      throw new errors.InputError(`Unable to determine SCM from ${sourceLocation}`);
-    }
-    const scmTree = await urlReader.readTree(sourceLocation.target);
-    const scmFile = (await scmTree.files()).find((f) => f.path === path);
-    if (!scmFile) {
-      res.status(404).json({
-        message: "Couldn't find file in SCM",
-        file: path,
-        scm: vcs.title
-      });
-      return;
-    }
-    const content = await scmFile?.content();
-    if (!content) {
-      res.status(400).json({
-        message: "Couldn't process content of file in SCM",
-        file: path,
-        scm: vcs.title
-      });
-      return;
-    }
-    const data = content.toString();
-    res.status(200).contentType("text/plain").send(data);
-  });
-  router.post("/report", async (req, res) => {
-    const { entity: entityRef, coverageType } = req.query;
-    const entity = await catalogApi.getEntityByRef(
-      entityRef,
-      await auth.getPluginRequestToken({
-        onBehalfOf: await httpAuth.credentials(req),
-        targetPluginId: "catalog"
-      })
-    );
-    if (!entity) {
-      throw new errors.NotFoundError(`No entity found matching ${entityRef}`);
-    }
-    let converter;
-    if (!coverageType) {
-      throw new errors.InputError("Need coverageType query parameter");
-    } else if (coverageType === "jacoco") {
-      converter = new Jacoco(logger);
-    } else if (coverageType === "cobertura") {
-      converter = new Cobertura(logger);
-    } else if (coverageType === "lcov") {
-      converter = new Lcov(logger);
-    } else {
-      throw new errors.InputError(`Unsupported coverage type '${coverageType}`);
-    }
-    const { sourceLocation, vcs, scmFiles, body } = await utils.processCoveragePayload(entity, req);
-    const files = converter.convert(body, scmFiles);
-    if (!files || files.length === 0) {
-      throw new errors.InputError(`Unable to parse body as ${coverageType}`);
-    }
-    const coverage = await utils.buildCoverage(
-      entity,
-      sourceLocation,
-      vcs,
-      files
-    );
-    await codeCoverageDatabase.insertCodeCoverage(coverage);
-    res.status(201).json({
-      links: [
-        {
-          rel: "coverage",
-          href: `${codecovUrl}/report?entity=${entityRef}`
-        }
-      ]
-    });
-  });
-  const middleware = rootHttpRouter.MiddlewareFactory.create({ logger, config });
-  router.use(middleware.error());
-  return router;
-};
-async function createRouter(options) {
-  const logger = options.logger;
-  logger.info("Initializing Code Coverage backend");
-  return makeRouter(options);
-}
-
-const codeCoveragePlugin = backendPluginApi.createBackendPlugin({
-  pluginId: "code-coverage",
-  register(env) {
-    env.registerInit({
-      deps: {
-        config: backendPluginApi.coreServices.rootConfig,
-        logger: backendPluginApi.coreServices.logger,
-        urlReader: backendPluginApi.coreServices.urlReader,
-        httpRouter: backendPluginApi.coreServices.httpRouter,
-        discovery: backendPluginApi.coreServices.discovery,
-        database: backendPluginApi.coreServices.database
-      },
-      async init({
-        config,
-        logger,
-        urlReader,
-        httpRouter,
-        discovery,
-        database
-      }) {
-        httpRouter.use(
-          await createRouter({
-            config,
-            logger,
-            urlReader,
-            discovery,
-            database
-          })
-        );
-        httpRouter.addAuthPolicy({
-          path: "/health",
-          allow: "unauthenticated"
-        });
-      }
-    });
-  }
-});
-
-exports.createRouter = createRouter;
-exports.default = codeCoveragePlugin;
+exports.createRouter = router.createRouter;
+exports.default = plugin.codeCoveragePlugin;
 //# sourceMappingURL=index.cjs.js.map