@secustor/backstage-plugin-renovate-backend 0.12.0 → 0.13.1

package/dist/index.cjs.js

@@ -2,1415 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var rootHttpRouter = require('@backstage/backend-defaults/rootHttpRouter');
-var express = require('express');
-var backendOpenapiUtils = require('@backstage/backend-openapi-utils');
-var zod = require('zod');
-var backstagePluginRenovateCommon = require('@secustor/backstage-plugin-renovate-common');
-var catalogClient = require('@backstage/catalog-client');
-var is = require('@sindresorhus/is');
-var integration = require('@backstage/integration');
-var backendPluginApi = require('@backstage/backend-plugin-api');
-var errors = require('@backstage/errors');
-var nanoid = require('nanoid');
-var backstagePluginRenovateNode = require('@secustor/backstage-plugin-renovate-node');
-var catalogModel = require('@backstage/catalog-model');
+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 is__default = /*#__PURE__*/_interopDefaultCompat(is);
 
-const spec = {
-  openapi: "3.0.0",
-  info: {
-    title: "renovate",
-    description: "Backstage Renovate API",
-    version: "0.2.0"
-  },
-  servers: [
-    {
-      description: "local test setup",
-      url: "http://localhost:7007"
-    }
-  ],
-  paths: {
-    "/health": {
-      get: {
-        summary: "Get health status of the plugin",
-        responses: {
-          "200": {
-            description: "health status is green",
-            content: {
-              "application/json": {
-                schema: {
-                  type: "string",
-                  example: "ok"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/reports": {
-      get: {
-        summary: "Get all reports",
-        responses: {
-          "200": {
-            $ref: "#/components/responses/reports"
-          }
-        }
-      },
-      delete: {
-        summary: "Delete reports based on parameters",
-        parameters: [
-          {
-            $ref: "#/components/parameters/keepLatest"
-          }
-        ],
-        responses: {
-          "200": {
-            $ref: "#/components/responses/deleted-successful"
-          }
-        }
-      }
-    },
-    "/reports/{host}": {
-      get: {
-        summary: "Get reports for host",
-        parameters: [
-          {
-            name: "host",
-            in: "path",
-            required: true,
-            schema: {
-              type: "string",
-              example: "github.com"
-            }
-          }
-        ],
-        responses: {
-          "200": {
-            $ref: "#/components/responses/reports"
-          },
-          "404": {
-            description: "unknown host"
-          }
-        }
-      },
-      delete: {
-        summary: "Delete reports based on parameters",
-        parameters: [
-          {
-            $ref: "#/components/parameters/keepLatest"
-          }
-        ],
-        responses: {
-          "200": {
-            $ref: "#/components/responses/deleted-successful"
-          }
-        }
-      }
-    },
-    "/reports/{host}/{repository}": {
-      get: {
-        summary: "Get reports for repository",
-        parameters: [
-          {
-            name: "host",
-            in: "path",
-            required: true,
-            schema: {
-              type: "string",
-              example: "github.com"
-            }
-          },
-          {
-            name: "repository",
-            in: "path",
-            required: true,
-            schema: {
-              type: "string",
-              example: "myOrg/myRepository"
-            }
-          }
-        ],
-        responses: {
-          "200": {
-            $ref: "#/components/responses/reports"
-          },
-          "404": {
-            description: "unknown repository"
-          }
-        }
-      },
-      delete: {
-        summary: "Delete reports based on parameters",
-        parameters: [
-          {
-            $ref: "#/components/parameters/keepLatest"
-          }
-        ],
-        responses: {
-          "200": {
-            $ref: "#/components/responses/deleted-successful"
-          }
-        }
-      }
-    },
-    "/dependencies": {
-      get: {
-        summary: "Get dependencies for host",
-        parameters: [
-          {
-            name: "pageSize",
-            in: "query",
-            description: "size of the page",
-            schema: {
-              type: "number",
-              default: 100
-            }
-          },
-          {
-            name: "page",
-            in: "query",
-            description: "page number. starting with 0",
-            schema: {
-              type: "number"
-            }
-          },
-          {
-            name: "availableValues",
-            in: "query",
-            description: "if set to true, the response will include all available values for the filters",
-            schema: {
-              type: "boolean"
-            }
-          },
-          {
-            name: "datasource",
-            in: "query",
-            description: "filter by datasource",
-            schema: {
-              type: "array",
-              items: {
-                example: "npm,pypi",
-                type: "string"
-              }
-            }
-          },
-          {
-            name: "depName",
-            in: "query",
-            description: "filter by dependency name",
-            schema: {
-              type: "array",
-              items: {
-                example: "pdm,react",
-                type: "string"
-              }
-            }
-          },
-          {
-            name: "depType",
-            in: "query",
-            description: "filter by dependency type",
-            schema: {
-              type: "array",
-              items: {
-                example: "dev,prod",
-                type: "string"
-              }
-            }
-          },
-          {
-            name: "host",
-            in: "query",
-            schema: {
-              type: "array",
-              example: "github.com,gitlab.example.com",
-              items: {
-                type: "string"
-              }
-            }
-          },
-          {
-            name: "latestOnly",
-            in: "query",
-            description: "include only dependencies which have been found in the last extraction",
-            schema: {
-              type: "boolean"
-            }
-          },
-          {
-            name: "manager",
-            in: "query",
-            description: "filter by manager",
-            schema: {
-              type: "array",
-              items: {
-                example: "npm,composer",
-                type: "string"
-              }
-            }
-          },
-          {
-            name: "packageFile",
-            in: "query",
-            description: "filter by package file",
-            schema: {
-              type: "array",
-              items: {
-                example: "package.json,composer.json",
-                type: "string"
-              }
-            }
-          },
-          {
-            name: "repository",
-            in: "query",
-            schema: {
-              type: "array",
-              example: "myOrg/myRepository,myOrg/myOtherRepository",
-              items: {
-                type: "string"
-              }
-            }
-          }
-        ],
-        responses: {
-          "200": {
-            $ref: "#/components/responses/dependencies"
-          },
-          "404": {
-            description: "unknown host"
-          }
-        }
-      }
-    },
-    "/runs": {
-      post: {
-        summary: "Start or get Renovate runs",
-        requestBody: {
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                required: ["target"],
-                properties: {
-                  target: {
-                    $ref: "#/components/schemas/target"
-                  }
-                }
-              }
-            }
-          }
-        },
-        responses: {
-          "202": {
-            description: "Run has been scheduled",
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object",
-                  properties: {
-                    taskID: {
-                      description: "id of the scheduler task",
-                      type: "string",
-                      example: "9-d_CO9JlaEmd-OM9QfkI"
-                    }
-                  }
-                }
-              }
-            }
-          },
-          "400": {
-            description: "Unexpected incoming data",
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object",
-                  properties: {
-                    error: {
-                      $ref: "#/components/schemas/error"
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  },
-  components: {
-    parameters: {
-      keepLatest: {
-        name: "keepLatest",
-        description: "how many reports of all targets should be kept",
-        in: "query",
-        required: false,
-        example: 3,
-        schema: {
-          type: "number"
-        }
-      }
-    },
-    responses: {
-      dependencies: {
-        description: "Returns dependencies",
-        headers: {
-          "X-Total-Count": {
-            schema: {
-              type: "integer",
-              description: "Total number of entries"
-            }
-          },
-          "X-Page-Count": {
-            schema: {
-              type: "integer",
-              description: "Total number of pages"
-            }
-          },
-          "X-Page": {
-            schema: {
-              type: "integer",
-              description: "Current page"
-            }
-          },
-          "X-Page-Size": {
-            schema: {
-              type: "integer",
-              description: "Number of entries per page"
-            }
-          }
-        },
-        content: {
-          "application/json": {
-            schema: {
-              type: "object",
-              required: ["dependencies"],
-              properties: {
-                dependencies: {
-                  type: "array",
-                  items: {
-                    $ref: "#/components/schemas/dependency"
-                  }
-                },
-                availableValues: {
-                  type: "object",
-                  description: "Will only be part of the response if `availableValues` is true. Returns all available values for the applied filters\n",
-                  properties: {
-                    datasource: {
-                      type: "array",
-                      items: {
-                        type: "string"
-                      }
-                    },
-                    depName: {
-                      type: "array",
-                      items: {
-                        type: "string"
-                      }
-                    },
-                    depType: {
-                      type: "array",
-                      items: {
-                        type: "string"
-                      }
-                    },
-                    host: {
-                      type: "array",
-                      items: {
-                        type: "string"
-                      }
-                    },
-                    manager: {
-                      type: "array",
-                      items: {
-                        type: "string"
-                      }
-                    },
-                    packageFile: {
-                      type: "array",
-                      items: {
-                        type: "string"
-                      }
-                    },
-                    repository: {
-                      type: "array",
-                      items: {
-                        type: "string"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      },
-      "deleted-successful": {
-        description: "Successful deleted",
-        content: {
-          "application/json": {
-            schema: {
-              type: "object",
-              properties: {
-                deleted: {
-                  type: "number",
-                  example: 15,
-                  description: "Numbers of reports deleted"
-                }
-              }
-            }
-          }
-        }
-      },
-      reports: {
-        description: "Returns reports",
-        content: {
-          "application/json": {
-            schema: {
-              type: "array",
-              items: {
-                type: "object",
-                additionalProperties: false,
-                required: [
-                  "taskID",
-                  "repository",
-                  "host",
-                  "timestamp",
-                  "report"
-                ],
-                properties: {
-                  taskID: {
-                    type: "string"
-                  },
-                  timestamp: {
-                    type: "string",
-                    format: "date-time"
-                  },
-                  host: {
-                    type: "string"
-                  },
-                  repository: {
-                    type: "string"
-                  },
-                  report: {
-                    $ref: "#/components/schemas/repositoryReport"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    schemas: {
-      error: {
-        anyOf: [
-          {
-            type: "object",
-            example: {
-              message: "I'm an error",
-              code: 1111
-            }
-          },
-          {
-            type: "string",
-            example: "I'm an error"
-          }
-        ]
-      },
-      target: {
-        anyOf: [
-          {
-            type: "string",
-            description: "URL to an repository",
-            example: "https://github.com/secustor/renovate-test"
-          },
-          {
-            type: "string",
-            description: "stringified Entity with SourceLocation URL annotation",
-            example: "component:default/backstage-plugins-example"
-          },
-          {
-            type: "string",
-            description: "host and path",
-            example: "secustor/backstage-plugins"
-          }
-        ]
-      },
-      repositoryReportList: {
-        type: "array",
-        items: {
-          $ref: "#/components/schemas/repositoryReport"
-        }
-      },
-      repositoryReport: {
-        description: "report for a specific repository",
-        type: "object",
-        additionalProperties: false,
-        required: ["branches", "packageFiles", "problems"],
-        properties: {
-          branches: {
-            type: "array",
-            items: {
-              type: "object"
-            }
-          },
-          packageFiles: {
-            type: "object"
-          },
-          problems: {
-            type: "array",
-            items: {
-              type: "object"
-            }
-          }
-        }
-      },
-      dependency: {
-        type: "object",
-        additionalProperties: false,
-        required: [
-          "id",
-          "runID",
-          "host",
-          "repository",
-          "extractionTimestamp",
-          "manager",
-          "datasource",
-          "packageFile",
-          "depName"
-        ],
-        properties: {
-          id: {
-            type: "string"
-          },
-          runID: {
-            type: "string"
-          },
-          host: {
-            type: "string"
-          },
-          repository: {
-            type: "string"
-          },
-          extractionTimestamp: {
-            type: "string",
-            format: "date-time"
-          },
-          manager: {
-            type: "string"
-          },
-          datasource: {
-            type: "string"
-          },
-          packageFile: {
-            type: "string"
-          },
-          packageFileUrl: {
-            type: "string"
-          },
-          depName: {
-            type: "string"
-          },
-          packageName: {
-            type: "string"
-          },
-          depType: {
-            type: "string"
-          },
-          currentValue: {
-            type: "string"
-          },
-          currentVersion: {
-            type: "string"
-          },
-          currentVersionTimestamp: {
-            type: "string",
-            format: "date-time"
-          },
-          skipReason: {
-            type: "string"
-          },
-          registryUrl: {
-            type: "string"
-          },
-          sourceUrl: {
-            type: "string"
-          }
-        }
-      }
-    }
-  }
-};
-const createOpenApiRouter = async (options) => backendOpenapiUtils.createValidatedOpenApiRouter(spec, options);
-
-const target = zod.z.string().or(backstagePluginRenovateCommon.targetRepo);
-const runRequestBody = zod.z.object({
-  target
-});
-
-async function getGithubToken(integrations, url) {
-  const cred = await integration.DefaultGithubCredentialsProvider.fromIntegrations(
-    integrations
-  ).getCredentials({ url });
-  return cred.token;
-}
-
-async function getPlatformEnvs(target, context) {
-  const { rootConfig, logger } = context;
-  const env = {};
-  const integrations = integration.ScmIntegrations.fromConfig(rootConfig);
-  const integration$1 = integrations.byHost(target.host);
-  if (is__default.default.nullOrUndefined(integration$1)) {
-    throw new Error(
-      `Could not identify platform for target ${target.host}/${target.repository}`
-    );
-  }
-  const errMsg = `No credentials could be found for url and '${integration$1.type}' type for host ${target.host}`;
-  const url = `https://${target.host}/${target.repository}`;
-  switch (integration$1.type) {
-    case "github": {
-      env.RENOVATE_PLATFORM = integration$1.type;
-      const token = await getGithubToken(integrations, url);
-      env.RENOVATE_TOKEN = requireConfigVariable(token, errMsg);
-      env.RENOVATE_REPOSITORIES = target.repository;
-      break;
-    }
-    case "gitlab":
-      {
-        const cred = await integration.DefaultGitlabCredentialsProvider.fromIntegrations(
-          integrations
-        ).getCredentials({ url });
-        const gitLabIntegrationConfig = requireConfigVariable(
-          integrations.gitlab.byHost(target.host)?.config,
-          errMsg
-        );
-        env.RENOVATE_PLATFORM = integration$1.type;
-        env.RENOVATE_ENDPOINT = gitLabIntegrationConfig.apiBaseUrl ?? `https://${target.host}/api/v4`;
-        env.RENOVATE_TOKEN = requireConfigVariable(cred.token, errMsg);
-        env.RENOVATE_REPOSITORIES = target.repository;
-      }
-      break;
-    default:
-      throw new Error(`Unsupported platform type ${integration$1.type}`);
-  }
-  const githubComURL = "https://github.com";
-  const githubComIntegration = integrations.github.byUrl(githubComURL);
-  if (is__default.default.nullOrUndefined(githubComIntegration)) {
-    logger.warn(`No Github.com integration has been found`);
-  } else {
-    const githubComToken = await getGithubToken(integrations, githubComURL);
-    if (githubComToken) {
-      env.RENOVATE_GITHUB_COM = githubComToken;
-    } else {
-      logger.warn(
-        `Could not get token for Github.com token in the defined integrations`
-      );
-    }
-  }
-  return env;
-}
-function requireConfigVariable(input, errMessage) {
-  if (is__default.default.nullOrUndefined(input)) {
-    throw new Error(errMessage);
-  }
-  return input;
-}
-function getFileUrl(options) {
-  if (options.host.includes("github")) {
-    return `https://${options.host}/${options.repository}/blob/HEAD/${options.packageFile}`;
-  }
-  return null;
-}
-
-async function createRouter(runner, options) {
-  const {
-    auth,
-    rootConfig: config,
-    logger,
-    databaseHandler,
-    discovery
-  } = options;
-  const middlewareFactory = rootHttpRouter.MiddlewareFactory.create({ logger, config });
-  const client = new catalogClient.CatalogClient({ discoveryApi: discovery });
-  const router = await createOpenApiRouter();
-  router.use(express__default.default.json());
-  router.get("/health", (_, response) => {
-    logger.debug("healthcheck request");
-    response.json("ok");
-  });
-  router.get("/reports", async (_request, response) => {
-    const reports = await databaseHandler.getReports();
-    response.status(200).json(reports);
-  });
-  router.delete("/reports", async (request, response) => {
-    const modified = await databaseHandler.deleteReports({
-      keepLatest: request.query.keepLatest
-    });
-    response.status(200).json({ modified });
-  });
-  router.get("/reports/:host", async (request, response) => {
-    const reports = await databaseHandler.getReports({
-      ...request.params
-    });
-    response.status(200).json(reports);
-  });
-  router.delete("/reports/:host", async (request, response) => {
-    const modified = await databaseHandler.deleteReportsByTarget(
-      request.params,
-      { keepLatest: request.query.keepLatest }
-    );
-    response.status(200).json({ modified });
-  });
-  router.get("/reports/:host/:repository", async (request, response) => {
-    const reports = await databaseHandler.getReports({
-      ...request.params
-    });
-    response.status(200).json(reports);
-  });
-  router.delete("/reports/:host/:repository", async (request, response) => {
-    const modified = await databaseHandler.deleteReportsByTarget(
-      request.params,
-      { keepLatest: request.query.keepLatest }
-    );
-    response.status(200).json({ modified });
-  });
-  router.get("/dependencies", async (request, response) => {
-    const filter = request.query;
-    const { result, total, pageCount, page, pageSize } = await databaseHandler.getDependencies(filter, filter);
-    const massaged = result.map((dep) => {
-      return {
-        ...dep,
-        id: dep.id,
-        runID: dep.run_id,
-        extractionTimestamp: dep.extractionTimestamp?.toISOString(),
-        currentVersionTimestamp: dep.currentVersionTimestamp?.toISOString(),
-        packageFileUrl: getFileUrl(dep) ?? void 0
-      };
-    });
-    let availableValues;
-    if (request.query.availableValues) {
-      availableValues = await databaseHandler.getDependenciesValues(filter);
-    }
-    response.setHeader("X-Total-Count", total);
-    response.setHeader("X-Page-Count", pageCount);
-    response.setHeader("X-Page", page);
-    response.setHeader("X-Page-Size", pageSize);
-    response.json({
-      dependencies: massaged,
-      availableValues
-    });
-  });
-  router.post("/runs", async (request, response) => {
-    const body = runRequestBody.safeParse(request.body);
-    if (!body.success) {
-      response.status(400).json({ error: body.error.toString() });
-      return;
-    }
-    let target = body.data.target;
-    if (is__default.default.string(target) && backstagePluginRenovateCommon.isEntityRef(target)) {
-      const { token } = await auth.getPluginRequestToken({
-        onBehalfOf: await auth.getOwnServiceCredentials(),
-        targetPluginId: "catalog"
-      });
-      const result2 = await client.getEntityByRef(target, { token });
-      if (result2) {
-        target = result2;
-      }
-    }
-    const targetRepo = backstagePluginRenovateCommon.getTargetRepo(target);
-    const id = backstagePluginRenovateCommon.getTaskID(targetRepo);
-    const result = await runner.runNext(targetRepo);
-    if (result.status === "already-running") {
-      logger.debug("Task already running", { taskID: id });
-      response.status(423).json({ error: "Task is already running" });
-      return;
-    }
-    response.status(202).json({ taskID: id });
-  });
-  router.use(middlewareFactory.error());
-  return router;
-}
-
-const RENOVATE_ANNOTATION_KEEP_UPDATED = "renovate.secustor.dev/keep-updated";
-function getPluginConfig(rootConfig) {
-  return rootConfig.getConfig("renovate");
-}
-function getRenovateConfig(rootConfig) {
-  const value = getPluginConfig(rootConfig).getOptional("config");
-  return value ?? null;
-}
-function getRuntimeConfigs(rootConfig) {
-  const runtimeConfig = getPluginConfig(rootConfig).getConfig("runtime");
-  const runtime = runtimeConfig.getString("type");
-  return {
-    runtime,
-    config: runtimeConfig.getConfig(runtime)
-  };
-}
-function getScheduleDefinition(pluginConfig, variant) {
-  try {
-    const scheduleConfig = pluginConfig.getConfig(`schedules.${variant}`);
-    return {
-      enabled: scheduleConfig.getOptionalBoolean("enabled") ?? true,
-      ...backendPluginApi.readSchedulerServiceTaskScheduleDefinitionFromConfig(scheduleConfig)
-    };
-  } catch (e) {
-    return {
-      enabled: true,
-      scope: "global",
-      timeout: { minutes: 60 },
-      frequency: { minutes: 60 }
-    };
-  }
-}
-
-async function extractReport(opts) {
-  const { logStream, logger } = opts;
-  return new Promise((resolve) => {
-    let uncompletedText = "";
-    logStream.on("data", (chunk) => {
-      const text = uncompletedText.concat(chunk.toString());
-      const logLines = text.split("\n");
-      uncompletedText = logLines.pop() ?? "";
-      for (const logLine of logLines) {
-        const log = JSON.parse(logLine);
-        if (log.report) {
-          const report = log.report;
-          resolve(report);
-        }
-        const msg = log.msg;
-        delete log.msg;
-        delete log.logContext;
-        logger.debug(msg, log);
-      }
-    });
-  });
-}
-function getCacheEnvs(config, logger) {
-  const cacheEnabled = getPluginConfig(config).getOptionalBoolean("cache.enabled") ?? true;
-  if (!cacheEnabled) {
-    logger.debug("Cache has been disabled in plugin configuration");
-    return {};
-  }
-  const cacheConfig = config.getOptionalConfig("backend.cache");
-  if (is__default.default.nullOrUndefined(cacheConfig)) {
-    logger.debug("No cache configured");
-    return {};
-  }
-  const store = cacheConfig.getString("store");
-  if (store !== "redis") {
-    logger.debug(`Unsupported cache store '${store}' detected`);
-    return {};
-  }
-  const connection = cacheConfig.getOptionalString("connection");
-  if (is__default.default.nullOrUndefined(connection)) {
-    logger.debug("No connection string for redis cache configured in backend");
-    return {};
-  }
-  logger.debug("Injecting Redis cache into Renovate");
-  return {
-    RENOVATE_REDIS_PREFIX: "renovate_",
-    RENOVATE_REDIS_URL: connection
-  };
-}
-
-function createQueue(queues, rootConfig, runnable) {
-  const type = getPluginConfig(rootConfig).getString("queue.type");
-  const factory = queues.get(type);
-  if (!factory) {
-    throw new Error(`Could not find Queue implementation ${type}`);
-  }
-  return factory(runnable);
-}
-
-class RenovateRunner {
-  constructor(queueFactories, databaseHandler, rootConfig, logger, runtimes) {
-    this.databaseHandler = databaseHandler;
-    this.rootConfig = rootConfig;
-    this.logger = logger;
-    this.runtimes = runtimes;
-    this.queue = createQueue(queueFactories, rootConfig, this);
-  }
-  queue;
-  static async from(options) {
-    const { databaseHandler, rootConfig, runtimes, logger, queueFactories } = options;
-    return new RenovateRunner(
-      queueFactories,
-      databaseHandler,
-      rootConfig,
-      logger,
-      runtimes
-    );
-  }
-  async addToQueue(...targets) {
-    const props = targets.map((target) => {
-      const jobId = backstagePluginRenovateCommon.getTaskID(target);
-      const targetRepo = backstagePluginRenovateCommon.getTargetRepo(target);
-      return {
-        jobId,
-        data: {
-          id: jobId,
-          target: targetRepo
-        }
-      };
-    });
-    return await this.queue.addBulk(props);
-  }
-  async runNext(target) {
-    const jobId = backstagePluginRenovateCommon.getTaskID(target);
-    const targetRepo = backstagePluginRenovateCommon.getTargetRepo(target);
-    return await this.queue.add(
-      jobId,
-      { id: jobId, target: targetRepo },
-      {
-        force: true,
-        insertInFront: true
-      }
-    );
-  }
-  async run(props) {
-    const { id, target } = props;
-    const runID = nanoid.nanoid();
-    const logger = this.logger.child({ runID, jobID: id, ...target });
-    try {
-      logger.info("Renovate run starting");
-      const report = await this.renovate(props, logger);
-      await this.databaseHandler.addReport({
-        runID,
-        taskID: id,
-        report,
-        target,
-        logger
-      });
-      logger.info("Renovate run successfully finished");
-    } catch (e) {
-      logger.error("Renovate failed", errors.isError(e) ? e : {});
-    }
-  }
-  async renovate({ id, target }, logger) {
-    const { runtime, config: runtimeConfig } = getRuntimeConfigs(
-      this.rootConfig
-    );
-    const wrapperRuntime = this.runtimes.get(runtime);
-    if (is__default.default.nullOrUndefined(wrapperRuntime)) {
-      throw new Error(`Unknown runtime type '${runtime}'`);
-    }
-    const env = {
-      // setup logging
-      LOG_FORMAT: "json",
-      LOG_LEVEL: "debug",
-      LOG_CONTEXT: id,
-      RENOVATE_REPORT_TYPE: "logging",
-      // setup platform specifics
-      ...await getPlatformEnvs(target, {
-        logger,
-        rootConfig: this.rootConfig
-      }),
-      ...getCacheEnvs(this.rootConfig, logger)
-    };
-    const renovateConfig = getRenovateConfig(this.rootConfig);
-    const promise = wrapperRuntime.run({
-      runID: id,
-      env,
-      renovateConfig,
-      runtimeConfig,
-      logger
-    });
-    return promise.then((result) => {
-      return extractReport({
-        logger,
-        logStream: result.stdout
-      });
-    });
-  }
-}
-
-const DependencyValueFiltersKeys = [
-  "datasource",
-  "depName",
-  "depType",
-  "host",
-  "manager",
-  "packageFile",
-  "repository"
-];
-
-const migrationsDir = backendPluginApi.resolvePackagePath(
-  "@secustor/backstage-plugin-renovate-backend",
-  "migrations"
-);
-class DatabaseHandler {
-  constructor(client, logger) {
-    this.client = client;
-    this.logger = logger;
-  }
-  static async create(options) {
-    const { database, logger } = options;
-    const client = await database.getClient();
-    if (!database.migrations?.skip) {
-      await client.migrate.latest({
-        directory: migrationsDir
-      });
-    }
-    return new DatabaseHandler(client, logger);
-  }
-  async addReport(options) {
-    const { runID, taskID, report, target } = options;
-    const logger = options.logger ?? this.logger;
-    const timestamp = /* @__PURE__ */ new Date();
-    const inserts = [];
-    for (const [repository, value] of Object.entries(report.repositories)) {
-      inserts.push({
-        run_id: runID,
-        task_id: taskID,
-        timestamp,
-        host: target.host,
-        repository,
-        report: value
-      });
-    }
-    await this.client("reports").insert(inserts).catch((reason) => logger.error("Failed insert data", reason));
-    await this.updateDependencies(timestamp, options);
-  }
-  async getReports(query) {
-    const builder = this.client.select();
-    if (query) {
-      builder.where(query);
-    }
-    const rows = await builder.from("reports");
-    return rows.map((row) => {
-      return {
-        runID: row.run_id,
-        taskID: row.task_id,
-        timestamp: row.timestamp.toISOString(),
-        host: row.host,
-        repository: row.repository,
-        // if the JSON field has not been auto-parsed do it manually
-        report: is__default.default.string(row.report) ? JSON.parse(row.report) : row.report
-      };
-    });
-  }
-  async getTargets() {
-    return this.client.select().distinct("host", "repository").from("reports");
-  }
-  async deleteReportsByTarget({ host, repository }, options) {
-    const offset = getOffset(options);
-    const toBeDeletedIDs = this.client("reports").select("run_id").where("host", host).andWhere("repository", repository).orderBy("timestamp", "DESC").offset(offset);
-    return this.client("reports").delete().whereIn("run_id", [toBeDeletedIDs]);
-  }
-  async deleteReports(options) {
-    const targets = await this.getTargets();
-    const modified = await Promise.all(
-      targets.map((target) => this.deleteReportsByTarget(target, options))
-    );
-    return modified.reduce((a, b) => a + b, 0);
-  }
-  async updateDependencies(timestamp, options) {
-    const { runID, report, target } = options;
-    const dependencies = [];
-    for (const [repository, repositoryContent] of Object.entries(
-      report.repositories
-    )) {
-      for (const [manager, packageFiles] of Object.entries(
-        repositoryContent.packageFiles
-      )) {
-        for (const packageFile of packageFiles) {
-          const packageFilePath = packageFile.packageFile;
-          for (const dependency of packageFile.deps) {
-            const {
-              packageName,
-              depName,
-              depType,
-              datasource,
-              currentValue,
-              currentVersion,
-              skipReason,
-              registryUrl,
-              sourceUrl,
-              currentVersionTimestamp
-            } = dependency;
-            const massagedDepName = depName ?? packageName;
-            if (!massagedDepName) {
-              continue;
-            }
-            dependencies.push({
-              run_id: runID,
-              host: target.host,
-              extractionTimestamp: timestamp,
-              repository,
-              manager,
-              datasource: datasource ?? packageFile.datasource ?? "no-datasource",
-              depName: massagedDepName,
-              packageName,
-              packageFile: packageFilePath,
-              depType,
-              currentValue,
-              currentVersion,
-              currentVersionTimestamp,
-              skipReason,
-              registryUrl,
-              sourceUrl
-            });
-          }
-        }
-      }
-    }
-    await this.client("dependencies").insert(dependencies);
-  }
-  async getDependencies(filters, pagination) {
-    const page = pagination?.page ?? 0;
-    const pageSize = pagination?.pageSize ?? 500;
-    const builder = this.client("dependencies").select();
-    this.applyDependencyFilters(builder, filters);
-    const total = await this.getDependenciesCount(filters);
-    const offset = page * pageSize;
-    return {
-      result: await builder.offset(offset).limit(pageSize),
-      total,
-      page,
-      pageSize,
-      pageCount: Math.ceil(total / pageSize)
-    };
-  }
-  async getDependenciesCount(filters) {
-    const builder = this.client("dependencies").count({ count: "*" });
-    this.applyDependencyFilters(builder, filters);
-    const count = await builder.first().then((result) => result?.count);
-    if (is__default.default.string(count)) {
-      return Number.parseInt(count, 10);
-    }
-    return count ?? 0;
-  }
-  applyDependencyFilters(builder, filters) {
-    if (filters.host) {
-      builder.whereIn("host", filters.host);
-    }
-    if (filters.repository) {
-      builder.whereIn("repository", filters.repository);
-    }
-    if (filters.manager) {
-      builder.whereIn("manager", filters.manager);
-    }
-    if (filters.datasource) {
-      builder.whereIn("datasource", filters.datasource);
-    }
-    if (filters.depName) {
-      builder.whereIn("depName", filters.depName);
-    }
-    if (filters.depType) {
-      builder.whereIn("depType", filters.depType);
-    }
-    if (filters.latestOnly) {
-      const runIDs = this.client("dependencies").select("d.run_id").from("dependencies as d").join(
-        this.client("dependencies").select("host", "repository").max("extractionTimestamp as max_timestamp").groupBy("host", "repository").as("max_d"),
-        // eslint-disable-next-line func-names
-        function() {
-          this.on("d.host", "=", "max_d.host").andOn("d.repository", "=", "max_d.repository").andOn("d.extractionTimestamp", "=", "max_d.max_timestamp");
-        }
-      ).distinct();
-      builder.whereIn("run_id", runIDs);
-    }
-  }
-  /**
-   * Gets the available values for the dependencies stored in the database.
-   * If filters are supplied, OTHER values are filtered accordingly, if a filter is supplied, all values are returned
-   * @param filters
-   */
-  async getDependenciesValues(filters) {
-    const baseBuilder = this.client(
-      "dependencies"
-    );
-    const limitedValuesBuilder = baseBuilder.clone();
-    const allValuesKeys = [];
-    const limitedValuesKeys = [];
-    for (const filterKey of DependencyValueFiltersKeys) {
-      const suppliedFilter = filters?.[filterKey];
-      if (suppliedFilter) {
-        limitedValuesBuilder.whereIn(filterKey, suppliedFilter);
-        limitedValuesKeys.push(filterKey);
-        continue;
-      }
-      allValuesKeys.push(filterKey);
-    }
-    const result = {
-      datasource: [],
-      manager: [],
-      depType: [],
-      depName: [],
-      host: [],
-      packageFile: [],
-      repository: []
-    };
-    const allValues = allValuesKeys.map(
-      async (filterKey) => {
-        const values = await limitedValuesBuilder.clone().select(filterKey).distinct().pluck(filterKey);
-        result[filterKey] = values.filter(is__default.default.string);
-      }
-    );
-    const limitedValues = limitedValuesKeys.map(async (filterKey) => {
-      const values = await baseBuilder.clone().select(filterKey).distinct().pluck(filterKey);
-      result[filterKey] = values.filter(is__default.default.string);
-    });
-    await Promise.all([...allValues, ...limitedValues]);
-    return result;
-  }
-  async deleteDependencies(options) {
-    const targets = await this.getTargets();
-    const modified = await Promise.all(
-      targets.map((target) => this.deleteDependenciesByTarget(target, options))
-    );
-    return modified.reduce((a, b) => a + b, 0);
-  }
-  async deleteDependenciesByTarget({ host, repository }, options) {
-    const offset = getOffset(options);
-    const dependencies = this.client("dependencies").select("run_id", "extractionTimestamp").distinct("host", "repository").where("host", host).andWhere("repository", repository);
-    const toBeDeletedIDs = this.client(dependencies).select("run_id").orderBy("extractionTimestamp", "DESC").offset(offset);
-    return this.client("dependencies").delete().whereIn("run_id", [toBeDeletedIDs]);
-  }
-}
-function getOffset(options) {
-  let offset = 0;
-  if (is__default.default.nullOrUndefined(options?.keepLatest) || is__default.default.boolean(options?.keepLatest)) {
-    offset = options?.keepLatest ? 1 : 0;
-  } else {
-    offset = options.keepLatest;
-  }
-  return offset;
-}
-
-async function scheduleJobSync(renovateRunner, routerOptions) {
-  const { scheduler, auth, rootConfig, discovery } = routerOptions;
-  const client = new catalogClient.CatalogClient({ discoveryApi: discovery });
-  const pluginConfig = getPluginConfig(rootConfig);
-  const schedule = getScheduleDefinition(pluginConfig, "renovation");
-  if (!schedule.enabled) {
-    return Promise.resolve();
-  }
-  return scheduler.scheduleTask({
-    id: `renovate_scheduled_runs`,
-    ...schedule,
-    fn: async () => {
-      const { token } = await auth.getPluginRequestToken({
-        onBehalfOf: await auth.getOwnServiceCredentials(),
-        targetPluginId: "catalog"
-      });
-      const { items: entities } = await client.getEntities(
-        {
-          filter: {
-            [`metadata.annotations.${RENOVATE_ANNOTATION_KEEP_UPDATED}`]: catalogClient.CATALOG_FILTER_EXISTS,
-            [`metadata.annotations.${catalogModel.ANNOTATION_SOURCE_LOCATION}`]: catalogClient.CATALOG_FILTER_EXISTS
-          },
-          fields: [
-            "kind",
-            "metadata.annotations",
-            "metadata.name",
-            "metadata.namespace",
-            "metadata.title"
-          ]
-        },
-        { token }
-      );
-      await renovateRunner.addToQueue(...entities);
-    }
-  });
-}
-
-async function scheduleCleanupTask(routerOptions) {
-  const { scheduler, rootConfig, databaseHandler, logger } = routerOptions;
-  const pluginConfig = getPluginConfig(rootConfig);
-  const schedule = getScheduleDefinition(pluginConfig, "cleanup");
-  if (!schedule.enabled) {
-    return Promise.resolve();
-  }
-  const reportsToKeep = pluginConfig.getOptionalNumber("cleanup.minimumReports") ?? -1;
-  const dependencyHistoryKeep = pluginConfig.getOptionalNumber("cleanup.dependencyHistory") ?? -1;
-  return scheduler.scheduleTask({
-    id: `renovate_report_cleanup`,
-    ...schedule,
-    fn: async () => {
-      if (reportsToKeep >= 0) {
-        logger.debug("Running report cleanup");
-        const modified = await databaseHandler.deleteReports({
-          keepLatest: reportsToKeep
-        });
-        logger.debug(`Report cleanup completed. ${modified} reports deleted`);
-      }
-      if (dependencyHistoryKeep >= 0) {
-        logger.debug("Running dependency history cleanup");
-        const modified = await databaseHandler.deleteDependencies({
-          keepLatest: dependencyHistoryKeep
-        });
-        logger.debug(
-          `Dependency history cleanup completed. ${modified} dependencies deleted`
-        );
-      }
-    }
-  });
-}
-
-const renovatePlugin = backendPluginApi.createBackendPlugin({
-  pluginId: "renovate",
-  register(env) {
-    const runtimes = /* @__PURE__ */ new Map();
-    env.registerExtensionPoint(backstagePluginRenovateNode.renovateRuntimeExtensionPoint, {
-      addRuntime(id, runtime) {
-        if (runtimes.has(id)) {
-          throw new Error(
-            ` ${id} has been already registered. Only one wrapper with the same ID is allowed to be registered`
-          );
-        }
-        runtimes.set(id, runtime);
-      }
-    });
-    const queueFactories = /* @__PURE__ */ new Map();
-    env.registerExtensionPoint(backstagePluginRenovateNode.renovateQueueExtensionPoint, {
-      addQueueFactory(id, factory) {
-        if (queueFactories.has(id)) {
-          throw new Error(
-            ` ${id} has been already registered. Only one queue with the same ID is allowed to be registered`
-          );
-        }
-        queueFactories.set(id, factory);
-      }
-    });
-    env.registerInit({
-      deps: {
-        rootConfig: backendPluginApi.coreServices.rootConfig,
-        logger: backendPluginApi.coreServices.logger,
-        httpRouter: backendPluginApi.coreServices.httpRouter,
-        database: backendPluginApi.coreServices.database,
-        scheduler: backendPluginApi.coreServices.scheduler,
-        discovery: backendPluginApi.coreServices.discovery,
-        auth: backendPluginApi.coreServices.auth
-      },
-      async init(options) {
-        const { database, httpRouter, logger } = options;
-        const routerOptions = {
-          ...options,
-          databaseHandler: await DatabaseHandler.create({ database, logger }),
-          runtimes,
-          queueFactories
-        };
-        const renovateRunner = await RenovateRunner.from(routerOptions);
-        await scheduleJobSync(renovateRunner, routerOptions);
-        await scheduleCleanupTask(routerOptions);
-        httpRouter.use(await createRouter(renovateRunner, routerOptions));
-        httpRouter.addAuthPolicy({
-          path: "/health",
-          allow: "unauthenticated"
-        });
-      }
-    });
-  }
-});
-
-exports.createRouter = createRouter;
-exports.default = renovatePlugin;
+exports.createRouter = router.createRouter;
+exports.default = plugin.renovatePlugin;
 //# sourceMappingURL=index.cjs.js.map