fix(storage): type not found errors (#27265)

packages/opencode/test/session/messages-pagination.test.ts

@@ -4,6 +4,7 @@ import { Session as SessionNs } from "@/session/session"
 import { MessageV2 } from "../../src/session/message-v2"
 import { MessageID, PartID, type SessionID } from "../../src/session/schema"
 import { ModelID, ProviderID } from "../../src/provider/schema"
+import { NotFoundError } from "@/storage/storage"
 import * as Log from "@opencode-ai/core/util/log"
 import { testEffect } from "../lib/effect"
 
@@ -11,6 +12,20 @@ void Log.init({ print: false })
 
 const it = testEffect(SessionNs.defaultLayer)
 
+function expectNotFound(fn: () => unknown, message: string) {
+  let thrown: unknown
+  try {
+    fn()
+  } catch (error) {
+    thrown = error
+  }
+  expect(thrown).toBeInstanceOf(NotFoundError)
+  if (thrown instanceof NotFoundError) {
+    expect(thrown._tag).toBe("NotFoundError")
+    expect(thrown.message).toBe(message)
+  }
+}
+
 const withSession = <A, E, R>(
   fn: (input: { session: SessionNs.Interface; sessionID: SessionID }) => Effect.Effect<A, E, R>,
 ) =>
@@ -186,7 +201,7 @@ describe("MessageV2.page", () => {
   it.instance("throws NotFoundError for non-existent session", () =>
     Effect.gen(function* () {
       const fake = "non-existent-session" as SessionID
-      expect(() => MessageV2.page({ sessionID: fake, limit: 10 })).toThrow("NotFoundError")
+      expectNotFound(() => MessageV2.page({ sessionID: fake, limit: 10 }), `Session not found: ${fake}`)
     }),
   )
 
@@ -471,7 +486,8 @@ describe("MessageV2.get", () => {
   it.instance("throws NotFoundError for non-existent message", () =>
     withSession(({ sessionID }) =>
       Effect.gen(function* () {
-        expect(() => MessageV2.get({ sessionID, messageID: MessageID.ascending() })).toThrow("NotFoundError")
+        const messageID = MessageID.ascending()
+        expectNotFound(() => MessageV2.get({ sessionID, messageID }), `Message not found: ${messageID}`)
       }),
     ),
   )
@@ -483,7 +499,7 @@ describe("MessageV2.get", () => {
       const b = yield* session.create({})
       const [id] = yield* fill(a.id, 1)
 
-      expect(() => MessageV2.get({ sessionID: b.id, messageID: id })).toThrow("NotFoundError")
+      expectNotFound(() => MessageV2.get({ sessionID: b.id, messageID: id }), `Message not found: ${id}`)
       const result = MessageV2.get({ sessionID: a.id, messageID: id })
       expect(result.info.id).toBe(id)
 

packages/opencode/test/storage/storage.test.ts

@@ -74,20 +74,23 @@ describe("Storage", () => {
   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)
+      const error = yield* Effect.flip(svc.read([...root, "missing", "value"]))
+      expect(error).toBeInstanceOf(Storage.NotFoundError)
+      expect(error._tag).toBe("NotFoundError")
+      expect(error.message).toContain(path.join(...root, "missing", "value") + ".json")
     }),
   )
 
   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) => {
+      const error = yield* Effect.flip(
+        svc.update<{ value: number }>([...root, "missing", "key"], (draft) => {
           draft.value += 1
-        })
-        .pipe(Effect.exit)
-      expect(Exit.isFailure(exit)).toBe(true)
+        }),
+      )
+      expect(error).toBeInstanceOf(Storage.NotFoundError)
+      expect(error._tag).toBe("NotFoundError")
     }),
   )