refactor(opencode): remove legacy database wrapper

Author: thdxr

packages/core/src/database/database.ts

@@ -3,7 +3,6 @@ export * as Database from "./database"
 import { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
 import { layer as sqliteLayer } from "#sqlite"
 import { Context, Effect, Layer } from "effect"
-import { Sqlite } from "./sqlite"
 import { Global } from "../global"
 import { Flag } from "../flag/flag"
 import { isAbsolute, join } from "path"
@@ -15,15 +14,13 @@ type DatabaseShape = Effect.Success<typeof makeDatabase>
 
 export interface Interface {
   db: DatabaseShape
-  drizzle: Sqlite.DrizzleClient
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/storage/Database") {}
 
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const drizzle = yield* Sqlite.Drizzle
     const db = yield* makeDatabase
 
     yield* db.run("PRAGMA journal_mode = WAL")
@@ -35,7 +32,7 @@ export const layer = Layer.effect(
     yield* Effect.log("Applying database migrations")
     yield* DatabaseMigration.apply(db)
 
-    return { db, drizzle }
+    return { db }
   }).pipe(Effect.orDie),
 )
 

packages/opencode/src/cli/cmd/db.ts

@@ -1,17 +1,14 @@
 import type { Argv } from "yargs"
 import { spawn } from "child_process"
-import { Database } from "@/storage/db"
-import { drizzle } from "drizzle-orm/bun-sqlite"
-import { Database as BunDatabase } from "bun:sqlite"
-import { UI } from "../ui"
-import { cmd } from "./cmd"
-import { JsonMigration } from "@/storage/json-migration"
-import { EOL } from "os"
-import { errorMessage } from "../../util/error"
+import { Database } from "@opencode-ai/core/database/database"
+import { Effect } from "effect"
+import { sql } from "drizzle-orm"
+import { effectCmd } from "../effect-cmd"
 
