@smthrs/notifications 1.0.0-rc.7 → 1.0.0-rc.9

package/src/Projection.ts

@@ -7,6 +7,7 @@
 import { Projection as JournalProjection } from "@smthrs/journal"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
+import * as Replay from "./internal/replay.ts"
 import * as NotificationEvent from "./NotificationEvent.ts"
 import * as NotificationState from "./NotificationState.ts"
 
@@ -18,7 +19,10 @@ import * as NotificationState from "./NotificationState.ts"
  * `NotificationState.applyAdmission` applies the decision each record already
  * committed, and an admitted record is retained however many are pending. A
  * composition built with `NotificationQueue.layerWith` above the default
- * replays every admission it wrote.
+ * replays every admission it wrote. A versioned edit of a steer that is still
+ * pending replaces that item in place, exactly as the queue's own fold reads
+ * it, so an edited steer projects as one pending item rather than one per
+ * version.
  *
  * The projected `capacity` is `NotificationState.defaultCapacity` because the
  * initial state has to start somewhere and no journal record carries the bound
@@ -37,9 +41,7 @@ export const derive = JournalProjection.make({
 
     const event = decoded.value
     if (NotificationEvent.isAdmitted(event)) {
-      return Effect.succeed(
-        NotificationState.applyAdmission(state, event.notification, entry.seq, event.decision)
-      )
+      return Effect.succeed(Replay.applyAdmitted(state, event, entry.seq))
     }
     return Effect.succeed(NotificationState.applyPromoted(state, event.ids))
   }

package/src/internal/replay.ts

@@ -0,0 +1,39 @@
+/**
+ * The one replay rule for an admission record, shared by the queue's fold and
+ * the journal projection so the two read the same history to the same state.
+ *
+ * @private
+ * @since 1.0.0
+ */
+
+import type * as NotificationEvent from "../NotificationEvent.ts"
+import * as NotificationState from "../NotificationState.ts"
+
+/**
+ * Applies one committed admission record to the state so far.
+ *
+ * A versioned record whose id is still pending is an edit: it replaces that
+ * item in place and keeps its original sequence, so the edit is delivered at
+ * the cutoff the first version was admitted under. Every other record applies
+ * the decision it committed.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const applyAdmitted = (
+  state: NotificationState.State,
+  event: NotificationEvent.Admitted,
+  seq: number
+): NotificationState.State => {
+  if (event.version !== undefined && state.items.some((item) => item.notification.id === event.notification.id)) {
+    return Object.freeze({
+      ...state,
+      items: Object.freeze(state.items.map((item) =>
+        item.notification.id === event.notification.id
+          ? Object.freeze({ notification: event.notification, seq: item.seq })
+          : item
+      ))
+    })
+  }
+  return NotificationState.applyAdmission(state, event.notification, seq, event.decision)
+}