@backstage-community/plugin-tech-insights-backend 0.5.32

package/dist/index.cjs.js

@@ -0,0 +1,826 @@
+'use strict';
+
+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 backendCommon = require('@backstage/backend-common');
+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 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);
+
+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) => {
+      var _a, _b, _c;
+      return {
+        entity: {
+          namespace: entity.metadata.namespace,
+          kind: entity.kind,
+          name: entity.metadata.name
+        },
+        facts: {
+          hasTitle: Boolean((_a = entity.metadata) == null ? void 0 : _a.title),
+          hasDescription: Boolean((_b = entity.metadata) == null ? void 0 : _b.description),
+          hasTags: !isEmpty__default.default((_c = entity.metadata) == null ? void 0 : _c.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) => {
+      var _a, _b, _c;
+      return {
+        entity: {
+          namespace: entity.metadata.namespace,
+          kind: entity.kind,
+          name: entity.metadata.name
+        },
+        facts: {
+          hasOwner: Boolean((_a = entity.spec) == null ? void 0 : _a.owner),
+          hasGroupOwner: Boolean(
+            ((_b = entity.spec) == null ? void 0 : _b.owner) && !((_c = entity.spec) == null ? void 0 : _c.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 techdocsAnnotationFactName = generateAnnotationFactName(techdocsAnnotation);
+const techdocsFactRetriever = {
+  id: "techdocsFactRetriever",
+  version: "0.0.1",
+  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"
+    }
+  },
+  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
+          )
+        }
+      };
+    });
+  }
+};
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class TechInsightsDatabase {
+  constructor(db, logger) {
+    this.db = db;
+    this.logger = logger;
+    __publicField$1(this, "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) => {
+      var _a;
+      const ts = (_a = it.timestamp) == null ? void 0 : _a.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 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 = backendCommon.resolvePackagePath(
+  "@backstage-community/plugin-tech-insights-backend",
+  "migrations"
+);
+const defaultOptions = {
+  logger: backendCommon.getVoidLogger()
+};
+const initializePersistenceContext = async (database, options = defaultOptions) => {
+  var _a;
+  const client = await database.getClient();
+  if (!((_a = database.migrations) == null ? void 0 : _a.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 } = options;
+  const { techInsightsStore } = persistenceContext;
+  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);
+    });
+    router.post("/checks/run", async (req, res) => {
+      const {
+        checks,
+        entities
+      } = req.body;
+      const tasks = entities.map(async (entity) => {
+        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(backendCommon.errorHandler());
+  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
+        );
+      }
+    };
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class DefaultFactRetrieverRegistry {
+  constructor(retrievers) {
+    __publicField(this, "retrievers", /* @__PURE__ */ new Map());
+    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) => {
+  var _a;
+  const {
+    factRetrievers,
+    factCheckerFactory,
+    config,
+    discovery,
+    database,
+    logger,
+    scheduler,
+    tokenManager
+  } = 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 = (_a = options.persistenceContext) != null ? _a : await initializePersistenceContext(database, {
+    logger
+  });
+  const { auth } = backendCommon.createLegacyAuthAdapters({
+    auth: options.auth,
+    tokenManager,
+    discovery
+  });
+  const factRetrieverEngine = await DefaultFactRetrieverEngine.create({
+    scheduler,
+    repository: persistenceContext.techInsightsStore,
+    factRetrieverRegistry,
+    factRetrieverContext: {
+      config,
+      discovery,
+      logger,
+      tokenManager,
+      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,
+        tokenManager: backendPluginApi.coreServices.tokenManager,
+        auth: backendPluginApi.coreServices.auth
+      },
+      async init({
+        config,
+        database,
+        discovery,
+        httpRouter,
+        logger,
+        scheduler,
+        tokenManager,
+        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,
+          tokenManager,
+          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;
+//# sourceMappingURL=index.cjs.js.map