@knpkv/herdr-work 0.8.1 → 0.9.0

package/dist/store.js

@@ -2812,7 +2812,15 @@ export class WorkStore {
      * succeeds), so a writer that planned from the head cannot bury a newer
      * owner checkpoint.
      */
-    appendAt = Effect.fn("WorkStore.append")(function* (event, guard) {
+    /**
+     * Appends one checkpoint. With `mode` `check`, every check runs in the same
+     * transaction and it is rolled back instead of written: the checkpoint is
+     * returned when it would have been appended.
+     */
+    appendAt = Effect.fn("WorkStore.append")(function* (event, guard, mode = "write", 
+    // In a check, the checkpoints earlier steps of the same plan would have
+    // written: limits are checked as if they were already stored.
+    planned = []) {
         const decoded = yield* Schema.decodeUnknownEffect(WorkGoalCheckpoint)(event).pipe(Effect.mapError(storeError("append.decode")));
         // The reconciler's event and activity ids are its provenance; no other
         // writer may use them.
@@ -2827,11 +2835,12 @@ export class WorkStore {
         const decision = yield* Effect.try({
             try: () => {
                 let transaction = false;
+                const abort = () => this.#database.exec("ROLLBACK");
                 try {
                     this.#database.exec("BEGIN IMMEDIATE");
                     transaction = true;
                     const reject = (error) => {
-                        this.#database.exec("ROLLBACK");
+                        abort();
                         transaction = false;
                         return { _tag: "rejected", error };
                     };
@@ -2840,7 +2849,7 @@ export class WorkStore {
                  WHERE event_id = ? OR (goal_id = ? AND occurred_at = ?)`)
                         .all(decoded.eventId, decoded.goal.id, decoded.occurredAt)).map(({ record }) => Schema.decodeUnknownSync(WorkGoalCheckpoint)(JSON.parse(record)));
                     if (collisions.length > 0 && collisions.every((existing) => Equal.equals(existing, decoded))) {
-                        this.#database.exec("ROLLBACK");
+                        abort();
                         transaction = false;
                         return { _tag: "replayed", event: decoded };
                     }
@@ -2868,7 +2877,7 @@ export class WorkStore {
                             }));
                         }
                         const count = Schema.decodeUnknownSync(CountRow)(this.#database.prepare("SELECT COUNT(*) AS count FROM work_goal_events").get()).count;
-                        if (count + 1 > workHistoryMaxEvents - guard.reserve) {
+                        if (count + planned.length + 1 > workHistoryMaxEvents - guard.reserve) {
                             return reject(new WorkProjectionError({
                                 cause: count,
                                 detail: `the reconciler leaves ${guard.reserve} of ${workHistoryMaxEvents} checkpoints free`,
@@ -2884,14 +2893,15 @@ export class WorkStore {
                         }));
                     }
                     const eventCount = Schema.decodeUnknownSync(CountRow)(this.#database.prepare("SELECT COUNT(*) AS count FROM work_goal_events").get()).count;
-                    if (eventCount >= workHistoryMaxEvents) {
+                    if (eventCount + planned.length >= workHistoryMaxEvents) {
                         return reject(new WorkProjectionError({
                             cause: decoded,
                             detail: `work history cannot exceed ${workHistoryMaxEvents} checkpoints`,
                             reason: "capacity_exceeded"
                         }));
                     }
-                    const history = Schema.decodeUnknownSync(StoredEventRows)(this.#database.prepare("SELECT record FROM work_goal_events").all()).map(({ record }) => Schema.decodeUnknownSync(WorkGoalCheckpoint)(JSON.parse(record)));
+                    const history = Schema.decodeUnknownSync(StoredEventRows)(this.#database.prepare("SELECT record FROM work_goal_events").all()).map(({ record }) => Schema.decodeUnknownSync(WorkGoalCheckpoint)(JSON.parse(record)))
+                        .concat(planned);
                     const familyError = validateGoalFamilyHistory([...history, decoded]);
                     if (familyError !== undefined)
                         return reject(familyError);
@@ -2930,6 +2940,11 @@ export class WorkStore {
                             }));
                         }
                     }
+                    if (mode === "check") {
+                        abort();
+                        transaction = false;
+                        return { _tag: "checked" };
+                    }
                     const result = this.#database.prepare("INSERT INTO work_goal_events (event_id, goal_id, occurred_at, record) VALUES (?, ?, ?, ?)").run(decoded.eventId, decoded.goal.id, decoded.occurredAt, JSON.stringify(decoded));
                     // The reconciler's own record of what it wrote: its authorship and its
                     // once-per-goal rule come from this table, never from an id's spelling.
@@ -2942,7 +2957,7 @@ export class WorkStore {
                 }
                 catch (error) {
                     if (transaction)
-                        this.#database.exec("ROLLBACK");
+                        abort();
                     throw error;
                 }
             },
@@ -2952,6 +2967,8 @@ export class WorkStore {
             return yield* decision.error;
         if (decision._tag === "replayed")
             return decision.event;
+        if (decision._tag === "checked")
+            return decoded;
         if (decision.changes !== 1 && decision.changes !== 1n) {
             return yield* storeError("append.insert.count")(decision.changes);
         }
@@ -4041,7 +4058,11 @@ export class WorkStore {
             reconcilerEvents
         };
     });
-    reconcile = Effect.fn("WorkStore.reconcile")(function* (request) {
+    /**
+     * The steps `reconcile` takes, shared by `reconcile` (`write`) and
+     * `planReconcile` (`check`, which runs every check and writes nothing).
+     */
+    reconcileSteps = Effect.fn("WorkStore.reconcileSteps")(function* (request, mode) {
         const options = yield* Schema.decodeUnknownEffect(WorkReconcileOptions)(request).pipe(Effect.mapError(storeError("reconcile.options")));
         const source = yield* this.snapshotInput();
         if (workHistoryMaxEvents - source.events.length < workReconcilerHeadroom) {
@@ -4063,7 +4084,13 @@ export class WorkStore {
         const stamped = new Map(source.reconcilerEvents.map(({ eventId, goalId }) => [goalId, eventId]));
         const cryptoService = this.#cryptoService;
         const now = yield* Clock.currentTimeMillis;
-        const appendAt = (checkpoint, guard) => this.appendAt(checkpoint, guard);
+        // A plan holds no transaction between steps: each check rolls back at once,
+        // and later steps are checked against the checkpoints earlier ones planned.
+        const planned = [];
+        const appendAt = (checkpoint, guard) => this.appendAt(checkpoint, guard, mode, planned).pipe(Effect.tap(() => Effect.sync(() => {
+            if (mode === "check")
+                planned.push(checkpoint);
+        })));
         return yield* Effect.forEach(terminalCandidates(source.events, source.facts, source.failures, new Set(options.confirmed.map(({ observationId, subject }) => `${subject}\u0000${observationId}`))), Effect.fnUntraced(function* (candidate) {
             const goalId = candidate.head.goal.id;
             const previous = stamped.get(goalId);
@@ -4076,7 +4103,7 @@ export class WorkStore {
             // holds the reconciler's id, a timestamp past the bound) is left for
             // its owner: reported as a conflict, never failing the other goals.
             if (Result.isFailure(checkpoint))
-                return { _tag: "conflict", goalId };
+                return { _tag: "conflict", goalId, reason: "checkpoint" };
             return yield* appendAt(checkpoint.success, {
                 fact: { observationId: candidate.fact.observationId, subject: candidate.fact.subject },
                 head: candidate.head,
@@ -4085,10 +4112,40 @@ export class WorkStore {
                 _tag: "applied",
                 eventId,
                 goalId,
-                state: candidate.pullRequest.state === "merged" ? "completed" : "abandoned"
-            }), Effect.catchTag("WorkGoalRevisionConflictError", () => Effect.succeed({ _tag: "conflict", goalId })));
+                state: candidate.pullRequest.state === "merged" ? "completed" : "abandoned",
+                candidate
+            }), Effect.catchTag("WorkGoalRevisionConflictError", () => Effect.succeed({ _tag: "conflict", goalId, reason: "revision" })));
         }));
     });
+    reconcile = Effect.fn("WorkStore.reconcile")(function* (request) {
+        const steps = yield* this.reconcileSteps(request, "write");
+        return steps.map((step) => step._tag === "applied"
+            ? { _tag: "applied", eventId: step.eventId, goalId: step.goalId, state: step.state }
+            : step._tag === "recorded"
+                ? step
+                : { _tag: "conflict", goalId: step.goalId });
+    });
+    /**
+     * What `reconcile` would do now with the same confirmations, writing
+     * nothing: every check it makes before writing runs, each in a transaction
+     * that is rolled back at once, with each step checked against the
+     * checkpoints earlier steps planned.
+     */
+    planReconcile = Effect.fn("WorkStore.planReconcile")(function* (request) {
+        const steps = yield* this.reconcileSteps(request, "check");
+        return steps.map((step) => step._tag === "applied"
+            ? {
+                _tag: "would_apply",
+                eventId: step.eventId,
+                goalId: step.goalId,
+                state: step.state,
+                subject: step.candidate.fact.subject,
+                observationId: step.candidate.fact.observationId,
+                goalEventId: step.candidate.head.eventId,
+                goalUpdatedAt: step.candidate.head.goal.updatedAt
+            }
+            : step);
+    });
     observe = Effect.fn("WorkStore.observe")(function* (envelopes) {
         const decoded = yield* Schema.decodeUnknownEffect(Schema.Array(WorkObservationEnvelope).check(Schema.isMaxLength(workObservedFactMaxRecords)))(envelopes).pipe(Effect.mapError(storeError("observe.decode")));
         const cryptoService = this.#cryptoService;