The database that remembers why.

// One application command is one atomic transaction that records who acted,
// which command it was, and the release whose rules it was checked against.
export const placeWorker = (release: InMemoryConfigStore.ConfigSnapshot) =>
  Effect.gen(function* () {
    const triples = yield* Triples;
    const rules = yield* GraphConstraint.collect(release.root);
    return yield* triples.transact(
      [
        {
          op: "assert",
          entityId: placement,
          entityType: "Placement",
          ...Placement.attributes.worker.assertion(maria, { validFrom: MAR_2 }),
        },
        {
          op: "assert",
          entityId: placement,
          entityType: "Placement",
          ...Placement.attributes.site.assertion(harbor, { validFrom: MAR_2 }),
        },
      ],
      {
        actor: "user:dana",
        commandId: "placement:create:maria-harbor", // unique: a retry can never apply twice
        correlationId: "request:7f3a",
        configSnapshot: release.id, // the rules this write was governed by
        enforce: GraphConstraint.enforcement(rules), // required/unique/ref checks, atomically
      },
    );
  });

import { Effect } from "effect";
import { Triples, type TemporalBasis } from "@triplex-build/triplex";
import { TrainedFor, maria } from "./model.ts";
import { MAR_2 } from "./record.ts";

// Was Maria trained for Harbor on the day she started there?
export const wasMariaTrained = Effect.gen(function* () {
  const triples = yield* Triples;
  const decision = yield* triples.transactionByCommand("placement:create:maria-harbor");
  if (decision === null) return yield* Effect.die("placement was never recorded");

  const trained = (basis: TemporalBasis) =>
    triples
      .match({ entityId: maria, attribute: TrainedFor.key }, basis)
      .pipe(Effect.map((facts) => facts.length > 0));

  return {
    // What the database believed at the instant Dana made the placement.
    knownAtDecision: yield* trained({ validAt: MAR_2, recordedAt: decision.instant }),
    // What the database knows now, after the auditor's correction.
    knownToday: yield* trained({ validAt: MAR_2 }),
  };
});

import { Effect } from "effect";
import { Triples } from "@triplex-build/triplex";
import { ConfigStore, ContentId } from "@triplex-build/triplex/config";

// Who placed Maria, and under which version of the rules?
export const governingRules = Effect.gen(function* () {
  const triples = yield* Triples;
  const config = yield* ConfigStore.ConfigStore;
  const receipt = yield* triples.transactionByCommand("placement:create:maria-harbor");
  const pinned = receipt?.configSnapshot;
  if (pinned === undefined || !ContentId.isContentId(pinned)) {
    return yield* Effect.die("placement was not pinned to a release");
  }

  return {
    actor: receipt?.actor,
    correlationId: receipt?.correlationId,
    governedBy: (yield* config.snapshotById(pinned))?.label,
    liveToday: (yield* config.resolveRef("live"))?.label,
  };
});

import { Effect } from "effect";
import { Triples } from "@triplex-build/triplex";
import * as Derivation from "@triplex-build/triplex/derivation";
import { PlacementSite, PlacementWorker, TrainedFor } from "./model.ts";

// Obligation: every placed worker holds current training for that site.
export const siteSafety = (configSnapshot: string) =>
  Derivation.make({
    name: "task.site-safety-training",
    query: {
      find: ["?worker", "?site"],
      where: [
        ["?placement", PlacementWorker.key, "?worker"],
        ["?placement", PlacementSite.key, "?site"],
        ["not", ["?worker", TrainedFor.key, "?site"]],
      ],
    },
    identity: ["?worker", "?site"],
    configSnapshot,
  });

const day = (instant: number) => new Date(instant).toISOString().slice(0, 10);

// Which training tasks should be open on a given day, and when will that change?
export const openWorkOn = (configSnapshot: string, validAt: number) =>
  Effect.gen(function* () {
    const triples = yield* Triples;
    const definition = yield* siteSafety(configSnapshot);
    const { candidates, nextTemporalBoundary } = yield* Derivation.evaluate(triples, definition, {
      basis: { validAt },
    });
    return {
      on: day(validAt),
      open: candidates.map((task) => task.result),
      recheckOn: nextTemporalBoundary === undefined ? null : day(nextTemporalBoundary),
    };
  });