context-epoch.ts 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174
  1. export * as SessionContextEpoch from "./context-epoch"
  2. import { eq } from "drizzle-orm"
  3. import { DateTime, Effect, Schema } from "effect"
  4. import type { Database } from "../database/database"
  5. import { EventV2 } from "../event"
  6. import { SystemContext } from "../system-context/index"
  7. import { ContextSnapshotDecodeError } from "./error"
  8. import { SessionEvent } from "./event"
  9. import { SessionHistory } from "./history"
  10. import { SessionInput } from "./input"
  11. import { SessionMessage } from "./message"
  12. import { SessionSchema } from "./schema"
  13. import { SessionContextEpochTable } from "./sql"
  14. type DatabaseService = Database.Interface["db"]
  15. interface Prepared {
  16. readonly baseline: string
  17. readonly baselineSeq: number
  18. }
  19. export function initialize(
  20. db: DatabaseService,
  21. context: Effect.Effect<SystemContext.SystemContext>,
  22. sessionID: SessionSchema.ID,
  23. ): Effect.Effect<Prepared | undefined, SystemContext.InitializationBlocked> {
  24. return initializeOnce(db, context, sessionID).pipe(Effect.withSpan("SessionContextEpoch.initialize"))
  25. }
  26. export function prepare(
  27. db: DatabaseService,
  28. events: EventV2.Interface,
  29. context: Effect.Effect<SystemContext.SystemContext>,
  30. sessionID: SessionSchema.ID,
  31. ): Effect.Effect<Prepared, SystemContext.InitializationBlocked | ContextSnapshotDecodeError> {
  32. return prepareOnce(db, events, context, sessionID).pipe(Effect.withSpan("SessionContextEpoch.prepare"))
  33. }
  34. const prepareOnce = Effect.fnUntraced(function* (
  35. db: DatabaseService,
  36. events: EventV2.Interface,
  37. context: Effect.Effect<SystemContext.SystemContext>,
  38. sessionID: SessionSchema.ID,
  39. ) {
  40. const [value, stored, compaction] = yield* Effect.all(
  41. [context, find(db, sessionID), SessionHistory.latestCompaction(db, sessionID)],
  42. { concurrency: "unbounded" },
  43. )
  44. if (!stored) {
  45. const generation = yield* SystemContext.initialize(value)
  46. const baselineSeq = yield* insert(db, sessionID, generation)
  47. return { baseline: generation.baseline, baselineSeq }
  48. }
  49. const snapshot = yield* Schema.decodeUnknownEffect(SystemContext.Snapshot)(stored.snapshot).pipe(
  50. Effect.mapError((error) => new ContextSnapshotDecodeError({ sessionID, details: String(error) })),
  51. )
  52. const replacementSeq = compaction !== undefined && compaction.seq > stored.baseline_seq ? compaction.seq : undefined
  53. const result = replacementSeq
  54. ? yield* SystemContext.replace(value, snapshot)
  55. : yield* SystemContext.reconcile(value, snapshot)
  56. if (result._tag === "Unchanged" || result._tag === "ReplacementBlocked") {
  57. return { baseline: stored.baseline, baselineSeq: stored.baseline_seq }
  58. }
  59. if (result._tag === "ReplacementReady") {
  60. const baselineSeq = replacementSeq ?? (yield* EventV2.latestSequence(db, sessionID))
  61. yield* replace(db, sessionID, baselineSeq, result.generation)
  62. return { baseline: result.generation.baseline, baselineSeq }
  63. }
  64. yield* events.publish(
  65. SessionEvent.ContextUpdated,
  66. { sessionID, messageID: SessionMessage.ID.create(), timestamp: yield* DateTime.now, text: result.text },
  67. { commit: () => advance(db, sessionID, result.snapshot).pipe(Effect.orDie) },
  68. )
  69. return { baseline: stored.baseline, baselineSeq: stored.baseline_seq }
  70. })
  71. const initializeOnce = Effect.fnUntraced(function* (
  72. db: DatabaseService,
  73. context: Effect.Effect<SystemContext.SystemContext>,
  74. sessionID: SessionSchema.ID,
  75. ) {
  76. if (yield* exists(db, sessionID)) return
  77. const generation = yield* context.pipe(Effect.flatMap(SystemContext.initialize))
  78. const baselineSeq = yield* insert(db, sessionID, generation)
  79. return { baseline: generation.baseline, baselineSeq }
  80. })
  81. const exists = Effect.fn("SessionContextEpoch.exists")(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
  82. return (
  83. (yield* db
  84. .select({ sessionID: SessionContextEpochTable.session_id })
  85. .from(SessionContextEpochTable)
  86. .where(eq(SessionContextEpochTable.session_id, sessionID))
  87. .get()
  88. .pipe(Effect.orDie)) !== undefined
  89. )
  90. })
  91. const find = Effect.fn("SessionContextEpoch.find")(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
  92. return yield* db
  93. .select()
  94. .from(SessionContextEpochTable)
  95. .where(eq(SessionContextEpochTable.session_id, sessionID))
  96. .get()
  97. .pipe(Effect.orDie)
  98. })
  99. export const reset = Effect.fn("SessionContextEpoch.reset")(function* (
  100. db: DatabaseService,
  101. sessionID: SessionSchema.ID,
  102. ) {
  103. yield* db
  104. .delete(SessionContextEpochTable)
  105. .where(eq(SessionContextEpochTable.session_id, sessionID))
  106. .run()
  107. .pipe(Effect.orDie)
  108. })
  109. const insert = Effect.fnUntraced(function* (
  110. db: DatabaseService,
  111. sessionID: SessionSchema.ID,
  112. generation: SystemContext.Generation,
  113. ) {
  114. const baselineSeq = yield* EventV2.latestSequence(db, sessionID)
  115. yield* db
  116. .insert(SessionContextEpochTable)
  117. .values({
  118. session_id: sessionID,
  119. baseline: generation.baseline,
  120. snapshot: generation.snapshot,
  121. baseline_seq: baselineSeq,
  122. })
  123. .run()
  124. .pipe(Effect.orDie)
  125. return baselineSeq
  126. })
  127. const replace = Effect.fnUntraced(function* (
  128. db: DatabaseService,
  129. sessionID: SessionSchema.ID,
  130. baselineSeq: number,
  131. generation: SystemContext.Generation,
  132. ) {
  133. const updated = yield* db
  134. .update(SessionContextEpochTable)
  135. .set({
  136. baseline: generation.baseline,
  137. snapshot: generation.snapshot,
  138. baseline_seq: baselineSeq,
  139. })
  140. .where(eq(SessionContextEpochTable.session_id, sessionID))
  141. .returning({ sessionID: SessionContextEpochTable.session_id })
  142. .get()
  143. .pipe(Effect.orDie)
  144. if (!updated) return yield* Effect.die("Context Epoch not found")
  145. })
  146. const advance = Effect.fnUntraced(function* (
  147. db: DatabaseService,
  148. sessionID: SessionSchema.ID,
  149. snapshot: SystemContext.Snapshot,
  150. ) {
  151. const updated = yield* db
  152. .update(SessionContextEpochTable)
  153. .set({ snapshot })
  154. .where(eq(SessionContextEpochTable.session_id, sessionID))
  155. .returning({ sessionID: SessionContextEpochTable.session_id })
  156. .get()
  157. .pipe(Effect.orDie)
  158. if (!updated) return yield* Effect.die("Context Epoch not found")
  159. })