@awiki/cli 0.0.1-beta.2

package/internal/store/dao_test.go

@@ -0,0 +1,87 @@
+package store
+
+import (
+	"context"
+	"testing"
+)
+
+func TestStoreMessageAndThreadView(t *testing.T) {
+	t.Parallel()
+
+	db := openTestDB(t)
+	ctx := context.Background()
+	if err := EnsureSchema(ctx, db); err != nil {
+		t.Fatalf("EnsureSchema() error = %v", err)
+	}
+	if err := StoreMessage(ctx, db, MessageRecord{
+		MsgID:          "msg-1",
+		OwnerDID:       "did:wba:awiki.ai:user:a",
+		ThreadID:       MakeThreadID("did:wba:awiki.ai:user:a", "did:wba:awiki.ai:user:b", ""),
+		Direction:      0,
+		SenderDID:      "did:wba:awiki.ai:user:b",
+		ReceiverDID:    "did:wba:awiki.ai:user:a",
+		ContentType:    "text",
+		Content:        "hello",
+		IsRead:         false,
+		CredentialName: "default",
+	}); err != nil {
+		t.Fatalf("StoreMessage() error = %v", err)
+	}
+	got, err := GetMessageByID(ctx, db, "msg-1", "did:wba:awiki.ai:user:a", "")
+	if err != nil {
+		t.Fatalf("GetMessageByID() error = %v", err)
+	}
+	if got["content"] != "hello" {
+		t.Fatalf("unexpected message content: %#v", got)
+	}
+	rows, err := ExecuteSQL(ctx, db, "SELECT thread_id, unread_count FROM threads")
+	if err != nil {
+		t.Fatalf("ExecuteSQL() error = %v", err)
+	}
+	if len(rows) != 1 {
+		t.Fatalf("unexpected threads rows: %#v", rows)
+	}
+}
+
+func TestRebindOwnerDIDAndClearE2EEData(t *testing.T) {
+	t.Parallel()
+
+	db := openTestDB(t)
+	ctx := context.Background()
+	if err := EnsureSchema(ctx, db); err != nil {
+		t.Fatalf("EnsureSchema() error = %v", err)
+	}
+	if _, err := QueueE2EEOutbox(ctx, db, E2EEOutboxRecord{
+		OutboxID:       "out-1",
+		OwnerDID:       "did:old",
+		PeerDID:        "did:peer",
+		Plaintext:      "secret",
+		LocalStatus:    "queued",
+		CredentialName: "default",
+	}); err != nil {
+		t.Fatalf("QueueE2EEOutbox() error = %v", err)
+	}
+	if _, err := db.ExecContext(ctx, `
+INSERT INTO e2ee_sessions
+    (owner_did, peer_did, session_id, is_initiator, send_chain_key, recv_chain_key, send_seq, recv_seq, expires_at, created_at, active_at, peer_confirmed, credential_name, updated_at)
+VALUES ('did:old', 'did:peer', 'sess-1', 1, 'send', 'recv', 0, 0, NULL, '2026-01-01T00:00:00Z', NULL, 0, 'default', '2026-01-01T00:00:00Z')`); err != nil {
+		t.Fatalf("insert e2ee session error = %v", err)
+	}
+	if err := UpsertContact(ctx, db, ContactRecord{OwnerDID: "did:old", DID: "did:peer", Name: "Peer"}); err != nil {
+		t.Fatalf("UpsertContact() error = %v", err)
+	}
+	result, err := RebindOwnerDID(ctx, db, "did:old", "did:new")
+	if err != nil {
+		t.Fatalf("RebindOwnerDID() error = %v", err)
+	}
+	if result["contacts"] != 1 {
+		t.Fatalf("unexpected rebind counts: %#v", result)
+	}
+	cleared, err := ClearOwnerE2EEData(ctx, db, "did:old")
+	if err != nil {
+		t.Fatalf("ClearOwnerE2EEData() error = %v", err)
+	}
+	if cleared["e2ee_outbox"] != 1 || cleared["e2ee_sessions"] != 1 {
+		t.Fatalf("unexpected clear result: %#v", cleared)
+	}
+}

package/internal/store/helpers.go

