refactor db.zig to use std.json.Stringify

- replace manual JSON string building with json.Stringify API
- remove appendEscaped() - json.write() handles escaping
- merge execSqlNoArgs into execSql with default empty args
- extract extractRows() helper for turso response parsing
- reuse extractRows() in parseCount() to reduce duplication

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

backend/src/db.zig

···
 const std = @import("std");
 const mem = std.mem;
-const Thread = std.Thread;
-const Allocator = mem.Allocator;
 const json = std.json;
 const http = std.http;
-const Io = std.Io;
+const Allocator = mem.Allocator;
 
 pub var turso_url: []const u8 = undefined;
 pub var turso_token: []const u8 = undefined;
-pub var mutex: Thread.Mutex = .{};
+pub var mutex: std.Thread.Mutex = .{};
 
 var gpa: std.heap.GeneralPurposeAllocator(.{}) = .{};
 
+// Turso API response types
+const TursoResponse = struct {
+    results: []const TursoResult,
+};
+
+const TursoResult = struct {
+    type: []const u8,
+    response: ?TursoResultResponse = null,
+};
+
+const TursoResultResponse = struct {
+    type: []const u8,
+    result: ?TursoQueryResult = null,
+};
+
+const TursoQueryResult = struct {
+    rows: []const []const TursoValue,
+};
+
+const TursoValue = struct {
+    type: []const u8,
+    value: ?json.Value = null,
+};
+
+// Search result type
+pub const SearchResult = struct {
+    uri: []const u8,
+    did: []const u8,
+    title: []const u8,
+    snippet: []const u8,
+    createdAt: []const u8,
+    rkey: []const u8,
+    basePath: []const u8,
+};
+
 pub fn init() !void {
     turso_url = std.posix.getenv("TURSO_URL") orelse {
         std.debug.print("TURSO_URL not set\n", .{});
···
 pub fn close() void {}
 
 fn initSchema() !void {
-    _ = try execSqlNoArgs(
+    _ = try execSql(
         \\CREATE TABLE IF NOT EXISTS documents (
         \\  uri TEXT PRIMARY KEY,
         \\  did TEXT NOT NULL,
···
         \\  created_at TEXT,
         \\  publication_uri TEXT
         \\)
-    );
+    , &.{});
 
-    _ = try execSqlNoArgs(
+    _ = try execSql(
         \\CREATE VIRTUAL TABLE IF NOT EXISTS documents_fts USING fts5(
         \\  uri UNINDEXED,
         \\  title,
         \\  content
         \\)
-    );
+    , &.{});
 
-    _ = try execSqlNoArgs(
+    _ = try execSql(
         \\CREATE TABLE IF NOT EXISTS publications (
         \\  uri TEXT PRIMARY KEY,
         \\  did TEXT NOT NULL,
···
         \\  description TEXT,
         \\  base_path TEXT
         \\)
-    );
+    , &.{});
 
     // migrate: add columns if missing
-    _ = execSqlNoArgs("ALTER TABLE documents ADD COLUMN publication_uri TEXT") catch {};
-    _ = execSqlNoArgs("ALTER TABLE publications ADD COLUMN base_path TEXT") catch {};
+    _ = execSql("ALTER TABLE documents ADD COLUMN publication_uri TEXT", &.{}) catch {};
+    _ = execSql("ALTER TABLE publications ADD COLUMN base_path TEXT", &.{}) catch {};
 
     std.debug.print("turso schema initialized with FTS5\n", .{});
 }
 
 pub fn insertDocument(uri: []const u8, did: []const u8, rkey: []const u8, title: []const u8, content: []const u8, created_at: ?[]const u8, publication_uri: ?[]const u8) !void {
-    _ = try execSqlWithArgs(
+    _ = try execSql(
         "INSERT OR REPLACE INTO documents (uri, did, rkey, title, content, created_at, publication_uri) VALUES (?, ?, ?, ?, ?, ?, ?)",
-        &[_][]const u8{ uri, did, rkey, title, content, created_at orelse "", publication_uri orelse "" },
+        &.{ uri, did, rkey, title, content, created_at orelse "", publication_uri orelse "" },
     );
 
-    // delete from fts first (ignore errors)
-    _ = execSqlWithArgs("DELETE FROM documents_fts WHERE uri = ?", &[_][]const u8{uri}) catch {};
+    _ = execSql("DELETE FROM documents_fts WHERE uri = ?", &.{uri}) catch {};
 
-    _ = execSqlWithArgs(
+    _ = execSql(
         "INSERT INTO documents_fts (uri, title, content) VALUES (?, ?, ?)",
-        &[_][]const u8{ uri, title, content },
+        &.{ uri, title, content },
     ) catch |err| {
         std.debug.print("insert FTS error: {}\n", .{err});
     };
 }
 
 pub fn insertPublication(uri: []const u8, did: []const u8, rkey: []const u8, name: []const u8, description: ?[]const u8, base_path: ?[]const u8) !void {
-    _ = try execSqlWithArgs(
+    _ = try execSql(
         "INSERT OR REPLACE INTO publications (uri, did, rkey, name, description, base_path) VALUES (?, ?, ?, ?, ?, ?)",
-        &[_][]const u8{ uri, did, rkey, name, description orelse "", base_path orelse "" },
+        &.{ uri, did, rkey, name, description orelse "", base_path orelse "" },
     );
 }
 
 pub fn deleteDocument(uri: []const u8) void {
-    _ = execSqlWithArgs("DELETE FROM documents WHERE uri = ?", &[_][]const u8{uri}) catch {};
-    _ = execSqlWithArgs("DELETE FROM documents_fts WHERE uri = ?", &[_][]const u8{uri}) catch {};
+    _ = execSql("DELETE FROM documents WHERE uri = ?", &.{uri}) catch {};
+    _ = execSql("DELETE FROM documents_fts WHERE uri = ?", &.{uri}) catch {};
 }
 
 pub fn deletePublication(uri: []const u8) void {
-    _ = execSqlWithArgs("DELETE FROM publications WHERE uri = ?", &[_][]const u8{uri}) catch {};
+    _ = execSql("DELETE FROM publications WHERE uri = ?", &.{uri}) catch {};
 }
 
 pub fn searchDocuments(alloc: Allocator, query: []const u8) !std.ArrayList(u8) {
-    var response: std.ArrayList(u8) = .{};
-    try response.appendSlice(alloc, "[");
+    var output: std.ArrayList(u8) = .{};
+    const writer = output.writer(alloc);
 
     const temp_alloc = gpa.allocator();
 
-    const result = execSqlWithArgs(
+    const result = execSql(
         "SELECT f.uri, d.did, d.title, snippet(documents_fts, 2, '<mark>', '</mark>', '...', 32) as snippet, d.created_at, d.rkey, p.base_path FROM documents_fts f JOIN documents d ON f.uri = d.uri LEFT JOIN publications p ON d.publication_uri = p.uri WHERE documents_fts MATCH ? ORDER BY rank LIMIT 50",
-        &[_][]const u8{query},
+        &.{query},
     ) catch {
-        try response.appendSlice(alloc, "]");
-        return response;
+        try writer.writeAll("[]");
+        return output;
     };
     defer temp_alloc.free(result);
 
-    const parsed = json.parseFromSlice(json.Value, temp_alloc, result, .{}) catch {
-        try response.appendSlice(alloc, "]");
-        return response;
+    const rows = extractRows(temp_alloc, result) catch {
+        try writer.writeAll("[]");
+        return output;
     };
-    defer parsed.deinit();
 
-    const results = parsed.value.object.get("results") orelse {
-        try response.appendSlice(alloc, "]");
-        return response;
-    };
+    var jw: json.Stringify = .{ .writer = &writer.any() };
+    try jw.beginArray();
 
-    if (results != .array or results.array.items.len == 0) {
-        try response.appendSlice(alloc, "]");
-        return response;
-    }
+    for (rows) |row| {
+        if (row.len < 7) continue;
 
-    const first_result = results.array.items[0];
-    if (first_result != .object) {
-        try response.appendSlice(alloc, "]");
-        return response;
+        try jw.beginObject();
+        try jw.objectField("uri");
+        try jw.write(extractText(row[0]));
+        try jw.objectField("did");
+        try jw.write(extractText(row[1]));
+        try jw.objectField("title");
+        try jw.write(extractText(row[2]));
+        try jw.objectField("snippet");
+        try jw.write(extractText(row[3]));
+        try jw.objectField("createdAt");
+        try jw.write(extractText(row[4]));
+        try jw.objectField("rkey");
+        try jw.write(extractText(row[5]));
+        try jw.objectField("basePath");
+        try jw.write(extractText(row[6]));
+        try jw.endObject();
     }
 
-    const resp_obj = first_result.object.get("response") orelse {
-        try response.appendSlice(alloc, "]");
-        return response;
-    };
+    try jw.endArray();
+    return output;
+}
 
-    if (resp_obj != .object) {
-        try response.appendSlice(alloc, "]");
-        return response;
-    }
-
-    const result_obj = resp_obj.object.get("result") orelse {
-        try response.appendSlice(alloc, "]");
-        return response;
-    };
-
-    if (result_obj != .object) {
-        try response.appendSlice(alloc, "]");
-        return response;
-    }
+fn extractRows(alloc: Allocator, result: []const u8) ![]const []const json.Value {
+    const parsed = try json.parseFromSlice(json.Value, alloc, result, .{});
+    defer parsed.deinit();
 
-    const rows = result_obj.object.get("rows") orelse {
-        try response.appendSlice(alloc, "]");
-        return response;
-    };
+    const results = parsed.value.object.get("results") orelse return &.{};
+    if (results != .array or results.array.items.len == 0) return &.{};
 
-    if (rows != .array) {
-        try response.appendSlice(alloc, "]");
-        return response;
-    }
+    const first = results.array.items[0];
+    if (first != .object) return &.{};
 
-    var first = true;
-    for (rows.array.items) |row| {
-        if (row != .array) continue;
-        const cols = row.array.items;
-        if (cols.len < 7) continue;
+    const resp = first.object.get("response") orelse return &.{};
+    if (resp != .object) return &.{};
 
-        if (!first) try response.appendSlice(alloc, ",");
-        first = false;
+    const res = resp.object.get("result") orelse return &.{};
+    if (res != .object) return &.{};
 
-        const uri = getTextValue(cols[0]);
-        const did = getTextValue(cols[1]);
-        const title = getTextValue(cols[2]);
-        const snippet = getTextValue(cols[3]);
-        const created_at = getTextValue(cols[4]);
-        const rkey = getTextValue(cols[5]);
-        const base_path = getTextValue(cols[6]);
+    const rows = res.object.get("rows") orelse return &.{};
+    if (rows != .array) return &.{};
 
-        try response.appendSlice(alloc, "{\"uri\":\"");
-        try appendEscaped(alloc, &response, uri);
-        try response.appendSlice(alloc, "\",\"did\":\"");
-        try appendEscaped(alloc, &response, did);
-        try response.appendSlice(alloc, "\",\"title\":\"");
-        try appendEscaped(alloc, &response, title);
-        try response.appendSlice(alloc, "\",\"snippet\":\"");
-        try appendEscaped(alloc, &response, snippet);
-        try response.appendSlice(alloc, "\",\"createdAt\":\"");
-        try appendEscaped(alloc, &response, created_at);
-        try response.appendSlice(alloc, "\",\"rkey\":\"");
-        try appendEscaped(alloc, &response, rkey);
-        try response.appendSlice(alloc, "\",\"basePath\":\"");
-        try appendEscaped(alloc, &response, base_path);
-        try response.appendSlice(alloc, "\"}");
+    var result_rows = std.ArrayList([]const json.Value).init(alloc);
+    for (rows.array.items) |row| {
+        if (row == .array) {
+            try result_rows.append(row.array.items);
+        }
     }
-
-    try response.appendSlice(alloc, "]");
-    return response;
+    return result_rows.toOwnedSlice();
 }
 
-fn getTextValue(val: json.Value) []const u8 {
+fn extractText(val: json.Value) []const u8 {
     return switch (val) {
         .string => |s| s,
         .object => |obj| if (obj.get("value")) |v| (if (v == .string) v.string else "") else "",
···
     };
 }
 
-fn appendEscaped(alloc: Allocator, list: *std.ArrayList(u8), s: []const u8) !void {
-    for (s) |c| {
-        switch (c) {
-            '"' => try list.appendSlice(alloc, "\\\""),
-            '\\' => try list.appendSlice(alloc, "\\\\"),
-            '\n' => try list.appendSlice(alloc, "\\n"),
-            '\r' => try list.appendSlice(alloc, "\\r"),
-            '\t' => try list.appendSlice(alloc, "\\t"),
-            else => try list.append(alloc, c),
-        }
-    }
-}
-
-fn execSqlNoArgs(sql: []const u8) ![]const u8 {
-    return execSqlWithArgs(sql, &[_][]const u8{});
-}
-
-fn execSqlWithArgs(sql: []const u8, args: []const []const u8) ![]const u8 {
+fn execSql(sql: []const u8, args: []const []const u8) ![]const u8 {
     mutex.lock();
     defer mutex.unlock();
 
···
             turso_url,
     }) catch return error.UrlTooLong;
 
-    // build request body with parameterized args
+    // build request body
     var body: std.ArrayList(u8) = .{};
     defer body.deinit(alloc);
+    const writer = body.writer(alloc);
 
-    try body.appendSlice(alloc, "{\"requests\":[{\"type\":\"execute\",\"stmt\":{\"sql\":\"");
-    for (sql) |c| {
-        switch (c) {
-            '"' => try body.appendSlice(alloc, "\\\""),
-            '\\' => try body.appendSlice(alloc, "\\\\"),
-            '\n' => try body.appendSlice(alloc, "\\n"),
-            '\r' => try body.appendSlice(alloc, "\\r"),
-            '\t' => try body.appendSlice(alloc, "\\t"),
-            else => try body.append(alloc, c),
-        }
-    }
-    try body.appendSlice(alloc, "\"");
+    var jw: json.Stringify = .{ .writer = &writer.any() };
+    try jw.beginObject();
+    try jw.objectField("requests");
+    try jw.beginArray();
 
-    // add args array if we have any
+    // execute statement
+    try jw.beginObject();
+    try jw.objectField("type");
+    try jw.write("execute");
+    try jw.objectField("stmt");
+    try jw.beginObject();
+    try jw.objectField("sql");
+    try jw.write(sql);
     if (args.len > 0) {
-        try body.appendSlice(alloc, ",\"args\":[");
-        for (args, 0..) |arg, i| {
-            if (i > 0) try body.appendSlice(alloc, ",");
-            try body.appendSlice(alloc, "{\"type\":\"text\",\"value\":\"");
-            for (arg) |c| {
-                switch (c) {
-                    '"' => try body.appendSlice(alloc, "\\\""),
-                    '\\' => try body.appendSlice(alloc, "\\\\"),
-                    '\n' => try body.appendSlice(alloc, "\\n"),
-                    '\r' => try body.appendSlice(alloc, "\\r"),
-                    '\t' => try body.appendSlice(alloc, "\\t"),
-                    else => try body.append(alloc, c),
-                }
-            }
-            try body.appendSlice(alloc, "\"}");
+        try jw.objectField("args");
+        try jw.beginArray();
+        for (args) |arg| {
+            try jw.beginObject();
+            try jw.objectField("type");
+            try jw.write("text");
+            try jw.objectField("value");
+            try jw.write(arg);
+            try jw.endObject();
         }
-        try body.appendSlice(alloc, "]");
+        try jw.endArray();
     }
+    try jw.endObject();
+    try jw.endObject();
 
-    try body.appendSlice(alloc, "}},{\"type\":\"close\"}]}");
+    // close statement
+    try jw.beginObject();
+    try jw.objectField("type");
+    try jw.write("close");
+    try jw.endObject();
+
+    try jw.endArray();
+    try jw.endObject();
 
     var auth_buf: [512]u8 = undefined;
     const auth_header = std.fmt.bufPrint(&auth_buf, "Bearer {s}", .{turso_token}) catch return error.AuthTooLong;
···
     var client: http.Client = .{ .allocator = alloc };
     defer client.deinit();
 
-    var aw: Io.Writer.Allocating = .init(alloc);
-    defer aw.deinit();
+    var response_body: std.Io.Writer.Allocating = .init(alloc);
+    defer response_body.deinit();
 
     const result = client.fetch(.{
         .location = .{ .url = url },
···
             .authorization = .{ .override = auth_header },
         },
         .payload = body.items,
-        .response_writer = &aw.writer,
+        .response_writer = &response_body.writer,
     }) catch |err| {
         std.debug.print("turso request failed: {}\n", .{err});
         return error.HttpError;
···
         return error.TursoError;
     }
 
-    return try aw.toOwnedSlice();
+    return try response_body.toOwnedSlice();
 }
 
 pub fn getStats() struct { documents: i64, publications: i64 } {
-    const doc_result = execSqlNoArgs("SELECT COUNT(*) FROM documents") catch return .{ .documents = 0, .publications = 0 };
+    const doc_result = execSql("SELECT COUNT(*) FROM documents", &.{}) catch return .{ .documents = 0, .publications = 0 };
     defer gpa.allocator().free(doc_result);
 
-    const pub_result = execSqlNoArgs("SELECT COUNT(*) FROM publications") catch return .{ .documents = 0, .publications = 0 };
+    const pub_result = execSql("SELECT COUNT(*) FROM publications", &.{}) catch return .{ .documents = 0, .publications = 0 };
     defer gpa.allocator().free(pub_result);
 
-    const doc_count = parseCount(doc_result);
-    const pub_count = parseCount(pub_result);
-
-    return .{ .documents = doc_count, .publications = pub_count };
+    return .{
+        .documents = parseCount(doc_result),
+        .publications = parseCount(pub_result),
+    };
 }
 
 fn parseCount(result: []const u8) i64 {
     const alloc = gpa.allocator();
-    const parsed = json.parseFromSlice(json.Value, alloc, result, .{}) catch return 0;
-    defer parsed.deinit();
-
-    const results = parsed.value.object.get("results") orelse return 0;
-    if (results != .array or results.array.items.len == 0) return 0;
+    const rows = extractRows(alloc, result) catch return 0;
+    if (rows.len == 0) return 0;
+    if (rows[0].len == 0) return 0;
 
-    const first = results.array.items[0];
-    if (first != .object) return 0;
-
-    const resp = first.object.get("response") orelse return 0;
-    if (resp != .object) return 0;
-
-    const res = resp.object.get("result") orelse return 0;
-    if (res != .object) return 0;
-
-    const rows = res.object.get("rows") orelse return 0;
-    if (rows != .array or rows.array.items.len == 0) return 0;
-
-    const row = rows.array.items[0];
-    if (row != .array or row.array.items.len == 0) return 0;
-
-    const val = row.array.items[0];
+    const val = rows[0][0];
     return switch (val) {
         .integer => |i| i,
         .object => |obj| blk: {