@backstage/plugin-catalog-backend 1.1.0-next.1 → 1.1.0-next.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @backstage/plugin-catalog-backend
 
+## 1.1.0-next.2
+
+### Minor Changes
+
+- bf82edf4c9: Added `/validate-entity` endpoint
+
+### Patch Changes
+
+- 8592cacfd3: Fixed an issue where sometimes entities would have stale relations "stuck" and
+  not getting removed as expected, after the other end of the relation had stopped
+  referring to them.
+- Updated dependencies
+  - @backstage/catalog-model@1.0.1-next.1
+
 ## 1.1.0-next.1
 
 ### Minor Changes

package/README.md

@@ -27,8 +27,7 @@ restoring the plugin, if you previously removed it.
 
 ```bash
 # From your Backstage root directory
-cd packages/backend
-yarn add @backstage/plugin-catalog-backend
+yarn add --cwd packages/backend @backstage/plugin-catalog-backend
 ```
 
 ### Adding the plugin to your `packages/backend`

package/alpha/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backstage/plugin-catalog-backend",
-  "version": "1.1.0-next.1",
+  "version": "1.1.0-next.2",
   "main": "../dist/index.cjs.js",
   "types": "../dist/index.alpha.d.ts"
 }

package/dist/index.cjs.js

@@ -1318,7 +1318,13 @@ class DefaultProcessingDatabase {
       entities: deferredEntities,
       sourceEntityRef: catalogModel.stringifyEntityRef(processedEntity)
     });
-    await tx("relations").where({ originating_entity_id: id }).delete();
+    let previousRelationRows;
+    if (tx.client.config.client.includes("sqlite3")) {
+      previousRelationRows = await tx("relations").select("*").where({ originating_entity_id: id });
+      await tx("relations").where({ originating_entity_id: id }).delete();
+    } else {
+      previousRelationRows = await tx("relations").where({ originating_entity_id: id }).delete().returning("*");
+    }
     const relationRows = relations.map(({ source, target, type }) => ({
       originating_entity_id: id,
       source_entity_ref: catalogModel.stringifyEntityRef(source),
@@ -1326,6 +1332,11 @@ class DefaultProcessingDatabase {
       type
     }));
     await tx.batchInsert("relations", this.deduplicateRelations(relationRows), BATCH_SIZE$1);
+    return {
+      previous: {
+        relations: previousRelationRows
+      }
+    };
   }
   async updateProcessedEntityErrors(txOpaque, options) {
     const tx = txOpaque;
@@ -1802,8 +1813,9 @@ class DefaultCatalogProcessingEngine {
             return;
           }
           result.completedEntity.metadata.uid = id;
+          let oldRelationSources;
           await this.processingDatabase.transaction(async (tx) => {
-            await this.processingDatabase.updateProcessedEntity(tx, {
+            const { previous } = await this.processingDatabase.updateProcessedEntity(tx, {
               id,
               processedEntity: result.completedEntity,
               resultHash,
@@ -1812,11 +1824,22 @@ class DefaultCatalogProcessingEngine {
               deferredEntities: result.deferredEntities,
               locationKey
             });
+            oldRelationSources = new Set(previous.relations.map((r) => r.source_entity_ref));
           });
+          const newRelationSources = new Set(result.relations.map((relation) => catalogModel.stringifyEntityRef(relation.source)));
           const setOfThingsToStitch = /* @__PURE__ */ new Set([
-            catalogModel.stringifyEntityRef(result.completedEntity),
-            ...result.relations.map((relation) => catalogModel.stringifyEntityRef(relation.source))
+            catalogModel.stringifyEntityRef(result.completedEntity)
           ]);
+          newRelationSources.forEach((r) => {
+            if (!oldRelationSources.has(r)) {
+              setOfThingsToStitch.add(r);
+            }
+          });
+          oldRelationSources.forEach((r) => {
+            if (!newRelationSources.has(r)) {
+              setOfThingsToStitch.add(r);
+            }
+          });
           await this.stitcher.stitch(setOfThingsToStitch);
           track.markSuccessfulWithChanges(setOfThingsToStitch.size);
         } catch (error) {
@@ -2866,6 +2889,7 @@ async function createRouter(options) {
     entitiesCatalog,
     locationAnalyzer,
     locationService,
+    orchestrator,
     refreshService,
     config,
     logger,
@@ -2988,6 +3012,46 @@ async function createRouter(options) {
       res.status(200).json(output);
     });
   }
+  if (orchestrator) {
+    router.post("/validate-entity", async (req, res) => {
+      const bodySchema = zod.z.object({
+        entity: zod.z.unknown(),
+        location: zod.z.string()
+      });
+      let body;
+      let entity;
+      let location;
+      try {
+        body = await validateRequestBody(req, bodySchema);
+        entity = validateEntityEnvelope(body.entity);
+        location = catalogModel.parseLocationRef(body.location);
+        if (location.type !== "url")
+          throw new TypeError(`Invalid location ref ${body.location}, only 'url:<target>' is supported, e.g. url:https://host/path`);
+      } catch (err) {
+        return res.status(400).json({
+          errors: [errors.serializeError(err)]
+        });
+      }
+      const processingResult = await orchestrator.process({
+        entity: {
+          ...entity,
+          metadata: {
+            ...entity.metadata,
+            annotations: {
+              [catalogModel.ANNOTATION_LOCATION]: body.location,
+              [catalogModel.ANNOTATION_ORIGIN_LOCATION]: body.location,
+              ...entity.metadata.annotations
+            }
+          }
+        }
+      });
+      if (!processingResult.ok)
+        res.status(400).json({
+          errors: processingResult.errors.map((e) => errors.serializeError(e))
+        });
+      return res.status(200).end();
+    });
+  }
   router.use(backendCommon.errorHandler());
   return router;
 }
@@ -3441,6 +3505,7 @@ class CatalogBuilder {
       entitiesCatalog,
       locationAnalyzer,
       locationService,
+      orchestrator,
       refreshService,
       logger,
       config,