@checkstack/dependency-backend 1.1.6 → 1.3.0

package/src/router.ts

@@ -16,11 +16,17 @@ import type {
   WarningEvaluationService,
   SystemStatus,
 } from "./services/warning-evaluation-service";
-import { dependencyHooks } from "./hooks";
 import type { InferClient } from "@checkstack/common";
 import { extractErrorMessage } from "@checkstack/common";
 import { CatalogApi } from "@checkstack/catalog-common";
 import { HealthCheckApi } from "@checkstack/healthcheck-common";
+import type { EntityHandle } from "@checkstack/automation-backend";
+import {
+  removeDependencyEdge,
+  toDependencyEdgeState,
+  writeDependencyEdge,
+  type DependencyEdgeState,
+} from "./dependency-entity";
 
 export function createRouter({
   service,
@@ -29,6 +35,7 @@ export function createRouter({
   catalogClient,
   healthCheckClient,
   logger,
+  getDependencyEntity,
 }: {
   service: DependencyService;
   warningService: WarningEvaluationService;
@@ -36,6 +43,8 @@ export function createRouter({
   catalogClient: InferClient<typeof CatalogApi>;
   healthCheckClient: InferClient<typeof HealthCheckApi>;
   logger: Logger;
+  /** Resolver for the reactive `dependency-edge` entity (§10.5). */
+  getDependencyEntity?: () => EntityHandle<DependencyEdgeState> | undefined;
 }) {
   /**
    * Fetch system statuses for warning evaluation using the bulk health status API.
@@ -181,9 +190,27 @@ export function createRouter({
     ),
 
     createDependency: os.createDependency.handler(
-      async ({ input, context }) => {
+      async ({ input }) => {
         try {
-          const result = await service.createDependency(input);
+          // Drive the create through the reactive `dependency-edge` entity
+          // (§10.5): `apply` performs the REAL `dependencies` write (the
+          // plugin's own db/tx, including cycle/duplicate validation that may
+          // throw) and returns the new reactive state; the deriver fires
+          // `dependency.created` from the resulting change. The id is
+          // generated up front so the handle is keyed on it and the create's
+          // `prev` snapshot reads the not-yet-existing row as absent. A
+          // throwing `apply` means no transition is appended and nothing is
+          // emitted (the create never happened).
+          const dependencyId = crypto.randomUUID();
+          let result!: Awaited<ReturnType<typeof service.createDependency>>;
+          await writeDependencyEdge({
+            handle: getDependencyEntity?.(),
+            dependencyId,
+            apply: async () => {
+              result = await service.createDependency(input, dependencyId);
+              return toDependencyEdgeState(result);
+            },
+          });
 
           // Broadcast signal
           await signalService.broadcast(DEPENDENCY_CHANGED, {
@@ -193,14 +220,6 @@ export function createRouter({
             action: "created",
           });
 
-          // Emit hook
-          await context.emitHook(dependencyHooks.dependencyCreated, {
-            dependencyId: result.id,
-            sourceSystemId: result.sourceSystemId,
-            targetSystemId: result.targetSystemId,
-            impactType: result.impactType,
-          });
-
           // Notify affected systems about warning changes
           await signalService.broadcast(DEPENDENCY_WARNINGS_CHANGED, {
             affectedSystemIds: [result.sourceSystemId],
@@ -221,26 +240,43 @@ export function createRouter({
     ),
 
     updateDependency: os.updateDependency.handler(
-      async ({ input, context }) => {
-        const result = await service.updateDependency(input);
-        if (!result) {
+      async ({ input }) => {
+        // Probe existence first so a missing dependency still surfaces as
+        // NOT_FOUND without driving an entity write.
+        const exists = await service.getDependencyById(input.id);
+        if (!exists) {
           throw new ORPCError("NOT_FOUND", {
             message: "Dependency not found",
           });
         }
 
-        await signalService.broadcast(DEPENDENCY_CHANGED, {
-          dependencyId: result.id,
-          sourceSystemId: result.sourceSystemId,
-          targetSystemId: result.targetSystemId,
-          action: "updated",
+        // Drive the update through the reactive `dependency-edge` entity
+        // (§10.5); the REAL update runs INSIDE `apply`, so `prev` is
+        // snapshotted before the write and the deriver fires
+        // `dependency.updated` from the resulting change.
+        let result!: NonNullable<
+          Awaited<ReturnType<typeof service.updateDependency>>
+        >;
+        await writeDependencyEdge({
+          handle: getDependencyEntity?.(),
+          dependencyId: input.id,
+          apply: async () => {
+            const updated = await service.updateDependency(input);
+            if (!updated) {
+              throw new ORPCError("NOT_FOUND", {
+                message: "Dependency not found",
+              });
+            }
+            result = updated;
+            return toDependencyEdgeState(result);
+          },
         });
 
-        await context.emitHook(dependencyHooks.dependencyUpdated, {
+        await signalService.broadcast(DEPENDENCY_CHANGED, {
           dependencyId: result.id,
           sourceSystemId: result.sourceSystemId,
           targetSystemId: result.targetSystemId,
-          impactType: result.impactType,
+          action: "updated",
         });
 
         await signalService.broadcast(DEPENDENCY_WARNINGS_CHANGED, {
@@ -252,9 +288,22 @@ export function createRouter({
     ),
 
     deleteDependency: os.deleteDependency.handler(
-      async ({ input, context }) => {
+      async ({ input }) => {
         const existing = await service.getDependencyById(input.id);
-        const success = await service.deleteDependency(input.id);
+
+        // Drive the delete through the reactive `dependency-edge` entity
+        // tombstone (§10.5). The REAL delete runs INSIDE `apply`, so `prev`
+        // is snapshotted before it and the deriver fires `dependency.deleted`
+        // from the tombstone. `success` tracks whether the row was actually
+        // deleted.
+        let success = false;
+        await removeDependencyEdge({
+          handle: getDependencyEntity?.(),
+          dependencyId: input.id,
+          apply: async () => {
+            success = await service.deleteDependency(input.id);
+          },
+        });
 
         if (success && existing) {
           await signalService.broadcast(DEPENDENCY_CHANGED, {
@@ -264,12 +313,6 @@ export function createRouter({
             action: "deleted",
           });
 
-          await context.emitHook(dependencyHooks.dependencyDeleted, {
-            dependencyId: input.id,
-            sourceSystemId: existing.sourceSystemId,
-            targetSystemId: existing.targetSystemId,
-          });
-
           await signalService.broadcast(DEPENDENCY_WARNINGS_CHANGED, {
             affectedSystemIds: [existing.sourceSystemId],
           });

package/src/services/dependency-service.ts

@@ -11,6 +11,7 @@ import type {
   CreateDependencyInput,
   UpdateDependencyInput,
   NodePosition,
+  ImpactType,
 } from "@checkstack/dependency-common";
 
 type Db = SafeDatabase<typeof schema>;
@@ -59,8 +60,17 @@ export class DependencyService {
   /**
    * Create a new dependency with cycle detection.
    * Throws if the dependency would create a circular chain.
+   *
+   * `id` may be supplied by the caller so the reactive `dependency-edge`
+   * entity can be keyed on a known id BEFORE the insert runs (the create's
+   * `prev` snapshot must read the not-yet-existing row as absent — see
+   * §10.5). When omitted, a fresh id is generated. The id is server-owned
+   * either way.
    */
-  async createDependency(input: CreateDependencyInput): Promise<Dependency> {
+  async createDependency(
+    input: CreateDependencyInput,
+    id: string = generateId(),
+  ): Promise<Dependency> {
     // Check for duplicate edge
     const [existing] = await this.db
       .select()
@@ -90,7 +100,6 @@ export class DependencyService {
       );
     }
 
-    const id = generateId();
     await this.db.insert(dependencies).values({
       id,
       sourceSystemId: input.sourceSystemId,
@@ -213,12 +222,67 @@ export class DependencyService {
 
     return {
       ...row,
-       
+
       label: row.label ?? null,
       healthCheckRules: rules.length > 0 ? rules : undefined,
     };
   }
 
+  /**
+   * Batched reactive-state read for the `dependency-edge` entity (Model B
+   * plugin-backed `read` accessor). Given dependency ids, return the reactive
+   * subset `{ sourceSystemId, targetSystemId, impactType, transitive }` for
+   * each that exists (missing ids omitted). Reads the AUTHORITATIVE
+   * `dependencies` table — no framework `entity_state` storage. This is the
+   * single source of truth `handle.mutate` snapshots `prev` from and
+   * `get`/`getMany`/scope enrichment route through.
+   */
+  async getManyEntityStates(
+    ids: ReadonlyArray<string>,
+  ): Promise<
+    Record<
+      string,
+      {
+        sourceSystemId: string;
+        targetSystemId: string;
+        impactType: ImpactType;
+        transitive: boolean;
+      }
+    >
+  > {
+    if (ids.length === 0) return {};
+
+    const rows = await this.db
+      .select({
+        id: dependencies.id,
+        sourceSystemId: dependencies.sourceSystemId,
+        targetSystemId: dependencies.targetSystemId,
+        impactType: dependencies.impactType,
+        transitive: dependencies.transitive,
+      })
+      .from(dependencies)
+      .where(inArray(dependencies.id, [...ids]));
+
+    const out: Record<
+      string,
+      {
+        sourceSystemId: string;
+        targetSystemId: string;
+        impactType: ImpactType;
+        transitive: boolean;
+      }
+    > = {};
+    for (const row of rows) {
+      out[row.id] = {
+        sourceSystemId: row.sourceSystemId,
+        targetSystemId: row.targetSystemId,
+        impactType: row.impactType,
+        transitive: row.transitive,
+      };
+    }
+    return out;
+  }
+
   // ===========================================================================
   // NODE POSITIONS
   // ===========================================================================

package/tsconfig.json

@@ -4,6 +4,9 @@
     "src"
   ],
   "references": [
+    {
+      "path": "../automation-backend"
+    },
     {
       "path": "../backend-api"
     },