@backstage-community/plugin-tech-insights-backend 1.2.0 → 1.2.2

package/dist/index.cjs.js

@@ -2,819 +2,23 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var backendPluginApi = require('@backstage/backend-plugin-api');
-var pluginTechInsightsNode = require('@backstage-community/plugin-tech-insights-node');
-var catalogClient = require('@backstage/catalog-client');
-var isEmpty = require('lodash/isEmpty');
-var camelCase = require('lodash/camelCase');
-var lodash = require('lodash');
-var semver = require('semver');
-var luxon = require('luxon');
-var catalogModel = require('@backstage/catalog-model');
-var express = require('express');
-var Router = require('express-promise-router');
-var errors = require('@backstage/errors');
-var rootHttpRouter = require('@backstage/backend-defaults/rootHttpRouter');
-var pLimit = require('p-limit');
-var config = require('@backstage/config');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var isEmpty__default = /*#__PURE__*/_interopDefaultCompat(isEmpty);
-var camelCase__default = /*#__PURE__*/_interopDefaultCompat(camelCase);
-var express__default = /*#__PURE__*/_interopDefaultCompat(express);
-var Router__default = /*#__PURE__*/_interopDefaultCompat(Router);
-var pLimit__default = /*#__PURE__*/_interopDefaultCompat(pLimit);
-
-function createFactRetrieverRegistration(options) {
-  const { cadence, factRetriever, lifecycle, timeout, initialDelay } = options;
-  return {
-    cadence,
-    factRetriever,
-    lifecycle,
-    timeout,
-    initialDelay
-  };
-}
-
-const entityMetadataFactRetriever = {
-  id: "entityMetadataFactRetriever",
-  version: "0.0.1",
-  title: "Entity Metadata",
-  description: "Generates facts which indicate the completeness of entity metadata",
-  schema: {
-    hasTitle: {
-      type: "boolean",
-      description: "The entity has a title in metadata"
-    },
-    hasDescription: {
-      type: "boolean",
-      description: "The entity has a description in metadata"
-    },
-    hasTags: {
-      type: "boolean",
-      description: "The entity has tags in metadata"
-    }
-  },
-  handler: async ({ discovery, entityFilter, auth }) => {
-    const { token } = await auth.getPluginRequestToken({
-      onBehalfOf: await auth.getOwnServiceCredentials(),
-      targetPluginId: "catalog"
-    });
-    const catalogClient$1 = new catalogClient.CatalogClient({
-      discoveryApi: discovery
-    });
-    const entities = await catalogClient$1.getEntities(
-      { filter: entityFilter },
-      { token }
-    );
-    return entities.items.map((entity) => {
-      return {
-        entity: {
-          namespace: entity.metadata.namespace,
-          kind: entity.kind,
-          name: entity.metadata.name
-        },
-        facts: {
-          hasTitle: Boolean(entity.metadata?.title),
-          hasDescription: Boolean(entity.metadata?.description),
-          hasTags: !isEmpty__default.default(entity.metadata?.tags)
-        }
-      };
-    });
-  }
-};
-
-const entityOwnershipFactRetriever = {
-  id: "entityOwnershipFactRetriever",
-  version: "0.0.1",
-  title: "Entity Ownership",
-  description: "Generates facts which indicate the quality of data in the spec.owner field",
-  entityFilter: [
-    { kind: ["component", "domain", "system", "api", "resource", "template"] }
-  ],
-  schema: {
-    hasOwner: {
-      type: "boolean",
-      description: "The spec.owner field is set"
-    },
-    hasGroupOwner: {
-      type: "boolean",
-      description: "The spec.owner field is set and refers to a group"
-    }
-  },
-  handler: async ({ discovery, entityFilter, auth }) => {
-    const { token } = await auth.getPluginRequestToken({
-      onBehalfOf: await auth.getOwnServiceCredentials(),
-      targetPluginId: "catalog"
-    });
-    const catalogClient$1 = new catalogClient.CatalogClient({
-      discoveryApi: discovery
-    });
-    const entities = await catalogClient$1.getEntities(
-      { filter: entityFilter },
-      { token }
-    );
-    return entities.items.map((entity) => {
-      return {
-        entity: {
-          namespace: entity.metadata.namespace,
-          kind: entity.kind,
-          name: entity.metadata.name
-        },
-        facts: {
-          hasOwner: Boolean(entity.spec?.owner),
-          hasGroupOwner: Boolean(
-            entity.spec?.owner && !(entity.spec?.owner).startsWith("user:")
-          )
-        }
-      };
-    });
-  }
-};
-
-const generateAnnotationFactName = (annotation) => camelCase__default.default(`hasAnnotation-${annotation}`);
-const entityHasAnnotation = (entity, annotation) => Boolean(lodash.get(entity, ["metadata", "annotations", annotation]));
-const isTtl = (lifecycle) => {
-  return !!lifecycle.timeToLive;
-};
-const isMaxItems = (lifecycle) => {
-  return !!lifecycle.maxItems;
-};
-
-const techdocsAnnotation = "backstage.io/techdocs-ref";
-const techdocsEntityAnnotation = "backstage.io/techdocs-entity";
-const techdocsAnnotationFactName = generateAnnotationFactName(techdocsAnnotation);
-const techdocsEntityAnnotationFactName = generateAnnotationFactName(
-  techdocsEntityAnnotation
-);
-const techdocsFactRetriever = {
-  id: "techdocsFactRetriever",
-  version: "0.1.0",
-  title: "Tech Docs",
-  description: "Generates facts related to the completeness of techdocs configuration for entities",
-  schema: {
-    [techdocsAnnotationFactName]: {
-      type: "boolean",
-      description: "The entity has a TechDocs reference annotation"
-    },
-    [techdocsEntityAnnotationFactName]: {
-      type: "boolean",
-      description: "The entity has a TechDocs entity annotation"
-    }
-  },
-  handler: async ({ discovery, entityFilter, auth }) => {
-    const { token } = await auth.getPluginRequestToken({
-      onBehalfOf: await auth.getOwnServiceCredentials(),
-      targetPluginId: "catalog"
-    });
-    const catalogClient$1 = new catalogClient.CatalogClient({
-      discoveryApi: discovery
-    });
-    const entities = await catalogClient$1.getEntities(
-      { filter: entityFilter },
-      { token }
-    );
-    return entities.items.map((entity) => {
-      return {
-        entity: {
-          namespace: entity.metadata.namespace,
-          kind: entity.kind,
-          name: entity.metadata.name
-        },
-        facts: {
-          [techdocsAnnotationFactName]: entityHasAnnotation(
-            entity,
-            techdocsAnnotation
-          ),
-          [techdocsEntityAnnotationFactName]: entityHasAnnotation(
-            entity,
-            techdocsEntityAnnotation
-          )
-        }
-      };
-    });
-  }
-};
-
-class TechInsightsDatabase {
-  constructor(db, logger) {
-    this.db = db;
-    this.logger = logger;
-  }
-  CHUNK_SIZE = 50;
-  async getLatestSchemas(ids) {
-    const queryBuilder = this.db("fact_schemas");
-    if (ids) {
-      queryBuilder.whereIn("id", ids);
-    }
-    const existingSchemas = await queryBuilder.orderBy("id", "desc").select();
-    const groupedSchemas = lodash.groupBy(existingSchemas, "id");
-    return Object.values(groupedSchemas).map((schemas) => {
-      const sorted = semver.rsort(schemas.map((it) => it.version));
-      return schemas.find((it) => it.version === sorted[0]);
-    }).map((it) => ({
-      ...lodash.omit(it, "schema"),
-      ...JSON.parse(it.schema),
-      entityFilter: it.entityFilter ? JSON.parse(it.entityFilter) : null
-    }));
-  }
-  async insertFactSchema(schemaDefinition) {
-    const { id, version, schema, entityFilter } = schemaDefinition;
-    const existingSchemas = await this.db("fact_schemas").where({ id }).and.where({ version }).select();
-    if (!existingSchemas || existingSchemas.length === 0) {
-      await this.db("fact_schemas").insert({
-        id,
-        version,
-        entityFilter: entityFilter ? JSON.stringify(entityFilter) : void 0,
-        schema: JSON.stringify(schema)
-      });
-    }
-  }
-  async insertFacts({
-    id,
-    facts,
-    lifecycle
-  }) {
-    if (facts.length === 0) return;
-    const currentSchema = await this.getLatestSchema(id);
-    const factRows = facts.map((it) => {
-      const ts = it.timestamp?.toISO();
-      return {
-        id,
-        version: currentSchema.version,
-        entity: catalogModel.stringifyEntityRef(it.entity),
-        facts: JSON.stringify(it.facts),
-        ...ts && { timestamp: ts }
-      };
-    });
-    await this.db.transaction(async (tx) => {
-      await tx.batchInsert("facts", factRows, this.CHUNK_SIZE);
-      if (lifecycle && isTtl(lifecycle)) {
-        const expiration = luxon.DateTime.now().minus(lifecycle.timeToLive);
-        await this.deleteExpiredFactsByDate(tx, id, expiration);
-      }
-      if (lifecycle && isMaxItems(lifecycle)) {
-        await this.deleteExpiredFactsByNumber(tx, id, lifecycle.maxItems);
-      }
-    });
-  }
-  async getLatestFactsByIds(ids, entityTriplet) {
-    const results = await this.db("facts").where({ entity: entityTriplet }).and.whereIn("id", ids).join(
-      this.db("facts").max("timestamp as maxTimestamp").column("id as subId").where({ entity: entityTriplet }).and.whereIn("id", ids).groupBy("id").as("subQ"),
-      {
-        "facts.id": "subQ.subId",
-        "facts.timestamp": "subQ.maxTimestamp"
-      }
-    );
-    return this.dbFactRowsToTechInsightFacts(results);
-  }
-  async getEntities() {
-    const results = await this.db("facts").distinct("entity");
-    return results.map((row) => catalogModel.parseEntityRef(row.entity));
-  }
-  async getFactsBetweenTimestampsByIds(ids, entityTriplet, startDateTime, endDateTime) {
-    const results = await this.db("facts").where({ entity: entityTriplet }).and.whereIn("id", ids).and.whereBetween("timestamp", [
-      startDateTime.toISO(),
-      endDateTime.toISO()
-    ]);
-    return lodash.groupBy(
-      results.map((it) => {
-        const { namespace, kind, name } = catalogModel.parseEntityRef(it.entity);
-        const timestamp = typeof it.timestamp === "string" ? luxon.DateTime.fromISO(it.timestamp) : luxon.DateTime.fromJSDate(it.timestamp);
-        return {
-          id: it.id,
-          entity: { namespace, kind, name },
-          timestamp,
-          version: it.version,
-          facts: JSON.parse(it.facts)
-        };
-      }),
-      "id"
-    );
-  }
-  async getLatestSchema(id) {
-    const existingSchemas = await this.db("fact_schemas").where({ id }).orderBy("id", "desc").select();
-    if (existingSchemas.length < 1) {
-      this.logger.warn(`No schema found for ${id}. `);
-      throw new Error(`No schema found for ${id}. `);
-    }
-    const sorted = semver.rsort(existingSchemas.map((it) => it.version));
-    return existingSchemas.find((it) => it.version === sorted[0]);
-  }
-  async deleteExpiredFactsByDate(tx, factRetrieverId, timestamp) {
-    await tx("facts").where({ id: factRetrieverId }).and.where("timestamp", "<", timestamp.toISO()).delete();
-  }
-  async deleteExpiredFactsByNumber(tx, factRetrieverId, maxItems) {
-    const deletionFilterQuery = (subTx) => subTx.select(["id", "entity", "timestamp"]).from("facts").where({ id: factRetrieverId }).and.whereIn(
-      "entity",
-      (db) => db.distinct("entity").where({ id: factRetrieverId })
-    ).and.leftJoin(
-      (joinTable) => joinTable.select("*").from(
-        this.db("facts").column(
-          { fid: "id" },
-          { fentity: "entity" },
-          { ftimestamp: "timestamp" }
-        ).column(
-          this.db.raw(
-            "row_number() over (partition by id, entity order by timestamp desc) as fact_rank"
-          )
-        ).as("ranks")
-      ).where("fact_rank", "<=", maxItems).as("filterjoin"),
-      (joinClause) => {
-        joinClause.on("filterjoin.fid", "facts.id").on("filterjoin.fentity", "facts.entity").on("filterjoin.ftimestamp", "facts.timestamp");
-      }
-    ).whereNull("filterjoin.fid");
-    await tx("facts").whereIn(
-      ["id", "entity", "timestamp"],
-      (database) => deletionFilterQuery(database)
-    ).delete();
-  }
-  dbFactRowsToTechInsightFacts(rows) {
-    return rows.reduce((acc, it) => {
-      const { namespace, kind, name } = catalogModel.parseEntityRef(it.entity);
-      const timestamp = typeof it.timestamp === "string" ? luxon.DateTime.fromISO(it.timestamp) : luxon.DateTime.fromJSDate(it.timestamp);
-      return {
-        ...acc,
-        [it.id]: {
-          id: it.id,
-          entity: { namespace, kind, name },
-          timestamp,
-          version: it.version,
-          facts: JSON.parse(it.facts)
-        }
-      };
-    }, {});
-  }
-}
-
-const migrationsDir = backendPluginApi.resolvePackagePath(
-  "@backstage-community/plugin-tech-insights-backend",
-  "migrations"
-);
-const initializePersistenceContext = async (database, options) => {
-  const client = await database.getClient();
-  if (!database.migrations?.skip) {
-    await client.migrate.latest({
-      directory: migrationsDir
-    });
-  }
-  return {
-    techInsightsStore: new TechInsightsDatabase(client, options.logger)
-  };
-};
-
-async function createRouter(options) {
-  const router = Router__default.default();
-  router.use(express__default.default.json());
-  const { persistenceContext, factChecker, logger, config } = options;
-  const { techInsightsStore } = persistenceContext;
-  const factory = rootHttpRouter.MiddlewareFactory.create({ logger, config });
-  if (factChecker) {
-    logger.info("Fact checker configured. Enabling fact checking endpoints.");
-    router.get("/checks", async (_req, res) => {
-      return res.json(await factChecker.getChecks());
-    });
-    router.post("/checks/run/:namespace/:kind/:name", async (req, res) => {
-      const { namespace, kind, name } = req.params;
-      const { checks } = req.body;
-      const entityTriplet = catalogModel.stringifyEntityRef({ namespace, kind, name });
-      const checkResult = await factChecker.runChecks(entityTriplet, checks);
-      return res.json(checkResult);
-    });
-    const checksRunConcurrency = config.getOptionalNumber("techInsights.checksRunConcurrency") || 100;
-    router.post("/checks/run", async (req, res) => {
-      const checks = req.body.checks;
-      let entities = req.body.entities;
-      if (entities.length === 0) {
-        entities = await techInsightsStore.getEntities();
-      }
-      const limit = pLimit__default.default(checksRunConcurrency);
-      const tasks = entities.map(
-        async (entity) => limit(async () => {
-          const entityTriplet = typeof entity === "string" ? entity : catalogModel.stringifyEntityRef(entity);
-          try {
-            const results2 = await factChecker.runChecks(entityTriplet, checks);
-            return {
-              entity: entityTriplet,
-              results: results2
-            };
-          } catch (e) {
-            const error = errors.serializeError(e);
-            logger.error(`${error.name}: ${error.message}`);
-            return {
-              entity: entityTriplet,
-              error,
-              results: []
-            };
-          }
-        })
-      );
-      const results = await Promise.all(tasks);
-      return res.json(results);
-    });
-  } else {
-    logger.info(
-      "Starting tech insights module without fact checking endpoints."
-    );
-  }
-  router.get("/fact-schemas", async (req, res) => {
-    const ids = req.query.ids;
-    return res.json(await techInsightsStore.getLatestSchemas(ids));
-  });
-  router.get("/facts/latest", async (req, res) => {
-    const { entity } = req.query;
-    const { namespace, kind, name } = catalogModel.parseEntityRef(entity);
-    if (!req.query.ids) {
-      return res.status(422).json({ error: "Failed to parse ids from request" });
-    }
-    const ids = [req.query.ids].flat();
-    return res.json(
-      await techInsightsStore.getLatestFactsByIds(
-        ids,
-        catalogModel.stringifyEntityRef({ namespace, kind, name })
-      )
-    );
-  });
-  router.get("/facts/range", async (req, res) => {
-    const { entity } = req.query;
-    const { namespace, kind, name } = catalogModel.parseEntityRef(entity);
-    if (!req.query.ids) {
-      return res.status(422).json({ error: "Failed to parse ids from request" });
-    }
-    const ids = [req.query.ids].flat();
-    const startDatetime = luxon.DateTime.fromISO(req.query.startDatetime);
-    const endDatetime = luxon.DateTime.fromISO(req.query.endDatetime);
-    if (!startDatetime.isValid || !endDatetime.isValid) {
-      return res.status(422).json({
-        message: "Failed to parse datetime from request",
-        field: !startDatetime.isValid ? "startDateTime" : "endDateTime",
-        value: !startDatetime.isValid ? startDatetime : endDatetime
-      });
-    }
-    const entityTriplet = catalogModel.stringifyEntityRef({ namespace, kind, name });
-    return res.json(
-      await techInsightsStore.getFactsBetweenTimestampsByIds(
-        ids,
-        entityTriplet,
-        startDatetime,
-        endDatetime
-      )
-    );
-  });
-  router.use(factory.error());
-  return router;
-}
-
-function randomDailyCron() {
-  const rand = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);
-  return `${rand(0, 59)} ${rand(0, 23)} * * *`;
-}
-function duration(startTimestamp) {
-  const delta = process.hrtime(startTimestamp);
-  const seconds = delta[0] + delta[1] / 1e9;
-  return `${seconds.toFixed(1)}s`;
-}
-class DefaultFactRetrieverEngine {
-  constructor(repository, factRetrieverRegistry, factRetrieverContext, logger, scheduler, defaultCadence, defaultTimeout, defaultInitialDelay) {
-    this.repository = repository;
-    this.factRetrieverRegistry = factRetrieverRegistry;
-    this.factRetrieverContext = factRetrieverContext;
-    this.logger = logger;
-    this.scheduler = scheduler;
-    this.defaultCadence = defaultCadence;
-    this.defaultTimeout = defaultTimeout;
-    this.defaultInitialDelay = defaultInitialDelay;
-  }
-  static async create(options) {
-    const {
-      repository,
-      factRetrieverRegistry,
-      factRetrieverContext,
-      scheduler,
-      defaultCadence,
-      defaultTimeout,
-      defaultInitialDelay
-    } = options;
-    const retrievers = await factRetrieverRegistry.listRetrievers();
-    await Promise.all(retrievers.map((it) => repository.insertFactSchema(it)));
-    return new DefaultFactRetrieverEngine(
-      repository,
-      factRetrieverRegistry,
-      factRetrieverContext,
-      factRetrieverContext.logger,
-      scheduler,
-      defaultCadence,
-      defaultTimeout,
-      defaultInitialDelay
-    );
-  }
-  async schedule() {
-    const registrations = await this.factRetrieverRegistry.listRegistrations();
-    const newRegs = [];
-    await Promise.all(
-      registrations.map(async (registration) => {
-        const { factRetriever, cadence, lifecycle, timeout, initialDelay } = registration;
-        const cronExpression = cadence || this.defaultCadence || randomDailyCron();
-        const timeLimit = timeout || this.defaultTimeout || luxon.Duration.fromObject({ minutes: 5 });
-        const initialDelaySetting = initialDelay || this.defaultInitialDelay || luxon.Duration.fromObject({ seconds: 5 });
-        try {
-          await this.scheduler.scheduleTask({
-            id: factRetriever.id,
-            frequency: { cron: cronExpression },
-            fn: this.createFactRetrieverHandler(factRetriever, lifecycle),
-            timeout: timeLimit,
-            // We add a delay in order to prevent errors due to the
-            // fact that the backend is not yet online in a cold-start scenario
-            initialDelay: initialDelaySetting
-          });
-          newRegs.push(factRetriever.id);
-        } catch (e) {
-          this.logger.warn(
-            `Failed to schedule fact retriever ${factRetriever.id}, ${e}`
-          );
-        }
-      })
-    );
-    this.logger.info(
-      `Scheduled ${newRegs.length}/${registrations.length} fact retrievers into the tech-insights engine`
-    );
-  }
-  getJobRegistration(ref) {
-    return this.factRetrieverRegistry.get(ref);
-  }
-  async triggerJob(ref) {
-    await this.scheduler.triggerTask(ref);
-  }
-  createFactRetrieverHandler(factRetriever, lifecycle) {
-    return async () => {
-      const startTimestamp = process.hrtime();
-      this.logger.info(
-        `Retrieving facts for fact retriever ${factRetriever.id}`
-      );
-      let facts = [];
-      try {
-        facts = await factRetriever.handler({
-          ...this.factRetrieverContext,
-          logger: this.logger.child({ factRetrieverId: factRetriever.id }),
-          entityFilter: factRetriever.entityFilter
-        });
-        this.logger.debug(
-          `Retrieved ${facts.length} facts for fact retriever ${factRetriever.id} in ${duration(startTimestamp)}`
-        );
-      } catch (e) {
-        this.logger.error(
-          `Failed to retrieve facts for retriever ${factRetriever.id}`,
-          e
-        );
-      }
-      try {
-        await this.repository.insertFacts({
-          id: factRetriever.id,
-          facts,
-          lifecycle
-        });
-        this.logger.info(
-          `Stored ${facts.length} facts for fact retriever ${factRetriever.id} in ${duration(startTimestamp)}`
-        );
-      } catch (e) {
-        this.logger.warn(
-          `Failed to insert facts for fact retriever ${factRetriever.id}`,
-          e
-        );
-      }
-    };
-  }
-}
-
-class DefaultFactRetrieverRegistry {
-  retrievers = /* @__PURE__ */ new Map();
-  constructor(retrievers) {
-    retrievers.forEach((r) => {
-      this.registerSync(r);
-    });
-  }
-  registerSync(registration) {
-    if (this.retrievers.has(registration.factRetriever.id)) {
-      throw new errors.ConflictError(
-        `Tech insight fact retriever with identifier '${registration.factRetriever.id}' has already been registered`
-      );
-    }
-    this.retrievers.set(registration.factRetriever.id, registration);
-  }
-  async register(registration) {
-    this.registerSync(registration);
-  }
-  async get(retrieverReference) {
-    const registration = this.retrievers.get(retrieverReference);
-    if (!registration) {
-      throw new errors.NotFoundError(
-        `Tech insight fact retriever with identifier '${retrieverReference}' is not registered.`
-      );
-    }
-    return registration;
-  }
-  async listRetrievers() {
-    return [...this.retrievers.values()].map((it) => it.factRetriever);
-  }
-  async listRegistrations() {
-    return [...this.retrievers.values()];
-  }
-  async getSchemas() {
-    const retrievers = await this.listRetrievers();
-    return retrievers.map((it) => it.schema);
-  }
-}
-
-const buildTechInsightsContext = async (options) => {
-  const {
-    factRetrievers,
-    factCheckerFactory,
-    config,
-    discovery,
-    database,
-    logger,
-    scheduler,
-    auth
-  } = options;
-  const buildFactRetrieverRegistry = () => {
-    if (!options.factRetrieverRegistry) {
-      if (!factRetrievers) {
-        throw new Error(
-          "Failed to build FactRetrieverRegistry because no factRetrievers found"
-        );
-      }
-      return new DefaultFactRetrieverRegistry(factRetrievers);
-    }
-    return options.factRetrieverRegistry;
-  };
-  const factRetrieverRegistry = buildFactRetrieverRegistry();
-  const persistenceContext = options.persistenceContext ?? await initializePersistenceContext(database, {
-    logger
-  });
-  const factRetrieverEngine = await DefaultFactRetrieverEngine.create({
-    scheduler,
-    repository: persistenceContext.techInsightsStore,
-    factRetrieverRegistry,
-    factRetrieverContext: {
-      config,
-      discovery,
-      logger,
-      auth
-    }
-  });
-  await factRetrieverEngine.schedule();
-  if (factCheckerFactory) {
-    const factChecker = factCheckerFactory.construct(
-      persistenceContext.techInsightsStore
-    );
-    return {
-      persistenceContext,
-      factChecker,
-      factRetrieverEngine
-    };
-  }
-  return {
-    persistenceContext,
-    factRetrieverEngine
-  };
-};
-
-function readLifecycleConfig(config$1) {
-  if (!config$1) {
-    return void 0;
-  }
-  if (config$1.has("maxItems")) {
-    return {
-      maxItems: config$1.getNumber("maxItems")
-    };
-  }
-  return {
-    timeToLive: config.readDurationFromConfig(config$1.getConfig("timeToLive"))
-  };
-}
-function readFactRetrieverConfig(config$1, name) {
-  const factRetrieverConfig = config$1.getOptionalConfig(
-    `techInsights.factRetrievers.${name}`
-  );
-  if (!factRetrieverConfig) {
-    return void 0;
-  }
-  const cadence = factRetrieverConfig.getString("cadence");
-  const initialDelay = factRetrieverConfig.has("initialDelay") ? config.readDurationFromConfig(factRetrieverConfig.getConfig("initialDelay")) : void 0;
-  const lifecycle = readLifecycleConfig(
-    factRetrieverConfig.getOptionalConfig("lifecycle")
-  );
-  const timeout = factRetrieverConfig.has("timeout") ? config.readDurationFromConfig(factRetrieverConfig.getConfig("timeout")) : void 0;
-  return {
-    cadence,
-    initialDelay,
-    lifecycle,
-    timeout
-  };
-}
-function createFactRetrieverRegistrationFromConfig(config, name, factRetriever) {
-  const factRetrieverConfig = readFactRetrieverConfig(config, name);
-  return factRetrieverConfig ? createFactRetrieverRegistration({
-    ...factRetrieverConfig,
-    factRetriever
-  }) : void 0;
-}
-
-const techInsightsPlugin = backendPluginApi.createBackendPlugin({
-  pluginId: "tech-insights",
-  register(env) {
-    let factCheckerFactory = void 0;
-    env.registerExtensionPoint(pluginTechInsightsNode.techInsightsFactCheckerFactoryExtensionPoint, {
-      setFactCheckerFactory(factory) {
-        factCheckerFactory = factory;
-      }
-    });
-    let factRetrieverRegistry = void 0;
-    env.registerExtensionPoint(
-      pluginTechInsightsNode.techInsightsFactRetrieverRegistryExtensionPoint,
-      {
-        setFactRetrieverRegistry(registry) {
-          factRetrieverRegistry = registry;
-        }
-      }
-    );
-    const addedFactRetrievers = {
-      entityMetadataFactRetriever,
-      entityOwnershipFactRetriever,
-      techdocsFactRetriever
-    };
-    env.registerExtensionPoint(pluginTechInsightsNode.techInsightsFactRetrieversExtensionPoint, {
-      addFactRetrievers(factRetrievers) {
-        Object.entries(factRetrievers).forEach(([key, value]) => {
-          addedFactRetrievers[key] = value;
-        });
-      }
-    });
-    let persistenceContext = void 0;
-    env.registerExtensionPoint(pluginTechInsightsNode.techInsightsPersistenceContextExtensionPoint, {
-      setPersistenceContext(context) {
-        persistenceContext = context;
-      }
-    });
-    env.registerInit({
-      deps: {
-        config: backendPluginApi.coreServices.rootConfig,
-        database: backendPluginApi.coreServices.database,
-        discovery: backendPluginApi.coreServices.discovery,
-        httpRouter: backendPluginApi.coreServices.httpRouter,
-        logger: backendPluginApi.coreServices.logger,
-        scheduler: backendPluginApi.coreServices.scheduler,
-        auth: backendPluginApi.coreServices.auth
-      },
-      async init({
-        config,
-        database,
-        discovery,
-        httpRouter,
-        logger,
-        scheduler,
-        auth
-      }) {
-        const factRetrievers = Object.entries(
-          addedFactRetrievers
-        ).map(
-          ([name, factRetriever]) => createFactRetrieverRegistrationFromConfig(
-            config,
-            name,
-            factRetriever
-          )
-        ).filter((registration) => registration);
-        const context = await buildTechInsightsContext({
-          config,
-          database,
-          discovery,
-          factCheckerFactory,
-          factRetrieverRegistry,
-          factRetrievers,
-          logger,
-          persistenceContext,
-          scheduler,
-          auth
-        });
-        httpRouter.use(
-          await createRouter({
-            ...context,
-            config,
-            logger
-          })
-        );
-      }
-    });
-  }
-});
-
-exports.buildTechInsightsContext = buildTechInsightsContext;
-exports.createFactRetrieverRegistration = createFactRetrieverRegistration;
-exports.createRouter = createRouter;
-exports.default = techInsightsPlugin;
-exports.entityMetadataFactRetriever = entityMetadataFactRetriever;
-exports.entityOwnershipFactRetriever = entityOwnershipFactRetriever;
-exports.initializePersistenceContext = initializePersistenceContext;
-exports.techdocsFactRetriever = techdocsFactRetriever;
+var plugin = require('./plugin/plugin.cjs.js');
+var createFactRetriever = require('./service/fact/createFactRetriever.cjs.js');
+var entityMetadataFactRetriever = require('./service/fact/factRetrievers/entityMetadataFactRetriever.cjs.js');
+var entityOwnershipFactRetriever = require('./service/fact/factRetrievers/entityOwnershipFactRetriever.cjs.js');
+var techdocsFactRetriever = require('./service/fact/factRetrievers/techdocsFactRetriever.cjs.js');
+var persistenceContext = require('./service/persistence/persistenceContext.cjs.js');
+var router = require('./service/router.cjs.js');
+var techInsightsContextBuilder = require('./service/techInsightsContextBuilder.cjs.js');
+
+
+
+exports.default = plugin.techInsightsPlugin;
+exports.createFactRetrieverRegistration = createFactRetriever.createFactRetrieverRegistration;
+exports.entityMetadataFactRetriever = entityMetadataFactRetriever.entityMetadataFactRetriever;
+exports.entityOwnershipFactRetriever = entityOwnershipFactRetriever.entityOwnershipFactRetriever;
+exports.techdocsFactRetriever = techdocsFactRetriever.techdocsFactRetriever;
+exports.initializePersistenceContext = persistenceContext.initializePersistenceContext;
+exports.createRouter = router.createRouter;
+exports.buildTechInsightsContext = techInsightsContextBuilder.buildTechInsightsContext;
 //# sourceMappingURL=index.cjs.js.map