refactor(keybase): migrate database implementation to keybase package

database.go

@@ -1,151 +0,0 @@
-package main
-
-import (
-	"database/sql"
-	_ "embed"
-	"fmt"
-	"sync"
-
-	_ "github.com/ncruces/go-sqlite3/driver"
-	_ "github.com/ncruces/go-sqlite3/embed"
-)
-
-//go:embed db/schema.sql
-var schemaSQL string
-
-var (
-	db   *sql.DB
-	dbMu sync.Mutex
-)
-
-func openDatabase() (*sql.DB, error) {
-	dbMu.Lock()
-	defer dbMu.Unlock()
-
-	if db != nil {
-		return db, nil
-	}
-
-	conn, err := sql.Open("sqlite3", ":memory:")
-	if err != nil {
-		return nil, fmt.Errorf("open database: %w", err)
-	}
-
-	if _, err := conn.Exec(schemaSQL); err != nil {
-		conn.Close()
-		return nil, fmt.Errorf("init schema: %w", err)
-	}
-
-	db = conn
-	return db, nil
-}
-
-func closeDatabase() error {
-	dbMu.Lock()
-	defer dbMu.Unlock()
-
-	if db == nil {
-		return nil
-	}
-
-	err := db.Close()
-	db = nil
-	return err
-}
-
-func getDatabase() *sql.DB {
-	dbMu.Lock()
-	defer dbMu.Unlock()
-	return db
-}
-
-func serializeDatabaseBytes() ([]byte, error) {
-	dbMu.Lock()
-	defer dbMu.Unlock()
-
-	if db == nil {
-		return nil, fmt.Errorf("database not initialized")
-	}
-
-	var data []byte
-	err := db.QueryRow("SELECT quote(readfile('.'))").Scan(&data)
-	if err != nil {
-		rows, err := db.Query("SELECT name, sql FROM sqlite_master WHERE type='table'")
-		if err != nil {
-			return nil, fmt.Errorf("query schema: %w", err)
-		}
-		defer rows.Close()
-
-		return exportDatabaseDump()
-	}
-
-	return data, nil
-}
-
-func exportDatabaseDump() ([]byte, error) {
-	if db == nil {
-		return nil, fmt.Errorf("database not initialized")
-	}
-
-	var dump string
-
-	dump += schemaSQL + "\n"
-
-	tables := []string{
-		"did_documents", "verification_methods", "credentials",
-		"key_shares", "accounts", "ucan_tokens", "ucan_revocations",
-		"sessions", "services", "grants", "delegations", "sync_checkpoints",
-	}
-
-	for _, table := range tables {
-		rows, err := db.Query(fmt.Sprintf("SELECT * FROM %s", table))
-		if err != nil {
-			continue
-		}
-
-		cols, err := rows.Columns()
-		if err != nil {
-			rows.Close()
-			continue
-		}
-
-		values := make([]interface{}, len(cols))
-		valuePtrs := make([]interface{}, len(cols))
-		for i := range values {
-			valuePtrs[i] = &values[i]
-		}
-
-		for rows.Next() {
-			if err := rows.Scan(valuePtrs...); err != nil {
-				continue
-			}
-
-			dump += fmt.Sprintf("-- Row from %s\n", table)
-		}
-		rows.Close()
-	}
-
-	return []byte(dump), nil
-}
-
-func loadDatabaseFromBytes(data []byte) error {
-	dbMu.Lock()
-	defer dbMu.Unlock()
-
-	if db != nil {
-		db.Close()
-	}
-
-	conn, err := sql.Open("sqlite3", ":memory:")
-	if err != nil {
-		return fmt.Errorf("open database: %w", err)
-	}
-
-	if _, err := conn.Exec(schemaSQL); err != nil {
-		conn.Close()
-		return fmt.Errorf("init schema: %w", err)
-	}
-
-	db = conn
-	return nil
-}

main.go

@@ -1,12 +1,15 @@
 package main
 
 import (
+	"context"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"strings"
 
+	"enclave/internal/keybase"
+
 	"github.com/extism/go-pdk"
 )
 
@@ -342,20 +345,15 @@ func query() int32 {
 }
 
 func initializeDatabase(credentialBytes []byte) (string, error) {
-	conn, err := openDatabase()
+	kb, err := keybase.Open()
 	if err != nil {
 		return "", fmt.Errorf("open database: %w", err)
 	}
 
-	did := fmt.Sprintf("did:sonr:%x", credentialBytes[:16])
+	ctx := context.Background()
-
+	did, err := kb.Initialize(ctx, credentialBytes)
-	docJSON := fmt.Sprintf(`{"@context":["https://www.w3.org/ns/did/v1"],"id":"%s"}`, did)
-	_, err = conn.Exec(
-		"INSERT INTO did_documents (did, controller, document, sequence) VALUES (?, ?, ?, ?)",
-		did, did, docJSON, 0,
-	)
 	if err != nil {
-		return "", fmt.Errorf("insert DID: %w", err)
+		return "", fmt.Errorf("initialize: %w", err)
 	}
 
 	pdk.Log(pdk.LogDebug, "initializeDatabase: created schema and initial records")
@@ -363,11 +361,11 @@ func initializeDatabase(credentialBytes []byte) (string, error) {
 }
 
 func serializeDatabase() ([]byte, error) {
-	data, err := serializeDatabaseBytes()
+	kb := keybase.Get()
-	if err != nil {
+	if kb == nil {
-		return nil, fmt.Errorf("serialize: %w", err)
+		return nil, errors.New("database not initialized")
 	}
-	return data, nil
+	return kb.Serialize()
 }
 
 func loadDatabase(data []byte) (string, error) {
@@ -375,19 +373,15 @@ func loadDatabase(data []byte) (string, error) {
 		return "", errors.New("invalid database format")
 	}
 
-	if err := loadDatabaseFromBytes(data); err != nil {
+	kb, err := keybase.Open()
-		return "", fmt.Errorf("load database: %w", err)
-	}
-
-	conn := getDatabase()
-	if conn == nil {
-		return "", errors.New("database not initialized")
-	}
-
-	var did string
-	err := conn.QueryRow("SELECT did FROM did_documents LIMIT 1").Scan(&did)
 	if err != nil {
-		return "", fmt.Errorf("query DID: %w", err)
+		return "", fmt.Errorf("open database: %w", err)
+	}
+
+	ctx := context.Background()
+	did, err := kb.Load(ctx, data)
+	if err != nil {
+		return "", fmt.Errorf("load DID: %w", err)
 	}
 
 	pdk.Log(pdk.LogDebug, "loadDatabase: database loaded successfully")

sqlc.yaml

@@ -1,12 +1,12 @@
 version: "2"
 sql:
   - engine: "sqlite"
-    queries: "db/query.sql"
+    queries: "internal/migrations/query.sql"
-    schema: "db/schema.sql"
+    schema: "internal/migrations/schema.sql"
     gen:
       go:
-        package: "db"
+        package: "keybase"
-        out: "db"
+        out: "internal/keybase"
         emit_json_tags: true
         emit_empty_slices: true
         emit_pointers_for_null_types: true