@@ -0,0 +1,197 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+	"time"
+)
+
+var (
+	forbiddenPatterns = []*regexp.Regexp{
+		regexp.MustCompile(`\bDROP\b`),
+		regexp.MustCompile(`\bTRUNCATE\b`),
+	}
+)
+
+func nowUTC() string {
+	return time.Now().UTC().Format(time.RFC3339)
+}
+
+func MakeThreadID(myDID string, peerDID string, groupID string) string {
+	if strings.TrimSpace(groupID) != "" {
+		return fmt.Sprintf("group:%s", strings.TrimSpace(groupID))
+	}
+	if strings.TrimSpace(peerDID) != "" {
+		pair := []string{strings.TrimSpace(myDID), strings.TrimSpace(peerDID)}
+		sort.Strings(pair)
+		return fmt.Sprintf("dm:%s:%s", pair[0], pair[1])
+	}
+	return fmt.Sprintf("dm:%s:unknown", strings.TrimSpace(myDID))
+}
+
+func normalizeOwnerDID(value string) string {
+	return strings.TrimSpace(value)
+}
+
+func normalizeCredentialName(value string) string {
+	return strings.TrimSpace(value)
+}
+
+func normalizeOptionalString(value string) any {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return nil
+	}
+	return value
+}
+
+func normalizeOptionalBool(value *bool) any {
+	if value == nil {
+		return nil
+	}
+	if *value {
+		return 1
+	}
+	return 0
+}
+
+func normalizeOptionalInt64(value *int64) any {
+	if value == nil {
+		return nil
+	}
+	return *value
+}
+
+func normalizeOptionalFloat64(value *float64) any {
+	if value == nil {
+		return nil
+	}
+	return *value
+}
+
+func defaultInt64Ptr(value *int64, fallback *int64) *int64 {
+	if value != nil {
+		return value
+	}
+	return fallback
+}
+
+func normalizeMetadata(value string) any {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return nil
+	}
+	return value
+}
+
+func metadataFromAny(value any) string {
+	if value == nil {
+		return ""
+	}
+	switch typed := value.(type) {
+	case string:
+		return typed
+	default:
+		raw, err := json.Marshal(typed)
+		if err != nil {
+			return ""
+		}
+		return string(raw)
+	}
+}
+
+func queryMaps(ctx context.Context, db *sql.DB, query string, args ...any) ([]map[string]any, error) {
+	rows, err := db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	columns, err := rows.Columns()
+	if err != nil {
+		return nil, err
+	}
+	results := make([]map[string]any, 0)
+	for rows.Next() {
+		values := make([]any, len(columns))
+		pointers := make([]any, len(columns))
+		for index := range values {
+			pointers[index] = &values[index]
+		}
+		if err := rows.Scan(pointers...); err != nil {
+			return nil, err
+		}
+		item := make(map[string]any, len(columns))
+		for index, column := range columns {
+			item[column] = convertSQLiteValue(values[index])
+		}
+		results = append(results, item)
+	}
+	return results, rows.Err()
+}
+
+func queryOneMap(ctx context.Context, db *sql.DB, query string, args ...any) (map[string]any, error) {
+	rows, err := queryMaps(ctx, db, query, args...)
+	if err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return nil, sql.ErrNoRows
+	}
+	return rows[0], nil
+}
+
+func convertSQLiteValue(value any) any {
+	switch typed := value.(type) {
+	case []byte:
+		return string(typed)
+	default:
+		return typed
+	}
+}
+
+func tableExists(ctx context.Context, db *sql.DB, tableName string) (bool, error) {
+	var exists int
+	row := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = ?", tableName)
+	if err := row.Scan(&exists); err != nil {
+		return false, err
+	}
+	return exists > 0, nil
+}
+
+func viewExists(ctx context.Context, db *sql.DB, viewName string) (bool, error) {
+	var exists int
+	row := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM sqlite_master WHERE type = 'view' AND name = ?", viewName)
+	if err := row.Scan(&exists); err != nil {
+		return false, err
+	}
+	return exists > 0, nil
+}
+
+func columnNames(ctx context.Context, db *sql.DB, tableName string) (map[string]struct{}, error) {
+	rows, err := queryMaps(ctx, db, fmt.Sprintf("PRAGMA table_info(%s)", tableName))
+	if err != nil {
+		return nil, err
+	}
+	columns := make(map[string]struct{}, len(rows))
+	for _, row := range rows {
+		name, _ := row["name"].(string)
+		if name != "" {
+			columns[name] = struct{}{}
+		}
+	}
+	return columns, nil
+}
+
+func schemaVersion(ctx context.Context, db *sql.DB) (int, error) {
+	var version int
+	row := db.QueryRowContext(ctx, "PRAGMA user_version")
+	if err := row.Scan(&version); err != nil {
+		return 0, err
+	}
+	return version, nil
+}