saeeol 1.2.5 → 1.2.7

package/test/storage/storage.test.ts

@@ -1,293 +0,0 @@
-import { describe, expect } from "bun:test"
-import path from "path"
-import { Effect, Exit, Layer } from "effect"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
-import { Git } from "../../src/git"
-import { Global } from "@saeeol/core/global"
-import { Storage } from "@/storage/storage"
-import { tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const dir = path.join(Global.Path.data, "storage")
-
-const it = testEffect(Layer.mergeAll(Storage.defaultLayer, AppFileSystem.defaultLayer, CrossSpawnSpawner.defaultLayer))
-
-const scope = Effect.fnUntraced(function* () {
-  const root = ["storage_test", crypto.randomUUID()]
-  const fs = yield* AppFileSystem.Service
-  const svc = yield* Storage.Service
-  yield* Effect.addFinalizer(() =>
-    fs.remove(path.join(dir, ...root), { recursive: true, force: true }).pipe(Effect.ignore),
-  )
-  return { root, svc }
-})
-
-// remap(root) rewrites any path under Global.Path.data to live under `root` instead.
-// Used by remappedFs to build an AppFileSystem that Storage thinks is the real global
-// data dir but actually targets a tmp dir — letting migration tests stage legacy layouts.
-// NOTE: only the 6 methods below are intercepted. If Storage starts using a different
-// AppFileSystem method that touches Global.Path.data, add it here.
-function remap(root: string, file: string) {
-  if (file === Global.Path.data) return root
-  if (file.startsWith(Global.Path.data + path.sep)) return path.join(root, path.relative(Global.Path.data, file))
-  return file
-}
-
-function remappedFs(root: string) {
-  return Layer.effect(
-    AppFileSystem.Service,
-    Effect.gen(function* () {
-      const fs = yield* AppFileSystem.Service
-      return AppFileSystem.Service.of({
-        ...fs,
-        isDir: (file) => fs.isDir(remap(root, file)),
-        readJson: (file) => fs.readJson(remap(root, file)),
-        writeWithDirs: (file, content, mode) => fs.writeWithDirs(remap(root, file), content, mode),
-        readFileString: (file) => fs.readFileString(remap(root, file)),
-        remove: (file) => fs.remove(remap(root, file)),
-        glob: (pattern, options) =>
-          fs.glob(pattern, options?.cwd ? { ...options, cwd: remap(root, options.cwd) } : options),
-      })
-    }),
-  ).pipe(Layer.provide(AppFileSystem.defaultLayer))
-}
-
-// Layer.fresh forces a new Storage instance — without it, Effect's in-test layer cache
-// returns the outer testEffect's Storage (which uses the real AppFileSystem), not a new
-// one built on top of remappedFs.
-const remappedStorage = (root: string) =>
-  Layer.fresh(Storage.layer.pipe(Layer.provide(remappedFs(root)), Layer.provide(Git.defaultLayer)))
-
-describe("Storage", () => {
-  it.live("round-trips JSON content", () =>
-    Effect.gen(function* () {
-      const { root, svc } = yield* scope()
-      const key = [...root, "session_diff", "roundtrip"]
-      const value = [{ file: "a.ts", additions: 2, deletions: 1 }]
-
-      yield* svc.write(key, value)
-      expect(yield* svc.read<typeof value>(key)).toEqual(value)
-    }),
-  )
-
-  it.live("maps missing reads to NotFoundError", () =>
-    Effect.gen(function* () {
-      const { root, svc } = yield* scope()
-      const exit = yield* svc.read([...root, "missing", "value"]).pipe(Effect.exit)
-      expect(Exit.isFailure(exit)).toBe(true)
-    }),
-  )
-
-  it.live("update on missing key throws NotFoundError", () =>
-    Effect.gen(function* () {
-      const { root, svc } = yield* scope()
-      const exit = yield* svc
-        .update<{ value: number }>([...root, "missing", "key"], (draft) => {
-          draft.value += 1
-        })
-        .pipe(Effect.exit)
-      expect(Exit.isFailure(exit)).toBe(true)
-    }),
-  )
-
-  it.live("write overwrites existing value", () =>
-    Effect.gen(function* () {
-      const { root, svc } = yield* scope()
-      const key = [...root, "overwrite", "test"]
-
-      yield* svc.write<{ v: number }>(key, { v: 1 })
-      yield* svc.write<{ v: number }>(key, { v: 2 })
-
-      expect(yield* svc.read<{ v: number }>(key)).toEqual({ v: 2 })
-    }),
-  )
-
-  it.live("remove on missing key is a no-op", () =>
-    Effect.gen(function* () {
-      const { root, svc } = yield* scope()
-      yield* svc.remove([...root, "nonexistent", "key"])
-    }),
-  )
-
-  it.live("list on missing prefix returns empty", () =>
-    Effect.gen(function* () {
-      const { root, svc } = yield* scope()
-      expect(yield* svc.list([...root, "nonexistent"])).toEqual([])
-    }),
-  )
-
-  it.live("serializes concurrent updates for the same key", () =>
-    Effect.gen(function* () {
-      const { root, svc } = yield* scope()
-      const key = [...root, "counter", "shared"]
-
-      yield* svc.write(key, { value: 0 })
-
-      yield* Effect.all(
-        Array.from({ length: 25 }, () =>
-          svc.update<{ value: number }>(key, (draft) => {
-            draft.value += 1
-          }),
-        ),
-        { concurrency: "unbounded" },
-      )
-
-      expect(yield* svc.read<{ value: number }>(key)).toEqual({ value: 25 })
-    }),
-  )
-
-  it.live("concurrent reads do not block each other", () =>
-    Effect.gen(function* () {
-      const { root, svc } = yield* scope()
-      const key = [...root, "concurrent", "reads"]
-
-      yield* svc.write(key, { ok: true })
-
-      const results = yield* Effect.all(
-        Array.from({ length: 10 }, () => svc.read(key)),
-        { concurrency: "unbounded" },
-      )
-
-      expect(results).toHaveLength(10)
-      for (const r of results) expect(r).toEqual({ ok: true })
-    }),
-  )
-
-  it.live("nested keys create deep paths", () =>
-    Effect.gen(function* () {
-      const { root, svc } = yield* scope()
-      const key = [...root, "a", "b", "c", "deep"]
-
-      yield* svc.write<{ nested: boolean }>(key, { nested: true })
-
-      expect(yield* svc.read<{ nested: boolean }>(key)).toEqual({ nested: true })
-      expect(yield* svc.list([...root, "a"])).toEqual([key])
-    }),
-  )
-
-  it.live("lists and removes stored entries", () =>
-    Effect.gen(function* () {
-      const { root, svc } = yield* scope()
-      const a = [...root, "list", "a"]
-      const b = [...root, "list", "b"]
-      const prefix = [...root, "list"]
-
-      yield* svc.write(b, { value: 2 })
-      yield* svc.write(a, { value: 1 })
-
-      expect(yield* svc.list(prefix)).toEqual([a, b])
-
-      yield* svc.remove(a)
-
-      expect(yield* svc.list(prefix)).toEqual([b])
-      const exit = yield* svc.read(a).pipe(Effect.exit)
-      expect(Exit.isFailure(exit)).toBe(true)
-    }),
-  )
-
-  it.live("migration 2 runs when marker contents are invalid", () =>
-    Effect.gen(function* () {
-      const fs = yield* AppFileSystem.Service
-      const tmp = yield* tmpdirScoped()
-      const storage = path.join(tmp, "storage")
-      const diffs = [
-        { additions: 2, deletions: 1 },
-        { additions: 3, deletions: 4 },
-      ]
-
-      yield* fs.writeWithDirs(path.join(storage, "migration"), "wat")
-      yield* fs.writeWithDirs(
-        path.join(storage, "session", "proj_test", "ses_test.json"),
-        JSON.stringify({
-          id: "ses_test",
-          projectID: "proj_test",
-          title: "legacy",
-          summary: { diffs },
-        }),
-      )
-
-      yield* Effect.gen(function* () {
-        const svc = yield* Storage.Service
-        expect(yield* svc.list(["session_diff"])).toEqual([["session_diff", "ses_test"]])
-        expect(yield* svc.read<typeof diffs>(["session_diff", "ses_test"])).toEqual(diffs)
-        expect(
-          yield* svc.read<{
-            id: string
-            projectID: string
-            title: string
-            summary: { additions: number; deletions: number }
-          }>(["session", "proj_test", "ses_test"]),
-        ).toEqual({
-          id: "ses_test",
-          projectID: "proj_test",
-          title: "legacy",
-          summary: { additions: 5, deletions: 5 },
-        })
-      }).pipe(Effect.provide(remappedStorage(tmp)))
-
-      expect(yield* fs.readFileString(path.join(storage, "migration"))).toBe("2")
-    }),
-  )
-
-  it.live("migration 1 tolerates malformed legacy records", () =>
-    Effect.gen(function* () {
-      const fs = yield* AppFileSystem.Service
-      const tmp = yield* tmpdirScoped({ git: true })
-      const storage = path.join(tmp, "storage")
-      const legacy = path.join(tmp, "project", "legacy")
-
-      yield* fs.writeWithDirs(path.join(legacy, "storage", "session", "message", "probe", "0.json"), "[]")
-      yield* fs.writeWithDirs(
-        path.join(legacy, "storage", "session", "message", "probe", "1.json"),
-        JSON.stringify({ path: { root: tmp } }),
-      )
-      yield* fs.writeWithDirs(
-        path.join(legacy, "storage", "session", "info", "ses_legacy.json"),
-        JSON.stringify({ id: "ses_legacy", title: "legacy" }),
-      )
-      yield* fs.writeWithDirs(
-        path.join(legacy, "storage", "session", "message", "ses_legacy", "msg_legacy.json"),
-        JSON.stringify({ role: "user", text: "hello" }),
-      )
-
-      yield* Effect.gen(function* () {
-        const svc = yield* Storage.Service
-        const projects = yield* svc.list(["project"])
-        expect(projects).toHaveLength(1)
-        const project = projects[0]![1]
-
-        expect(yield* svc.list(["session", project])).toEqual([["session", project, "ses_legacy"]])
-        expect(yield* svc.read<{ id: string; title: string }>(["session", project, "ses_legacy"])).toEqual({
-          id: "ses_legacy",
-          title: "legacy",
-        })
-        expect(yield* svc.read<{ role: string; text: string }>(["message", "ses_legacy", "msg_legacy"])).toEqual({
-          role: "user",
-          text: "hello",
-        })
-      }).pipe(Effect.provide(remappedStorage(tmp)))
-
-      expect(yield* fs.readFileString(path.join(storage, "migration"))).toBe("2")
-    }),
-  )
-
-  it.live("failed migrations do not advance the marker", () =>
-    Effect.gen(function* () {
-      const fs = yield* AppFileSystem.Service
-      const tmp = yield* tmpdirScoped()
-      const storage = path.join(tmp, "storage")
-      const legacy = path.join(tmp, "project", "legacy")
-
-      yield* fs.writeWithDirs(path.join(legacy, "storage", "session", "message", "probe", "0.json"), "{")
-
-      yield* Effect.gen(function* () {
-        const svc = yield* Storage.Service
-        expect(yield* svc.list(["project"])).toEqual([])
-      }).pipe(Effect.provide(remappedStorage(tmp)))
-
-      const exit = yield* fs.access(path.join(storage, "migration")).pipe(Effect.exit)
-      expect(Exit.isFailure(exit)).toBe(true)
-    }),
-  )
-})

package/test/suggestion/suggestion.test.ts

@@ -1 +0,0 @@
-// Moved to test/saeeol/suggestion/suggestion.test.ts.

package/test/sync/index.test.ts

@@ -1,256 +0,0 @@
-import { describe, expect, beforeEach, afterEach, afterAll } from "bun:test"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { Effect, Layer, Schema } from "effect"
-import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
-import { Bus } from "../../src/bus"
-import { SyncEvent } from "../../src/sync"
-import { Database } from "@/storage/db"
-import { EventTable } from "../../src/sync/event.sql"
-import { MessageID } from "../../src/session/schema"
-import { Flag } from "@saeeol/core/flag/flag"
-import { initProjectors } from "../../src/server/projectors"
-import { testEffect } from "../lib/effect"
-
-const original = Flag.SAEEOL_EXPERIMENTAL_WORKSPACES
-const it = testEffect(Layer.mergeAll(SyncEvent.defaultLayer, CrossSpawnSpawner.defaultLayer))
-
-beforeEach(() => {
-  Database.close()
-
-  Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = true
-})
-
-afterEach(() => {
-  Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = original
-})
-
-describe("SyncEvent", () => {
-  function setup() {
-    SyncEvent.reset()
-
-    const Created = SyncEvent.define({
-      type: "item.created",
-      version: 1,
-      aggregate: "id",
-      schema: Schema.Struct({ id: Schema.String, name: Schema.String }),
-    })
-    const Sent = SyncEvent.define({
-      type: "item.sent",
-      version: 1,
-      aggregate: "item_id",
-      schema: Schema.Struct({ item_id: Schema.String, to: Schema.String }),
-    })
-
-    SyncEvent.init({
-      projectors: [SyncEvent.project(Created, () => {}), SyncEvent.project(Sent, () => {})],
-    })
-
-    return { Created, Sent }
-  }
-
-  function expectDefect<A, E, R>(effect: Effect.Effect<A, E, R>, pattern: RegExp) {
-    return Effect.gen(function* () {
-      const exit = yield* Effect.exit(effect)
-      if (exit._tag === "Success") throw new Error("Expected effect to fail")
-      expect(String(exit.cause)).toMatch(pattern)
-    })
-  }
-
-  afterAll(() => {
-    SyncEvent.reset()
-    initProjectors()
-  })
-
-  describe("run", () => {
-    it.live(
-      "inserts event row",
-      provideTmpdirInstance(() =>
-        Effect.gen(function* () {
-          const { Created } = setup()
-          yield* SyncEvent.use.run(Created, { id: "evt_1", name: "first" })
-          const rows = Database.use((db) => db.select().from(EventTable).all())
-          expect(rows).toHaveLength(1)
-          expect(rows[0].type).toBe("item.created.1")
-          expect(rows[0].aggregate_id).toBe("evt_1")
-        }),
-      ),
-    )
-
-    it.live(
-      "increments seq per aggregate",
-      provideTmpdirInstance(() =>
-        Effect.gen(function* () {
-          const { Created } = setup()
-          yield* SyncEvent.use.run(Created, { id: "evt_1", name: "first" })
-          yield* SyncEvent.use.run(Created, { id: "evt_1", name: "second" })
-          const rows = Database.use((db) => db.select().from(EventTable).all())
-          expect(rows).toHaveLength(2)
-          expect(rows[1].seq).toBe(rows[0].seq + 1)
-        }),
-      ),
-    )
-
-    it.live(
-      "uses custom aggregate field from agg()",
-      provideTmpdirInstance(() =>
-        Effect.gen(function* () {
-          const { Sent } = setup()
-          yield* SyncEvent.use.run(Sent, { item_id: "evt_1", to: "james" })
-          const rows = Database.use((db) => db.select().from(EventTable).all())
-          expect(rows).toHaveLength(1)
-          expect(rows[0].aggregate_id).toBe("evt_1")
-        }),
-      ),
-    )
-
-    it.live(
-      "emits events",
-      provideTmpdirInstance(() =>
-        Effect.gen(function* () {
-          const { Created } = setup()
-          const events: Array<{
-            type: string
-            properties: { id: string; name: string }
-          }> = []
-          let resolve = () => {}
-          const received = new Promise<void>((done) => {
-            resolve = done
-          })
-          const dispose = Bus.subscribeAll((event) => {
-            events.push(event)
-            resolve()
-          })
-          try {
-            yield* SyncEvent.use.run(Created, { id: "evt_1", name: "test" })
-            yield* Effect.promise(() => received)
-            expect(events).toHaveLength(1)
-            expect(events[0]).toEqual({
-              type: "item.created",
-              properties: {
-                id: "evt_1",
-                name: "test",
-              },
-            })
-          } finally {
-            dispose()
-          }
-        }),
-      ),
-    )
-  })
-
-  describe("replay", () => {
-    it.live(
-      "inserts event from external payload",
-      provideTmpdirInstance(() =>
-        Effect.gen(function* () {
-          const id = MessageID.ascending()
-          yield* SyncEvent.use.replay({
-            id: "evt_1",
-            type: "item.created.1",
-            seq: 0,
-            aggregateID: id,
-            data: { id, name: "replayed" },
-          })
-          const rows = Database.use((db) => db.select().from(EventTable).all())
-          expect(rows).toHaveLength(1)
-          expect(rows[0].aggregate_id).toBe(id)
-        }),
-      ),
-    )
-
-    it.live(
-      "throws on sequence mismatch",
-      provideTmpdirInstance(() =>
-        Effect.gen(function* () {
-          const id = MessageID.ascending()
-          yield* SyncEvent.use.replay({
-            id: "evt_1",
-            type: "item.created.1",
-            seq: 0,
-            aggregateID: id,
-            data: { id, name: "first" },
-          })
-          yield* expectDefect(
-            SyncEvent.use.replay({
-              id: "evt_1",
-              type: "item.created.1",
-              seq: 5,
-              aggregateID: id,
-              data: { id, name: "bad" },
-            }),
-            /Sequence mismatch/,
-          )
-        }),
-      ),
-    )
-
-    it.live(
-      "throws on unknown event type",
-      provideTmpdirInstance(() =>
-        Effect.gen(function* () {
-          yield* expectDefect(
-            SyncEvent.use.replay({
-              id: "evt_1",
-              type: "unknown.event.1",
-              seq: 0,
-              aggregateID: "x",
-              data: {},
-            }),
-            /Unknown event type/,
-          )
-        }),
-      ),
-    )
-
-    it.live(
-      "replayAll accepts later chunks after the first batch",
-      provideTmpdirInstance(() =>
-        Effect.gen(function* () {
-          const { Created } = setup()
-          const id = MessageID.ascending()
-
-          const one = yield* SyncEvent.use.replayAll([
-            {
-              id: "evt_1",
-              type: SyncEvent.versionedType(Created.type, Created.version),
-              seq: 0,
-              aggregateID: id,
-              data: { id, name: "first" },
-            },
-            {
-              id: "evt_2",
-              type: SyncEvent.versionedType(Created.type, Created.version),
-              seq: 1,
-              aggregateID: id,
-              data: { id, name: "second" },
-            },
-          ])
-
-          const two = yield* SyncEvent.use.replayAll([
-            {
-              id: "evt_3",
-              type: SyncEvent.versionedType(Created.type, Created.version),
-              seq: 2,
-              aggregateID: id,
-              data: { id, name: "third" },
-            },
-            {
-              id: "evt_4",
-              type: SyncEvent.versionedType(Created.type, Created.version),
-              seq: 3,
-              aggregateID: id,
-              data: { id, name: "fourth" },
-            },
-          ])
-
-          expect(one).toBe(id)
-          expect(two).toBe(id)
-
-          const rows = Database.use((db) => db.select().from(EventTable).all())
-          expect(rows.map((row) => row.seq)).toEqual([0, 1, 2, 3])
-        }),
-      ),
-    )
-  })
-})