-const QueryCommand = cmd({
+const QueryCommand = effectCmd({
   command: "$0 [query]",
   describe: "open an interactive sqlite3 shell or run a query",
+  instance: false,
   builder: (yargs: Argv) => {
     return yargs
       .positional("query", {
@@ -25,96 +22,41 @@ const QueryCommand = cmd({
         describe: "Output format",
       })
   },
-  handler: async (args: { query?: string; format: string }) => {
+  handler: Effect.fn("Cli.db.query")(function* (args: { query?: string; format: string }) {
     const query = args.query as string | undefined
     if (query) {
-      const db = new BunDatabase(Database.getPath(), { readonly: true })
-      try {
-        const result = db.query(query).all() as Record<string, unknown>[]
-        if (args.format === "json") {
-          console.log(JSON.stringify(result, null, 2))
-        } else if (result.length > 0) {
-          const keys = Object.keys(result[0])
-          console.log(keys.join("\t"))
-          for (const row of result) {
-            console.log(keys.map((k) => row[k]).join("\t"))
-          }
-        }
-      } catch (err) {
-        UI.error(errorMessage(err))
-        process.exit(1)
+      const { db } = yield* Database.Service
+      const result = yield* db.all<Record<string, unknown>>(sql.raw(query)).pipe(Effect.orDie)
+      if (args.format === "json") console.log(JSON.stringify(result, null, 2))
+      else if (result.length > 0) {
+        const keys = Object.keys(result[0])
+        console.log(keys.join("\t"))
+        for (const row of result) console.log(keys.map((key) => row[key]).join("\t"))
       }
-      db.close()
       return
     }
-    const child = spawn("sqlite3", [Database.getPath()], {
+    const child = spawn("sqlite3", [Database.path()], {
       stdio: "inherit",
     })
-    await new Promise((resolve) => child.on("close", resolve))
-  },
+    yield* Effect.promise(() => new Promise((resolve) => child.on("close", resolve)))
+  }),
 })
 
-const PathCommand = cmd({
+const PathCommand = effectCmd({
   command: "path",
   describe: "print the database path",
-  handler: () => {
-    console.log(Database.getPath())
-  },
-})
-
-const MigrateCommand = cmd({
-  command: "migrate",
-  describe: "migrate JSON data to SQLite (merges with existing data)",
-  handler: async () => {
-    const sqlite = new BunDatabase(Database.getPath())
-    const tty = process.stderr.isTTY
-    const width = 36
-    const orange = "\x1b[38;5;214m"
-    const muted = "\x1b[0;2m"
-    const reset = "\x1b[0m"
-    let last = -1
-    if (tty) process.stderr.write("\x1b[?25l")
-    try {
-      const stats = await JsonMigration.run(drizzle({ client: sqlite }), {
-        progress: (event) => {
-          const percent = Math.floor((event.current / event.total) * 100)
-          if (percent === last) return
-          last = percent
-          if (tty) {
-            const fill = Math.round((percent / 100) * width)
-            const bar = `${"■".repeat(fill)}${"･".repeat(width - fill)}`
-            process.stderr.write(
-              `\r${orange}${bar} ${percent.toString().padStart(3)}%${reset} ${muted}${event.current}/${event.total}${reset} `,
-            )
-          } else {
-            process.stderr.write(`sqlite-migration:${percent}${EOL}`)
-          }
-        },
-      })
-      if (tty) process.stderr.write("\n")
-      if (tty) process.stderr.write("\x1b[?25h")
-      else process.stderr.write(`sqlite-migration:done${EOL}`)
-      UI.println(
-        `Migration complete: ${stats.projects} projects, ${stats.sessions} sessions, ${stats.messages} messages`,
-      )
-      if (stats.errors.length > 0) {
-        UI.println(`${stats.errors.length} errors occurred during migration`)
-      }
-    } catch (err) {
-      if (tty) process.stderr.write("\x1b[?25h")
-      UI.error(`Migration failed: ${errorMessage(err)}`)
-      process.exit(1)
-    } finally {
-      sqlite.close()
-    }
-  },
+  instance: false,
+  handler: Effect.fn("Cli.db.path")(function* () {
+    console.log(Database.path())
+  }),
 })
 
-export const DbCommand = cmd({
+export const DbCommand = effectCmd({
   command: "db",
   describe: "database tools",
+  instance: false,
   builder: (yargs: Argv) => {
-    return yargs.command(QueryCommand).command(PathCommand).command(MigrateCommand).demandCommand()
+    return yargs.command(QueryCommand).command(PathCommand).demandCommand()
   },
-  handler: () => {},
+  handler: Effect.fn("Cli.db")(function* () {}),
 })

packages/opencode/src/cli/cmd/import.ts

@@ -3,7 +3,7 @@ import { SessionLegacy } from "@opencode-ai/core/session/legacy"
 import { Session } from "@/session/session"
 import { MessageV2 } from "../../session/message-v2"
 import { CliError, effectCmd } from "../effect-cmd"
-import { Database } from "@/storage/db"
+import { Database } from "@opencode-ai/core/database/database"
 import { SessionTable, MessageTable, PartTable } from "@opencode-ai/core/session/sql"
 import { InstanceRef } from "@/effect/instance-ref"
 import { ShareNext } from "@/share/share-next"
@@ -99,6 +99,7 @@ export const ImportCommand = effectCmd({
 const runImport = Effect.fn("Cli.import.body")(function* (file: string, ctx: InstanceContext) {
   const share = yield* ShareNext.Service
   const fs = yield* AppFileSystem.Service
+  const { db } = yield* Database.Service
 
   let exportData: ExportData | undefined
 
@@ -176,48 +177,45 @@ const runImport = Effect.fn("Cli.import.body")(function* (file: string, ctx: Ins
     path: path.relative(path.resolve(ctx.worktree), ctx.directory).replaceAll("\\", "/"),
   }) as Session.Info
   const row = Session.toRow(info)
-  Database.use((db) =>
-    db
-      .insert(SessionTable)
-      .values(row)
-      .onConflictDoUpdate({
-        target: SessionTable.id,
-        set: { project_id: row.project_id, directory: row.directory, path: row.path },
-      })
-      .run(),
-  )
+  yield* db
+    .insert(SessionTable)
+    .values(row)
+    .onConflictDoUpdate({
+      target: SessionTable.id,
+      set: { project_id: row.project_id, directory: row.directory, path: row.path },
+    })
+    .run()
+    .pipe(Effect.orDie)
 
   for (const msg of exportData.messages) {
     const msgInfo = decodeMessageInfo(msg.info) as SessionLegacy.Info
     const { id, sessionID: _, ...msgData } = msgInfo
-    Database.use((db) =>
-      db
-        .insert(MessageTable)
-        .values({
-          id,
-          session_id: row.id,
-          time_created: msgInfo.time?.created ?? Date.now(),
-          data: msgData as never,
-        })
-        .onConflictDoNothing()
-        .run(),
-    )
+    yield* db
+      .insert(MessageTable)
+      .values({
+        id,
+        session_id: row.id,
+        time_created: msgInfo.time?.created ?? Date.now(),
+        data: msgData as never,
+      })
+      .onConflictDoNothing()
+      .run()
+      .pipe(Effect.orDie)
 
     for (const part of msg.parts) {
       const partInfo = decodePart(part) as SessionLegacy.Part
       const { id: partId, sessionID: _s, messageID, ...partData } = partInfo
-      Database.use((db) =>
-        db
-          .insert(PartTable)
-          .values({
-            id: partId,
-            message_id: messageID,
-            session_id: row.id,
-            data: partData,
-          })
-          .onConflictDoNothing()
-          .run(),
-      )
+      yield* db
+        .insert(PartTable)
+        .values({
+          id: partId,
+          message_id: messageID,
+          session_id: row.id,
+          data: partData,
+        })
+        .onConflictDoNothing()
+        .run()
+        .pipe(Effect.orDie)
     }
   }
 

packages/opencode/src/cli/cmd/stats.ts

@@ -2,7 +2,7 @@ import { Effect } from "effect"
 import { effectCmd } from "../effect-cmd"
 import { Session } from "@/session/session"
 import { NotFoundError } from "@/storage/storage"
-import { Database } from "@/storage/db"
+import { Database } from "@opencode-ai/core/database/database"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { Project } from "@/project/project"
 import { InstanceRef } from "@/effect/instance-ref"
@@ -80,17 +80,18 @@ export const StatsCommand = effectCmd({
   }),
 })
 
-const getAllSessions = Effect.sync(() =>
-  Database.use((db) => db.select().from(SessionTable).all()).map((row) => Session.fromRow(row)),
-)
+const getAllSessions = Effect.fnUntraced(function* () {
+  const { db } = yield* Database.Service
+  return (yield* db.select().from(SessionTable).all().pipe(Effect.orDie)).map((row) => Session.fromRow(row))
+})
 
 const aggregateSessionStats = Effect.fn("Cli.stats.aggregate")(function* (
   days?: number,
   projectFilter?: string,
   currentProject?: Project.Info,
 ) {
   const svc = yield* Session.Service
-  const sessions = yield* getAllSessions
+  const sessions = yield* getAllSessions()
   const MS_IN_DAY = 24 * 60 * 60 * 1000
 
   const cutoffTime = (() => {