deepseek-harness/packages/session-persistence/tests/persistence.spec.ts

import { describe, expect, it } from 'vitest'
import { Context } from 'cordis'
import { SessionId, isJsonValue } from '@deepseek-ai/dsh-session'
import type { SessionEvent, SessionMeta, SessionSummary } from '@deepseek-ai/dsh-session'
import { SessionPersistence } from '../src/index.ts'
import { runPersistenceContract, meta, oneTurnLog } from './contract.ts'

/**
 * A minimal in-memory {@link SessionPersistence} used to (a) cover the abstract
 * base's constructor + service registration and (b) validate the reusable
 * contract suite itself. The real durable backend is
 * `@deepseek-ai/dsh-session-persistence-jsonl`.
 */
class MemoryPersistence extends SessionPersistence {
  private store = new Map<string, { meta: SessionMeta; events: SessionEvent[] }>()
  private pending = new Map<string, SessionMeta>()

  async create(m: SessionMeta): Promise<void> {
    // Lazy: record the intended meta, but stay absent from has/list until the
    // first append materializes the session.
    this.pending.set(m.id, m)
  }

  async append(id: SessionId, events: readonly SessionEvent[]): Promise<void> {
    const existing = this.store.get(id)
    const nextSeq = existing ? existing.events.length : 0
    if (events.length > 0 && events[0]!.seq !== nextSeq) {
      throw new Error(`append seq mismatch for "${id}": expected ${nextSeq}, got ${events[0]!.seq}`)
    }
    for (let i = 0; i < events.length; i++) {
      const e = events[i]!
      if (e.seq !== nextSeq + i) throw new Error(`non-contiguous seq in batch for "${id}" at index ${i}`)
      if (!isJsonValue(e.data)) {
        throw new Error(`event "${e.type}" carries non-JSON-serializable data`)
      }
    }
    if (!existing) {
      const m = this.pending.get(id)
      if (!m) throw new Error(`append before create for "${id}"`)
      this.store.set(id, { meta: m, events: structuredClone(events) as SessionEvent[] })
    } else {
      existing.events.push(...structuredClone(events) as SessionEvent[])
    }
  }

  async load(id: SessionId): Promise<{ meta: SessionMeta; events: SessionEvent[] }> {
    const entry = this.store.get(id)
    if (!entry) throw new Error(`session "${id}" not found`)
    return { meta: structuredClone(entry.meta), events: structuredClone(entry.events) }
  }

  async list(): Promise<SessionMeta[]> {
    return [...this.store.values()].map(e => structuredClone(e.meta))
  }

  async has(id: SessionId): Promise<boolean> {
    return this.store.has(id)
  }

  async delete(id: SessionId): Promise<void> {
    this.store.delete(id)
    this.pending.delete(id)
  }

  async update(id: SessionId, summary: Partial<SessionSummary>): Promise<void> {
    const entry = this.store.get(id)
    if (entry) Object.assign(entry.meta, summary)
  }
}

// Run the shared contract against the in-memory backend.
runPersistenceContract('memory', async () => {
  const ctx = new Context()
  const fiber = await ctx.plugin(MemoryPersistence)
  return {
    persistence: ctx.sessionPersistence,
    dispose: async () => { await fiber.dispose() },
  }
})

describe('SessionPersistence service registration', () => {
  it('registers as ctx.sessionPersistence and is removed on fiber dispose (HMR safety)', async () => {
    const ctx = new Context()
    const fiber = await ctx.plugin(MemoryPersistence)
    expect(ctx.sessionPersistence).toBeInstanceOf(SessionPersistence)

    await fiber.dispose()
    expect(ctx.sessionPersistence).toBeUndefined()
  })

  it('round-trips through the registered service instance', async () => {
    const ctx = new Context()
    const fiber = await ctx.plugin(MemoryPersistence)
    const m = meta('reg')
    await ctx.sessionPersistence.create(m)
    await ctx.sessionPersistence.append(m.id, oneTurnLog())
    const loaded = await ctx.sessionPersistence.load(m.id)
    expect(loaded.events).toHaveLength(6)
    await fiber.dispose()
  })
})