+4

backend/fly.toml

··· 3 3 4 4 [build] 5 5 6 6 + [env] 7 7 + TAP_HOST = 'pollz-tap.internal' 8 8 + TAP_PORT = '2480' 9 9 + 6 10 [http_service] 7 11 internal_port = 3000 8 12 force_https = true

-97

backend/src/backfill.zig

··· 1 1 - const std = @import("std"); 2 2 - const mem = std.mem; 3 3 - const json = std.json; 4 4 - const Allocator = mem.Allocator; 5 5 - const db = @import("db.zig"); 6 6 - const jetstream = @import("jetstream.zig"); 7 7 - 8 8 - pub fn run(allocator: Allocator) void { 9 9 - std.debug.print("starting backfill from ufos-api.microcosm.blue...\n", .{}); 10 10 - 11 11 - backfillCollection(allocator, "tech.waow.poll"); 12 12 - backfillCollection(allocator, "tech.waow.vote"); 13 13 - 14 14 - std.debug.print("backfill complete\n", .{}); 15 15 - } 16 16 - 17 17 - fn backfillCollection(allocator: Allocator, collection: []const u8) void { 18 18 - var url_buf: [256]u8 = undefined; 19 19 - const url = std.fmt.bufPrint(&url_buf, "https://ufos-api.microcosm.blue/records?collection={s}", .{collection}) catch return; 20 20 - 21 21 - std.debug.print("backfill: fetching {s} from ufos\n", .{collection}); 22 22 - 23 23 - // make https request 24 24 - var client = std.http.Client{ .allocator = allocator }; 25 25 - defer client.deinit(); 26 26 - 27 27 - const uri = std.Uri.parse(url) catch return; 28 28 - 29 29 - var req = client.request(.GET, uri, .{ 30 30 - .headers = .{ .accept_encoding = .{ .override = "identity" } }, 31 31 - }) catch |err| { 32 32 - std.debug.print("backfill: http request error: {}\n", .{err}); 33 33 - return; 34 34 - }; 35 35 - defer req.deinit(); 36 36 - 37 37 - req.sendBodiless() catch |err| { 38 38 - std.debug.print("backfill: http send error: {}\n", .{err}); 39 39 - return; 40 40 - }; 41 41 - 42 42 - var redirect_buf: [8192]u8 = undefined; 43 43 - var response = req.receiveHead(&redirect_buf) catch |err| { 44 44 - std.debug.print("backfill: http receive error: {}\n", .{err}); 45 45 - return; 46 46 - }; 47 47 - 48 48 - if (response.head.status != .ok) { 49 49 - std.debug.print("backfill: http status {}\n", .{response.head.status}); 50 50 - return; 51 51 - } 52 52 - 53 53 - // read response body 54 54 - var reader = response.reader(&.{}); 55 55 - const body = reader.allocRemaining(allocator, std.Io.Limit.limited(65536)) catch |err| { 56 56 - std.debug.print("backfill: http read error: {}\n", .{err}); 57 57 - return; 58 58 - }; 59 59 - defer allocator.free(body); 60 60 - 61 61 - // parse json response - UFOs returns array of {did, collection, rkey, record} 62 62 - const parsed = json.parseFromSlice(json.Value, allocator, body, .{}) catch |err| { 63 63 - std.debug.print("backfill: json parse error: {}\n", .{err}); 64 64 - return; 65 65 - }; 66 66 - defer parsed.deinit(); 67 67 - 68 68 - if (parsed.value != .array) return; 69 69 - 70 70 - var count: usize = 0; 71 71 - for (parsed.value.array.items) |item| { 72 72 - if (item != .object) continue; 73 73 - 74 74 - const did = item.object.get("did") orelse continue; 75 75 - if (did != .string) continue; 76 76 - 77 77 - const rkey = item.object.get("rkey") orelse continue; 78 78 - if (rkey != .string) continue; 79 79 - 80 80 - const record = item.object.get("record") orelse continue; 81 81 - if (record != .object) continue; 82 82 - 83 83 - // construct record uri 84 84 - const record_uri = std.fmt.allocPrint(allocator, "at://{s}/{s}/{s}", .{ did.string, collection, rkey.string }) catch continue; 85 85 - defer allocator.free(record_uri); 86 86 - 87 87 - if (mem.eql(u8, collection, "tech.waow.poll")) { 88 88 - jetstream.processPoll(allocator, record_uri, did.string, rkey.string, record.object) catch continue; 89 89 - count += 1; 90 90 - } else if (mem.eql(u8, collection, "tech.waow.vote")) { 91 91 - jetstream.processVote(record_uri, did.string, record.object) catch continue; 92 92 - count += 1; 93 93 - } 94 94 - } 95 95 - 96 96 - std.debug.print("backfill: indexed {d} {s} records\n", .{ count, collection }); 97 97 - }

+12 -36

backend/src/db.zig

··· 70 70 return err; 71 71 }; 72 72 73 73 - conn.execNoArgs( 74 74 - \\CREATE TABLE IF NOT EXISTS cursor ( 75 75 - \\ id INTEGER PRIMARY KEY CHECK (id = 1), 76 76 - \\ time_us INTEGER NOT NULL 77 77 - \\) 78 78 - ) catch |err| { 79 79 - std.debug.print("failed to create cursor table: {}\n", .{err}); 80 80 - return err; 81 81 - }; 82 82 - 83 73 std.debug.print("database schema initialized\n", .{}); 84 74 } 85 75 86 86 - pub fn getCursor() ?i64 { 87 87 - mutex.lock(); 88 88 - defer mutex.unlock(); 89 89 - 90 90 - const row = conn.row("SELECT time_us FROM cursor WHERE id = 1", .{}) catch return null; 91 91 - if (row == null) return null; 92 92 - defer row.?.deinit(); 93 93 - return row.?.int(0); 94 94 - } 95 95 - 96 96 - pub fn saveCursor(time_us: i64) void { 97 97 - mutex.lock(); 98 98 - defer mutex.unlock(); 99 99 - 100 100 - conn.exec("INSERT OR REPLACE INTO cursor (id, time_us) VALUES (1, ?)", .{time_us}) catch |err| { 101 101 - std.debug.print("failed to save cursor: {}\n", .{err}); 102 102 - }; 103 103 - } 104 104 - 105 76 pub fn insertPoll(uri: []const u8, did: []const u8, rkey: []const u8, text_json: []const u8, options_json: []const u8, created_at: []const u8) !void { 106 77 mutex.lock(); 107 78 defer mutex.unlock(); ··· 119 90 mutex.lock(); 120 91 defer mutex.unlock(); 121 92 122 122 - // delete any existing vote by this user on this poll, then insert new one 123 123 - // this enforces one vote per user per poll 124 124 - conn.exec("DELETE FROM votes WHERE subject = ? AND voter = ?", .{ subject, voter }) catch {}; 125 125 - 93 93 + // upsert: update if exists and new vote is newer, otherwise insert 94 94 + // this handles out-of-order events from tap 126 95 conn.exec( 127 127 - "INSERT INTO votes (uri, subject, option, voter, created_at) VALUES (?, ?, ?, ?, ?)", 128 128 - .{ uri, subject, option, voter, created_at }, 129 129 - ) catch |err| { 96 96 + \\INSERT INTO votes (uri, subject, option, voter, created_at) 97 97 + \\VALUES (?, ?, ?, ?, ?) 98 98 + \\ON CONFLICT(subject, voter) DO UPDATE SET 99 99 + \\ uri = excluded.uri, 100 100 + \\ option = excluded.option, 101 101 + \\ created_at = excluded.created_at 102 102 + \\WHERE excluded.created_at > votes.created_at OR votes.created_at IS NULL 103 103 + , .{ uri, subject, option, voter, created_at }) catch |err| { 130 104 std.debug.print("db insert vote error: {}\n", .{err}); 131 105 return err; 132 106 }; ··· 149 123 mutex.lock(); 150 124 defer mutex.unlock(); 151 125 126 126 + // only delete if the URI matches - if a newer vote replaced this one, 127 127 + // the URI won't match and we should not delete 152 128 conn.exec("DELETE FROM votes WHERE uri = ?", .{uri}) catch |err| { 153 129 std.debug.print("db delete vote error: {}\n", .{err}); 154 130 };

+51 -41

backend/src/jetstream.zig backend/src/tap.zig

··· 9 9 const POLL_COLLECTION = "tech.waow.poll"; 10 10 const VOTE_COLLECTION = "tech.waow.vote"; 11 11 12 12 + // tap url from env or default to fly.io internal network 13 13 + fn getTapHost() []const u8 { 14 14 + return std.posix.getenv("TAP_HOST") orelse "pollz-tap.fly.dev"; 15 15 + } 16 16 + 17 17 + fn getTapPort() u16 { 18 18 + const port_str = std.posix.getenv("TAP_PORT") orelse "443"; 19 19 + return std.fmt.parseInt(u16, port_str, 10) catch 443; 20 20 + } 21 21 + 22 22 + fn useTls() bool { 23 23 + const port = getTapPort(); 24 24 + return port == 443; 25 25 + } 26 26 + 12 27 pub fn consumer(allocator: Allocator) void { 28 28 + // exponential backoff: 1s -> 2s -> 4s -> ... -> 60s cap 29 29 + var backoff: u64 = 1; 30 30 + const max_backoff: u64 = 60; 31 31 + 13 32 while (true) { 14 33 connect(allocator) catch |err| { 15 15 - std.debug.print("jetstream error: {}, reconnecting in 3s...\n", .{err}); 34 34 + std.debug.print("tap error: {}, reconnecting in {}s...\n", .{ err, backoff }); 16 35 }; 17 17 - posix.nanosleep(3, 0); 36 36 + posix.nanosleep(backoff, 0); 37 37 + backoff = @min(backoff * 2, max_backoff); 18 38 } 19 39 } 20 40 ··· 25 45 pub fn serverMessage(self: *Handler, data: []const u8) !void { 26 46 self.msg_count += 1; 27 47 if (self.msg_count % 100 == 1) { 28 28 - std.debug.print("jetstream: received {} messages\n", .{self.msg_count}); 48 48 + std.debug.print("tap: received {} messages\n", .{self.msg_count}); 29 49 } 30 50 processMessage(self.allocator, data) catch |err| { 31 51 std.debug.print("message processing error: {}\n", .{err}); ··· 33 53 } 34 54 35 55 pub fn close(_: *Handler) void { 36 36 - std.debug.print("jetstream connection closed\n", .{}); 56 56 + std.debug.print("tap connection closed\n", .{}); 37 57 } 38 58 }; 39 59 40 60 fn connect(allocator: Allocator) !void { 41 41 - const host = "jetstream1.us-east.bsky.network"; 61 61 + const host = getTapHost(); 62 62 + const port = getTapPort(); 63 63 + const tls = useTls(); 42 64 43 43 - var path_buf: [512]u8 = undefined; 65 65 + const path = "/channel"; 44 66 45 45 - // only use saved cursor if we have one (for resuming after disconnect) 46 46 - // otherwise start from NOW - UFOs handles backfill, Jetstream is for live events only 47 47 - const path = if (db.getCursor()) |cursor| 48 48 - std.fmt.bufPrint(&path_buf, "/subscribe?wantedCollections={s}&wantedCollections={s}&cursor={d}", .{ POLL_COLLECTION, VOTE_COLLECTION, cursor }) catch "/subscribe" 49 49 - else 50 50 - std.fmt.bufPrint(&path_buf, "/subscribe?wantedCollections={s}&wantedCollections={s}", .{ POLL_COLLECTION, VOTE_COLLECTION }) catch "/subscribe"; 51 51 - 52 52 - std.debug.print("connecting to wss://{s}{s}\n", .{ host, path }); 67 67 + std.debug.print("connecting to {s}://{s}:{d}{s}\n", .{ if (tls) "wss" else "ws", host, port, path }); 53 68 54 69 var client = websocket.Client.init(allocator, .{ 55 70 .host = host, 56 56 - .port = 443, 57 57 - .tls = true, 71 71 + .port = port, 72 72 + .tls = tls, 58 73 }) catch |err| { 59 74 std.debug.print("websocket client init failed: {}\n", .{err}); 60 75 return err; 61 76 }; 62 77 defer client.deinit(); 63 78 64 64 - std.debug.print("tcp+tls connected, starting handshake...\n", .{}); 79 79 + std.debug.print("tcp connected, starting handshake...\n", .{}); 65 80 66 66 - // add Host header which is required for websocket handshake 67 67 - var host_header_buf: [128]u8 = undefined; 68 68 - const host_header = std.fmt.bufPrint(&host_header_buf, "Host: {s}\r\n", .{host}) catch "Host: jetstream1.us-east.bsky.network\r\n"; 81 81 + var host_header_buf: [256]u8 = undefined; 82 82 + const host_header = std.fmt.bufPrint(&host_header_buf, "Host: {s}\r\n", .{host}) catch "Host: pollz-tap.fly.dev\r\n"; 69 83 70 84 client.handshake(path, .{ .headers = host_header }) catch |err| { 71 85 std.debug.print("websocket handshake failed: {}\n", .{err}); 72 86 return err; 73 87 }; 74 88 75 75 - std.debug.print("jetstream connected!\n", .{}); 89 89 + std.debug.print("tap connected!\n", .{}); 76 90 77 91 var handler = Handler{ .allocator = allocator }; 78 92 client.readLoop(&handler) catch |err| { ··· 82 96 } 83 97 84 98 fn processMessage(allocator: Allocator, payload: []const u8) !void { 85 85 - // parse jetstream event 99 99 + // parse tap event 86 100 const parsed = json.parseFromSlice(json.Value, allocator, payload, .{}) catch return; 87 101 defer parsed.deinit(); 88 102 89 103 const root = parsed.value.object; 90 104 91 91 - // save cursor from event timestamp 92 92 - if (root.get("time_us")) |time_us_val| { 93 93 - if (time_us_val == .integer) { 94 94 - db.saveCursor(time_us_val.integer); 95 95 - } 96 96 - } 105 105 + // tap format: { "id": 123, "type": "record", "record": { ... } } 106 106 + const msg_type = root.get("type") orelse return; 107 107 + if (msg_type != .string) return; 97 108 98 98 - const kind = root.get("kind") orelse return; 99 99 - if (kind != .string) return; 109 109 + if (!mem.eql(u8, msg_type.string, "record")) return; 100 110 101 101 - if (!mem.eql(u8, kind.string, "commit")) return; 111 111 + const record_wrapper = root.get("record") orelse return; 112 112 + if (record_wrapper != .object) return; 102 113 103 103 - const commit = root.get("commit") orelse return; 104 104 - if (commit != .object) return; 114 114 + const rec = record_wrapper.object; 105 115 106 106 - const collection = commit.object.get("collection") orelse return; 116 116 + const collection = rec.get("collection") orelse return; 107 117 if (collection != .string) return; 108 118 109 109 - const operation = commit.object.get("operation") orelse return; 110 110 - if (operation != .string) return; 119 119 + const action = rec.get("action") orelse return; 120 120 + if (action != .string) return; 111 121 112 112 - const did = root.get("did") orelse return; 122 122 + const did = rec.get("did") orelse return; 113 123 if (did != .string) return; 114 124 115 115 - const rkey = commit.object.get("rkey") orelse return; 125 125 + const rkey = rec.get("rkey") orelse return; 116 126 if (rkey != .string) return; 117 127 118 128 const uri_str = try std.fmt.allocPrint(allocator, "at://{s}/{s}/{s}", .{ did.string, collection.string, rkey.string }); 119 129 defer allocator.free(uri_str); 120 130 121 121 - if (mem.eql(u8, operation.string, "create")) { 122 122 - const record = commit.object.get("record") orelse return; 131 131 + if (mem.eql(u8, action.string, "create") or mem.eql(u8, action.string, "update")) { 132 132 + const record = rec.get("record") orelse return; 123 133 if (record != .object) return; 124 134 125 135 if (mem.eql(u8, collection.string, POLL_COLLECTION)) { ··· 131 141 std.debug.print("vote processing error: {}\n", .{err}); 132 142 }; 133 143 } 134 134 - } else if (mem.eql(u8, operation.string, "delete")) { 144 144 + } else if (mem.eql(u8, action.string, "delete")) { 135 145 if (mem.eql(u8, collection.string, POLL_COLLECTION)) { 136 146 db.deletePoll(uri_str); 137 147 std.debug.print("deleted poll: {s}\n", .{uri_str});

+5 -7

backend/src/main.zig

··· 3 3 const Thread = std.Thread; 4 4 const db = @import("db.zig"); 5 5 const http_server = @import("http.zig"); 6 6 - const jetstream = @import("jetstream.zig"); 7 7 - const backfill = @import("backfill.zig"); 6 6 + const tap = @import("tap.zig"); 8 7 9 8 pub fn main() !void { 10 9 var gpa = std.heap.GeneralPurposeAllocator(.{}){}; ··· 16 15 try db.init(db_path); 17 16 defer db.close(); 18 17 19 19 - // backfill existing records from known repos at startup 20 20 - backfill.run(allocator); 18 18 + // tap handles backfill automatically - no need to call backfill.run() 21 19 22 22 - // start jetstream consumer in background 23 23 - const jetstream_thread = try Thread.spawn(.{}, jetstream.consumer, .{allocator}); 24 24 - defer jetstream_thread.join(); 20 20 + // start tap consumer in background 21 21 + const tap_thread = try Thread.spawn(.{}, tap.consumer, .{allocator}); 22 22 + defer tap_thread.join(); 25 23 26 24 // start http server (bind to 0.0.0.0 for containerized deployments) 27 25 const address = try net.Address.parseIp("0.0.0.0", 3000);

-137

backend/zignotes.md

··· 1 1 - # zig 0.15 notes 2 2 - 3 3 - ## breaking changes from 0.14 4 4 - 5 5 - ### `json.stringify` → `json.fmt` 6 6 - ```zig 7 7 - // old: json.stringify(value, .{}, writer); 8 8 - // new: use json.fmt formatter 9 9 - try buffer.print(allocator, "{f}", .{json.fmt(value, .{})}); 10 10 - ``` 11 11 - 12 12 - ### `std.builtin.Mode` → `std.builtin.OptimizeMode` 13 13 - the optimization mode enum was renamed 14 14 - 15 15 - ### `std.time.sleep` removed 16 16 - use `std.posix.nanosleep(seconds, nanoseconds)` instead 17 17 - 18 18 - ### `std.ArrayList` is now unmanaged by default 19 19 - the old `ArrayList` with embedded allocator is now `array_list.AlignedManaged`. 20 20 - the new `std.ArrayList(T)` returns an unmanaged struct that: 21 21 - - doesn't store the allocator internally 22 22 - - requires passing allocator to methods like `appendSlice(alloc, slice)` 23 23 - - initializes with `.{}` or `.empty` instead of `.init(allocator)` 24 24 - - `deinit(alloc)` takes allocator as argument 25 25 - 26 26 - ```zig 27 27 - // old 0.14 style: 28 28 - var list = std.ArrayList(u8).init(allocator); 29 29 - try list.appendSlice("hello"); 30 30 - list.deinit(); 31 31 - 32 32 - // new 0.15 style: 33 33 - var list: std.ArrayList(u8) = .{}; 34 34 - try list.appendSlice(allocator, "hello"); 35 35 - list.deinit(allocator); 36 36 - ``` 37 37 - 38 38 - ### build.zig changes 39 39 - - `root_source_file` → `root_module` with `b.createModule(...)` 40 40 - - `strip` field removed from `ExecutableOptions` 41 41 - - fingerprint field required in `build.zig.zon` 42 42 - 43 43 - ### `std.http.Server` API 44 44 - requires `*std.Io.Reader` and `*std.Io.Writer`, not raw `net.Stream` 45 45 - 46 46 - ## net.Stream → http.Server 47 47 - 48 48 - ```zig 49 49 - var read_buffer: [8192]u8 = undefined; 50 50 - var write_buffer: [8192]u8 = undefined; 51 51 - 52 52 - var reader = conn.stream.reader(&read_buffer); 53 53 - var writer = conn.stream.writer(&write_buffer); 54 54 - 55 55 - // reader has .interface() method that returns *Io.Reader 56 56 - // writer has .interface field that is Io.Writer 57 57 - var server = http.Server.init(reader.interface(), &writer.interface); 58 58 - ``` 59 59 - 60 60 - ### http.Server.Request.respond 61 61 - the `respond` method is on `Request`, not `Server`: 62 62 - ```zig 63 63 - try request.respond(body, .{ 64 64 - .status = .ok, 65 65 - .extra_headers = &.{ 66 66 - .{ .name = "content-type", .value = "application/json" }, 67 67 - }, 68 68 - }); 69 69 - ``` 70 70 - 71 71 - ### `std.Uri.percentDecode` → `std.Uri.percentDecodeInPlace` 72 72 - there's no allocating `percentDecode` anymore. use in-place decoding: 73 73 - ```zig 74 74 - // copy to mutable buffer first, then decode in place 75 75 - const uri_buf = try alloc.dupe(u8, uri_encoded); 76 76 - const uri = std.Uri.percentDecodeInPlace(uri_buf); 77 77 - ``` 78 78 - 79 79 - ### `std.http.Client` for outgoing requests 80 80 - ```zig 81 81 - var client = std.http.Client{ .allocator = allocator }; 82 82 - defer client.deinit(); 83 83 - 84 84 - const uri = std.Uri.parse("https://example.com/api") catch return; 85 85 - 86 86 - // use .headers to control accept-encoding (default is gzip/deflate) 87 87 - var req = client.request(.GET, uri, .{ 88 88 - .headers = .{ .accept_encoding = .{ .override = "identity" } }, 89 89 - }) catch return; 90 90 - defer req.deinit(); 91 91 - 92 92 - req.sendBodiless() catch return; 93 93 - 94 94 - var redirect_buf: [8192]u8 = undefined; 95 95 - var response = req.receiveHead(&redirect_buf) catch return; 96 96 - 97 97 - if (response.head.status != .ok) return; 98 98 - 99 99 - // read response body - use allocRemaining with Limit 100 100 - var reader = response.reader(&.{}); 101 101 - const body = reader.allocRemaining(allocator, std.Io.Limit.limited(65536)) catch return; 102 102 - defer allocator.free(body); 103 103 - ``` 104 104 - 105 105 - ## external libraries 106 106 - 107 107 - ### websocket.zig (karlseguin/websocket.zig) 108 108 - use for websocket client/server. add to `build.zig.zon`: 109 109 - ```zig 110 110 - .dependencies = .{ 111 111 - .websocket = .{ 112 112 - .url = "https://github.com/karlseguin/websocket.zig/archive/refs/heads/master.tar.gz", 113 113 - .hash = "websocket-0.1.0-ZPISdRNzAwAGszh62EpRtoQxu8wb1MSMVI6Ow0o2dmyJ", 114 114 - }, 115 115 - }, 116 116 - ``` 117 117 - 118 118 - client usage: 119 119 - ```zig 120 120 - const websocket = @import("websocket"); 121 121 - 122 122 - var client = try websocket.Client.init(allocator, .{ 123 123 - .host = "example.com", 124 124 - .port = 443, 125 125 - .tls = true, 126 126 - }); 127 127 - defer client.deinit(); 128 128 - 129 129 - // Host header is NOT automatically added - must provide it 130 130 - client.handshake("/path", .{ .headers = "Host: example.com\r\n" }) catch |err| { 131 131 - // handle error 132 132 - }; 133 133 - 134 134 - // handler must have serverMessage(self, data) function 135 135 - var handler = MyHandler{}; 136 136 - try client.readLoop(&handler); 137 137 - ```

+126

docs/architecture.md

··· 1 1 + # pollz architecture 2 2 + 3 3 + ## overview 4 4 + 5 5 + pollz is a polling app built on atproto. users create polls and vote using their bluesky accounts. 6 6 + 7 7 + ``` 8 8 + ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ 9 9 + │ frontend │────▶│ backend │◀────│ tap │ 10 10 + │ (vite/ts) │ │ (zig) │ │ (go) │ 11 11 + │ cloudflare │ │ fly.io │ │ fly.io │ 12 12 + └─────────────┘ └─────────────┘ └─────────────┘ 13 13 + │ │ │ 14 14 + │ ▼ │ 15 15 + │ ┌─────────────┐ │ 16 16 + │ │ sqlite │ │ 17 17 + │ │ (fly vol) │ │ 18 18 + │ └─────────────┘ │ 19 19 + │ │ 20 20 + ▼ ▼ 21 21 + ┌─────────────┐ ┌─────────────┐ 22 22 + │ user PDS │ │ firehose │ 23 23 + │ (bsky.social) │ (relay) │ 24 24 + └─────────────┘ └─────────────┘ 25 25 + ``` 26 26 + 27 27 + ## components 28 28 + 29 29 + ### frontend (src/) 30 30 + - vanilla typescript with vite 31 31 + - oauth via @atcute/oauth-browser-client 32 32 + - writes polls/votes directly to user's PDS 33 33 + - fetches poll data from backend API 34 34 + 35 35 + ### backend (backend/) 36 36 + - zig http server 37 37 + - sqlite for persistence 38 38 + - consumes events from tap via websocket 39 39 + - serves REST API for frontend 40 40 + 41 41 + ### tap (tap/) 42 42 + - bluesky's official atproto sync utility 43 43 + - handles firehose connection, backfill, cursor management 44 44 + - filters for `tech.waow.poll` and `tech.waow.vote` collections 45 45 + - delivers events to backend via websocket 46 46 + 47 47 + ## data flow 48 48 + 49 49 + ### creating a poll 50 50 + 1. user logs in via oauth 51 51 + 2. frontend calls `com.atproto.repo.createRecord` on user's PDS 52 52 + 3. PDS broadcasts to relay/firehose 53 53 + 4. tap receives event, forwards to backend 54 54 + 5. backend inserts poll into sqlite 55 55 + 56 56 + ### voting 57 57 + 1. frontend checks if user has existing vote on this poll 58 58 + 2. if exists: `com.atproto.repo.putRecord` (update) 59 59 + 3. if not: `com.atproto.repo.createRecord` (create) 60 60 + 4. tap receives event, forwards to backend 61 61 + 5. backend upserts vote (one vote per user per poll) 62 62 + 63 63 + ### reading polls 64 64 + 1. frontend fetches `/api/polls` from backend 65 65 + 2. backend queries sqlite, returns polls with vote counts 66 66 + 3. frontend renders poll list 67 67 + 68 68 + ## lexicons 69 69 + 70 70 + ### tech.waow.poll 71 71 + ```json 72 72 + { 73 73 + "$type": "tech.waow.poll", 74 74 + "text": "what's the best language?", 75 75 + "options": ["rust", "zig", "go"], 76 76 + "createdAt": "2024-01-01T00:00:00.000Z" 77 77 + } 78 78 + ``` 79 79 + 80 80 + ### tech.waow.vote 81 81 + ```json 82 82 + { 83 83 + "$type": "tech.waow.vote", 84 84 + "subject": "at://did:plc:.../tech.waow.poll/...", 85 85 + "option": 0, 86 86 + "createdAt": "2024-01-01T00:00:00.000Z" 87 87 + } 88 88 + ``` 89 89 + 90 90 + ## key lessons learned 91 91 + 92 92 + ### vote updates, not delete+create 93 93 + when changing a vote, use `putRecord` to update the existing record rather than deleting and creating. this avoids race conditions where tap receives events out of order (create then delete) causing the vote to disappear. 94 94 + 95 95 + ### tap event ordering 96 96 + tap delivers events in the order they're received from the firehose, but the firehose itself can deliver events out of order. the backend must handle this gracefully: 97 97 + - `insertVote` uses upsert with timestamp comparison 98 98 + - only updates if the incoming vote is newer than existing 99 99 + 100 100 + ### one vote per user per poll 101 101 + enforced at multiple levels: 102 102 + - frontend: checks for existing vote before creating 103 103 + - backend: `UNIQUE(subject, voter)` constraint 104 104 + - backend: upsert logic in `insertVote` 105 105 + 106 106 + ## deployment 107 107 + 108 108 + ### fly.io apps 109 109 + - `pollz-backend` - zig backend with sqlite volume 110 110 + - `pollz-tap` - tap instance with sqlite volume 111 111 + 112 112 + ### cloudflare pages 113 113 + - frontend static files 114 114 + - oauth client metadata at `/oauth-client-metadata.json` 115 115 + 116 116 + ### environment variables 117 117 + 118 118 + backend: 119 119 + - `TAP_HOST` - tap hostname (default: pollz-tap.internal) 120 120 + - `TAP_PORT` - tap port (default: 2480) 121 121 + - `DATA_PATH` - sqlite db path (default: /data/pollz.db) 122 122 + 123 123 + tap: 124 124 + - `TAP_DATABASE_URL` - sqlite path 125 125 + - `TAP_COLLECTION_FILTERS` - collections to track 126 126 + - `TAP_SIGNAL_COLLECTION` - collection for auto-discovery

+122

docs/tap.md

··· 1 1 + # tap integration 2 2 + 3 3 + tap is bluesky's official atproto sync utility. pollz uses it to receive real-time events from the firehose. 4 4 + 5 5 + ## what tap provides 6 6 + 7 7 + - firehose connection with automatic reconnection 8 8 + - signature verification of repo structure and identity 9 9 + - automatic backfill when adding new repos 10 10 + - filtered output by collection 11 11 + - ordering guarantees - backfill completes before live events 12 12 + - cursor management - persists automatically, resumes on restart 13 13 + 14 14 + ## pollz tap configuration 15 15 + 16 16 + ```toml 17 17 + # tap/fly.toml 18 18 + [env] 19 19 + TAP_COLLECTION_FILTERS = "tech.waow.poll,tech.waow.vote" 20 20 + TAP_SIGNAL_COLLECTION = "tech.waow.poll" 21 21 + TAP_DATABASE_URL = "sqlite:///data/tap.db" 22 22 + TAP_DISABLE_ACKS = "true" 23 23 + ``` 24 24 + 25 25 + `TAP_SIGNAL_COLLECTION` makes tap automatically discover and track all repos that have ever created a poll. 26 26 + 27 27 + ## event format 28 28 + 29 29 + tap delivers events via websocket at `/channel`: 30 30 + 31 31 + ```json 32 32 + { 33 33 + "id": 12345, 34 34 + "type": "record", 35 35 + "record": { 36 36 + "live": true, 37 37 + "did": "did:plc:abc123", 38 38 + "collection": "tech.waow.poll", 39 39 + "rkey": "3kb3fge5lm32x", 40 40 + "action": "create", 41 41 + "record": { 42 42 + "text": "what's your favorite color?", 43 43 + "options": ["red", "blue", "green"], 44 44 + "$type": "tech.waow.poll", 45 45 + "createdAt": "2024-10-07T12:00:00.000Z" 46 46 + } 47 47 + } 48 48 + } 49 49 + ``` 50 50 + 51 51 + ### action types 52 52 + - `create` - new record created 53 53 + - `update` - existing record updated (same rkey) 54 54 + - `delete` - record deleted 55 55 + 56 56 + ## backend tap consumer 57 57 + 58 58 + the backend connects to tap via websocket and processes events: 59 59 + 60 60 + ```zig 61 61 + // tap.zig 62 62 + if (mem.eql(u8, action.string, "create") or mem.eql(u8, action.string, "update")) { 63 63 + // process poll or vote 64 64 + } else if (mem.eql(u8, action.string, "delete")) { 65 65 + // delete poll or vote 66 66 + } 67 67 + ``` 68 68 + 69 69 + ## handling out-of-order events 70 70 + 71 71 + tap delivers events in firehose order, but the firehose itself can deliver events out of order. example: 72 72 + 73 73 + 1. user deletes old vote, creates new vote 74 74 + 2. firehose delivers: create (new), delete (old) 75 75 + 3. if backend processes delete after create, the new vote disappears 76 76 + 77 77 + ### solution: use putRecord instead of delete+create 78 78 + 79 79 + when changing a vote, the frontend uses `putRecord` to update the existing record: 80 80 + 81 81 + ```typescript 82 82 + // api.ts 83 83 + if (existingRkey) { 84 84 + // update existing vote - single "update" event 85 85 + await rpc.post("com.atproto.repo.putRecord", { ... }); 86 86 + } else { 87 87 + // create new vote 88 88 + await rpc.post("com.atproto.repo.createRecord", { ... }); 89 89 + } 90 90 + ``` 91 91 + 92 92 + this results in a single "update" event instead of separate "delete" and "create" events, eliminating the race condition. 93 93 + 94 94 + ### backend upsert logic 95 95 + 96 96 + as additional protection, `insertVote` uses upsert with timestamp comparison: 97 97 + 98 98 + ```sql 99 99 + INSERT INTO votes (uri, subject, option, voter, created_at) 100 100 + VALUES (?, ?, ?, ?, ?) 101 101 + ON CONFLICT(subject, voter) DO UPDATE SET 102 102 + uri = excluded.uri, 103 103 + option = excluded.option, 104 104 + created_at = excluded.created_at 105 105 + WHERE excluded.created_at > votes.created_at OR votes.created_at IS NULL 106 106 + ``` 107 107 + 108 108 + this ensures that if out-of-order events do occur, older events don't overwrite newer ones. 109 109 + 110 110 + ## deployment 111 111 + 112 112 + tap runs as a separate fly.io app (`pollz-tap`) and communicates with the backend over fly's internal network: 113 113 + 114 114 + ``` 115 115 + pollz-tap.internal:2480 → pollz-backend 116 116 + ``` 117 117 + 118 118 + ## further reading 119 119 + 120 120 + - [tap README](https://github.com/bluesky-social/indigo/blob/main/cmd/tap/README.md) 121 121 + - [indigo repo](https://github.com/bluesky-social/indigo) 122 122 + - [bailey's tap guide](https://marvins-guide.leaflet.pub/3m7ttuppfzc23)

+126

docs/zig.md

··· 1 1 + # zig 0.15 notes 2 2 + 3 3 + reference for zig 0.15 patterns used in the backend. 4 4 + 5 5 + ## breaking changes from 0.14 6 6 + 7 7 + ### json.stringify → json.fmt 8 8 + ```zig 9 9 + // old: json.stringify(value, .{}, writer); 10 10 + // new: use json.fmt formatter 11 11 + try buffer.print(allocator, "{f}", .{json.fmt(value, .{})}); 12 12 + ``` 13 13 + 14 14 + ### std.ArrayList is unmanaged by default 15 15 + ```zig 16 16 + // old 0.14 style: 17 17 + var list = std.ArrayList(u8).init(allocator); 18 18 + try list.appendSlice("hello"); 19 19 + list.deinit(); 20 20 + 21 21 + // new 0.15 style: 22 22 + var list: std.ArrayList(u8) = .{}; 23 23 + try list.appendSlice(allocator, "hello"); 24 24 + list.deinit(allocator); 25 25 + ``` 26 26 + 27 27 + ### std.time.sleep removed 28 28 + ```zig 29 29 + // use posix.nanosleep instead 30 30 + std.posix.nanosleep(seconds, nanoseconds); 31 31 + ``` 32 32 + 33 33 + ### std.Uri.percentDecode → percentDecodeInPlace 34 34 + ```zig 35 35 + // copy to mutable buffer first, then decode in place 36 36 + const uri_buf = try alloc.dupe(u8, uri_encoded); 37 37 + const uri = std.Uri.percentDecodeInPlace(uri_buf); 38 38 + ``` 39 39 + 40 40 + ## http server patterns 41 41 + 42 42 + ### net.Stream → http.Server 43 43 + ```zig 44 44 + var read_buffer: [8192]u8 = undefined; 45 45 + var write_buffer: [8192]u8 = undefined; 46 46 + 47 47 + var reader = conn.stream.reader(&read_buffer); 48 48 + var writer = conn.stream.writer(&write_buffer); 49 49 + 50 50 + var server = http.Server.init(reader.interface(), &writer.interface); 51 51 + ``` 52 52 + 53 53 + ### responding to requests 54 54 + ```zig 55 55 + try request.respond(body, .{ 56 56 + .status = .ok, 57 57 + .extra_headers = &.{ 58 58 + .{ .name = "content-type", .value = "application/json" }, 59 59 + }, 60 60 + }); 61 61 + ``` 62 62 + 63 63 + ## websocket client (karlseguin/websocket.zig) 64 64 + 65 65 + ```zig 66 66 + const websocket = @import("websocket"); 67 67 + 68 68 + var client = try websocket.Client.init(allocator, .{ 69 69 + .host = "example.com", 70 70 + .port = 443, 71 71 + .tls = true, 72 72 + }); 73 73 + defer client.deinit(); 74 74 + 75 75 + // Host header must be provided manually 76 76 + client.handshake("/path", .{ .headers = "Host: example.com\r\n" }) catch |err| { 77 77 + // handle error 78 78 + }; 79 79 + 80 80 + // handler must have serverMessage(self, data) function 81 81 + var handler = MyHandler{}; 82 82 + try client.readLoop(&handler); 83 83 + ``` 84 84 + 85 85 + ## sqlite patterns (zqlite) 86 86 + 87 87 + ### prepared statements with bind 88 88 + ```zig 89 89 + var stmt = conn.prepare("SELECT * FROM votes WHERE uri = ?") catch return; 90 90 + defer stmt.deinit(); 91 91 + 92 92 + const row = stmt.bind(.{uri}).step() catch return; 93 93 + if (row) |r| { 94 94 + const subject = r[0].?.text; 95 95 + // ... 96 96 + } 97 97 + ``` 98 98 + 99 99 + ### upsert with ON CONFLICT 100 100 + ```zig 101 101 + conn.exec( 102 102 + \\INSERT INTO votes (uri, subject, option, voter, created_at) 103 103 + \\VALUES (?, ?, ?, ?, ?) 104 104 + \\ON CONFLICT(subject, voter) DO UPDATE SET 105 105 + \\ uri = excluded.uri, 106 106 + \\ option = excluded.option, 107 107 + \\ created_at = excluded.created_at 108 108 + \\WHERE excluded.created_at > votes.created_at OR votes.created_at IS NULL 109 109 + , .{ uri, subject, option, voter, created_at }) catch |err| { 110 110 + // handle error 111 111 + }; 112 112 + ``` 113 113 + 114 114 + ## build.zig.zon 115 115 + 116 116 + ```zig 117 117 + .{ 118 118 + .name = .pollz, 119 119 + .version = "0.0.0", 120 120 + .fingerprint = 0x..., // required in 0.15 121 121 + .dependencies = .{ 122 122 + .zqlite = .{ ... }, 123 123 + .websocket = .{ ... }, 124 124 + }, 125 125 + } 126 126 + ```

+6 -1

justfile

··· 1 1 # pollz 2 2 mod backend 3 3 + mod tap 3 4 4 5 # show available commands 5 6 default: ··· 18 19 deploy-backend: 19 20 just backend::deploy 20 21 22 22 + # deploy tap to fly.io 23 23 + deploy-tap: 24 24 + just tap::deploy 25 25 + 21 26 # deploy everything 22 22 - deploy: deploy-backend deploy-frontend 27 27 + deploy: deploy-tap deploy-backend deploy-frontend

+312

src/lib/api.ts

··· 1 1 + import { Client, simpleFetchHandler } from "@atcute/client"; 2 2 + import { 3 3 + CompositeDidDocumentResolver, 4 4 + CompositeHandleResolver, 5 5 + DohJsonHandleResolver, 6 6 + PlcDidDocumentResolver, 7 7 + AtprotoWebDidDocumentResolver, 8 8 + WellKnownHandleResolver, 9 9 + } from "@atcute/identity-resolver"; 10 10 + import { 11 11 + configureOAuth, 12 12 + createAuthorizationUrl, 13 13 + defaultIdentityResolver, 14 14 + finalizeAuthorization, 15 15 + getSession, 16 16 + OAuthUserAgent, 17 17 + deleteStoredSession, 18 18 + } from "@atcute/oauth-browser-client"; 19 19 + 20 20 + export const POLL = "tech.waow.poll"; 21 21 + export const VOTE = "tech.waow.vote"; 22 22 + 23 23 + export const didDocumentResolver = new CompositeDidDocumentResolver({ 24 24 + methods: { 25 25 + plc: new PlcDidDocumentResolver(), 26 26 + web: new AtprotoWebDidDocumentResolver(), 27 27 + }, 28 28 + }); 29 29 + 30 30 + export const handleResolver = new CompositeHandleResolver({ 31 31 + strategy: "dns-first", 32 32 + methods: { 33 33 + dns: new DohJsonHandleResolver({ dohUrl: "https://dns.google/resolve?" }), 34 34 + http: new WellKnownHandleResolver(), 35 35 + }, 36 36 + }); 37 37 + 38 38 + const BASE_URL = import.meta.env.VITE_BASE_URL || "https://pollz.waow.tech"; 39 39 + export const BACKEND_URL = import.meta.env.VITE_BACKEND_URL || "https://pollz-backend.fly.dev"; 40 40 + 41 41 + configureOAuth({ 42 42 + metadata: { 43 43 + client_id: `${BASE_URL}/oauth-client-metadata.json`, 44 44 + redirect_uri: `${BASE_URL}/`, 45 45 + }, 46 46 + identityResolver: defaultIdentityResolver({ 47 47 + handleResolver, 48 48 + didDocumentResolver, 49 49 + }), 50 50 + }); 51 51 + 52 52 + // state 53 53 + export let agent: OAuthUserAgent | null = null; 54 54 + export let currentDid: string | null = null; 55 55 + 56 56 + export const setAgent = (a: OAuthUserAgent | null) => { agent = a; }; 57 57 + export const setCurrentDid = (did: string | null) => { currentDid = did; }; 58 58 + 59 59 + export type Poll = { 60 60 + uri: string; 61 61 + repo: string; 62 62 + rkey: string; 63 63 + text: string; 64 64 + options: string[]; 65 65 + createdAt: string; 66 66 + votes: Map<string, number>; 67 67 + voteCount?: number; 68 68 + }; 69 69 + 70 70 + export const polls = new Map<string, Poll>(); 71 71 + 72 72 + // oauth 73 73 + export const login = async (handle: string): Promise<void> => { 74 74 + const url = await createAuthorizationUrl({ 75 75 + scope: `atproto repo:${POLL} repo:${VOTE}`, 76 76 + target: { type: "account", identifier: handle }, 77 77 + }); 78 78 + location.assign(url); 79 79 + }; 80 80 + 81 81 + export const logout = async (): Promise<void> => { 82 82 + if (currentDid) { 83 83 + await deleteStoredSession(currentDid as `did:${string}:${string}`); 84 84 + localStorage.removeItem("lastDid"); 85 85 + } 86 86 + agent = null; 87 87 + currentDid = null; 88 88 + }; 89 89 + 90 90 + export const handleCallback = async (): Promise<boolean> => { 91 91 + const params = new URLSearchParams(location.hash.slice(1)); 92 92 + if (!params.has("state")) return false; 93 93 + 94 94 + history.replaceState(null, "", "/"); 95 95 + const { session } = await finalizeAuthorization(params); 96 96 + agent = new OAuthUserAgent(session); 97 97 + currentDid = session.info.sub; 98 98 + localStorage.setItem("lastDid", currentDid); 99 99 + return true; 100 100 + }; 101 101 + 102 102 + export const restoreSession = async (): Promise<void> => { 103 103 + const lastDid = localStorage.getItem("lastDid"); 104 104 + if (!lastDid) return; 105 105 + 106 106 + try { 107 107 + const session = await getSession(lastDid as `did:${string}:${string}`); 108 108 + agent = new OAuthUserAgent(session); 109 109 + currentDid = session.info.sub; 110 110 + } catch { 111 111 + localStorage.removeItem("lastDid"); 112 112 + } 113 113 + }; 114 114 + 115 115 + // backend api 116 116 + export const fetchPolls = async (): Promise<void> => { 117 117 + const res = await fetch(`${BACKEND_URL}/api/polls`); 118 118 + if (!res.ok) throw new Error("failed to fetch polls"); 119 119 + 120 120 + const backendPolls = await res.json() as Array<{ 121 121 + uri: string; 122 122 + repo: string; 123 123 + rkey: string; 124 124 + text: string; 125 125 + options: string[]; 126 126 + createdAt: string; 127 127 + voteCount: number; 128 128 + }>; 129 129 + 130 130 + for (const p of backendPolls) { 131 131 + const existing = polls.get(p.uri); 132 132 + if (existing) { 133 133 + existing.voteCount = p.voteCount; 134 134 + } else { 135 135 + polls.set(p.uri, { 136 136 + uri: p.uri, 137 137 + repo: p.repo, 138 138 + rkey: p.rkey, 139 139 + text: p.text, 140 140 + options: p.options, 141 141 + createdAt: p.createdAt, 142 142 + votes: new Map(), 143 143 + voteCount: p.voteCount, 144 144 + }); 145 145 + } 146 146 + } 147 147 + }; 148 148 + 149 149 + export const fetchPoll = async (uri: string) => { 150 150 + const res = await fetch(`${BACKEND_URL}/api/polls/${encodeURIComponent(uri)}`); 151 151 + if (!res.ok) return null; 152 152 + return res.json() as Promise<{ 153 153 + uri: string; 154 154 + repo: string; 155 155 + rkey: string; 156 156 + text: string; 157 157 + options: Array<{ text: string; count: number }>; 158 158 + createdAt: string; 159 159 + }>; 160 160 + }; 161 161 + 162 162 + export const fetchVoters = async (pollUri: string) => { 163 163 + const res = await fetch(`${BACKEND_URL}/api/polls/${encodeURIComponent(pollUri)}/votes`); 164 164 + if (!res.ok) return []; 165 165 + return res.json() as Promise<Array<{ voter: string; option: number; uri: string; createdAt?: string }>>; 166 166 + }; 167 167 + 168 168 + // user votes 169 169 + export const loadUserVotes = async (): Promise<void> => { 170 170 + if (!agent || !currentDid) return; 171 171 + 172 172 + try { 173 173 + const rpc = new Client({ handler: agent }); 174 174 + const res = await rpc.get("com.atproto.repo.listRecords", { 175 175 + params: { repo: currentDid, collection: VOTE, limit: 100 }, 176 176 + }); 177 177 + 178 178 + if (res.ok) { 179 179 + for (const record of res.data.records) { 180 180 + const val = record.value as { subject?: string; option?: number }; 181 181 + if (val.subject && typeof val.option === "number") { 182 182 + const poll = polls.get(val.subject); 183 183 + if (poll) { 184 184 + poll.votes.set(record.uri, val.option); 185 185 + } 186 186 + } 187 187 + } 188 188 + } 189 189 + } catch (e) { 190 190 + console.error("failed to load user votes:", e); 191 191 + } 192 192 + }; 193 193 + 194 194 + // create poll 195 195 + export const createPoll = async (text: string, options: string[]): Promise<string | null> => { 196 196 + if (!agent || !currentDid) return null; 197 197 + 198 198 + const rpc = new Client({ handler: agent }); 199 199 + const res = await rpc.post("com.atproto.repo.createRecord", { 200 200 + input: { 201 201 + repo: currentDid, 202 202 + collection: POLL, 203 203 + record: { $type: POLL, text, options, createdAt: new Date().toISOString() }, 204 204 + }, 205 205 + }); 206 206 + 207 207 + if (!res.ok) throw new Error(res.data.error || "failed to create poll"); 208 208 + 209 209 + const rkey = res.data.uri.split("/").pop()!; 210 210 + polls.set(res.data.uri, { 211 211 + uri: res.data.uri, 212 212 + repo: currentDid, 213 213 + rkey, 214 214 + text, 215 215 + options, 216 216 + createdAt: new Date().toISOString(), 217 217 + votes: new Map(), 218 218 + }); 219 219 + 220 220 + return res.data.uri; 221 221 + }; 222 222 + 223 223 + // vote - creates or updates vote record on user's PDS 224 224 + export const vote = async (pollUri: string, option: number): Promise<void> => { 225 225 + if (!agent || !currentDid) throw new Error("not logged in"); 226 226 + 227 227 + const rpc = new Client({ handler: agent }); 228 228 + 229 229 + // check if we already have a vote on this poll 230 230 + const existing = await rpc.get("com.atproto.repo.listRecords", { 231 231 + params: { repo: currentDid, collection: VOTE, limit: 100 }, 232 232 + }); 233 233 + 234 234 + let existingRkey: string | null = null; 235 235 + if (existing.ok) { 236 236 + for (const record of existing.data.records) { 237 237 + const val = record.value as { subject?: string }; 238 238 + if (val.subject === pollUri) { 239 239 + existingRkey = record.uri.split("/").pop()!; 240 240 + break; 241 241 + } 242 242 + } 243 243 + } 244 244 + 245 245 + if (existingRkey) { 246 246 + // update existing vote 247 247 + const res = await rpc.post("com.atproto.repo.putRecord", { 248 248 + input: { 249 249 + repo: currentDid, 250 250 + collection: VOTE, 251 251 + rkey: existingRkey, 252 252 + record: { $type: VOTE, subject: pollUri, option, createdAt: new Date().toISOString() }, 253 253 + }, 254 254 + }); 255 255 + if (!res.ok) throw new Error(res.data.error || res.data.message || "vote update failed"); 256 256 + } else { 257 257 + // create new vote 258 258 + const res = await rpc.post("com.atproto.repo.createRecord", { 259 259 + input: { 260 260 + repo: currentDid, 261 261 + collection: VOTE, 262 262 + record: { $type: VOTE, subject: pollUri, option, createdAt: new Date().toISOString() }, 263 263 + }, 264 264 + }); 265 265 + if (!res.ok) throw new Error(res.data.error || res.data.message || "vote failed"); 266 266 + } 267 267 + }; 268 268 + 269 269 + // resolve handle from DID 270 270 + const handleCache = new Map<string, string>(); 271 271 + 272 272 + export const resolveHandle = async (did: string): Promise<string> => { 273 273 + if (handleCache.has(did)) return handleCache.get(did)!; 274 274 + try { 275 275 + const res = await fetch(`https://public.api.bsky.app/xrpc/app.bsky.actor.getProfile?actor=${did}`); 276 276 + if (res.ok) { 277 277 + const data = await res.json(); 278 278 + if (data.handle) { 279 279 + handleCache.set(did, data.handle); 280 280 + return data.handle; 281 281 + } 282 282 + } 283 283 + } catch {} 284 284 + return did; 285 285 + }; 286 286 + 287 287 + // fetch poll directly from PDS (fallback) 288 288 + export const fetchPollFromPDS = async (repo: string, rkey: string) => { 289 289 + const didDoc = await didDocumentResolver.resolve(repo as `did:${string}:${string}`); 290 290 + const pds = didDoc?.service?.find((s: { id: string }) => s.id === "#atproto_pds") as { serviceEndpoint?: string } | undefined; 291 291 + const pdsUrl = pds?.serviceEndpoint || "https://bsky.social"; 292 292 + 293 293 + const pdsClient = new Client({ 294 294 + handler: simpleFetchHandler({ service: pdsUrl }), 295 295 + }); 296 296 + 297 297 + const res = await pdsClient.get("com.atproto.repo.getRecord", { 298 298 + params: { repo, collection: POLL, rkey }, 299 299 + }); 300 300 + 301 301 + if (!res.ok) return null; 302 302 + 303 303 + const rec = res.data.value as { text: string; options: string[]; createdAt: string }; 304 304 + return { 305 305 + uri: res.data.uri, 306 306 + repo, 307 307 + rkey, 308 308 + text: rec.text, 309 309 + options: rec.options, 310 310 + createdAt: rec.createdAt, 311 311 + }; 312 312 + };

+16

src/lib/utils.ts

··· 1 1 + // html escaping 2 2 + export const esc = (s: string) => 3 3 + s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"); 4 4 + 5 5 + // relative time 6 6 + export const ago = (date: string) => { 7 7 + const seconds = Math.floor((Date.now() - new Date(date).getTime()) / 1000); 8 8 + if (seconds < 60) return "just now"; 9 9 + const minutes = Math.floor(seconds / 60); 10 10 + if (minutes < 60) return `${minutes}m ago`; 11 11 + const hours = Math.floor(minutes / 60); 12 12 + if (hours < 24) return `${hours}h ago`; 13 13 + const days = Math.floor(hours / 24); 14 14 + if (days < 30) return `${days}d ago`; 15 15 + return new Date(date).toLocaleDateString(); 16 16 + };

+159 -362

src/main.ts

··· 1 1 - import { Client, simpleFetchHandler } from "@atcute/client"; 2 1 import { 3 3 - CompositeDidDocumentResolver, 4 4 - CompositeHandleResolver, 5 5 - DohJsonHandleResolver, 6 6 - PlcDidDocumentResolver, 7 7 - AtprotoWebDidDocumentResolver, 8 8 - WellKnownHandleResolver, 9 9 - } from "@atcute/identity-resolver"; 10 10 - import { 11 11 - configureOAuth, 12 12 - createAuthorizationUrl, 13 13 - defaultIdentityResolver, 14 14 - finalizeAuthorization, 15 15 - getSession, 16 16 - OAuthUserAgent, 17 17 - deleteStoredSession, 18 18 - } from "@atcute/oauth-browser-client"; 19 19 - 20 20 - const POLL = "tech.waow.poll"; 21 21 - const VOTE = "tech.waow.vote"; 22 22 - 23 23 - const didDocumentResolver = new CompositeDidDocumentResolver({ 24 24 - methods: { 25 25 - plc: new PlcDidDocumentResolver(), 26 26 - web: new AtprotoWebDidDocumentResolver(), 27 27 - }, 28 28 - }); 29 29 - 30 30 - const handleResolver = new CompositeHandleResolver({ 31 31 - strategy: "dns-first", 32 32 - methods: { 33 33 - dns: new DohJsonHandleResolver({ dohUrl: "https://dns.google/resolve?" }), 34 34 - http: new WellKnownHandleResolver(), 35 35 - }, 36 36 - }); 37 37 - 38 38 - const BASE_URL = import.meta.env.VITE_BASE_URL || "https://pollz.waow.tech"; 39 39 - 40 40 - configureOAuth({ 41 41 - metadata: { 42 42 - client_id: `${BASE_URL}/oauth-client-metadata.json`, 43 43 - redirect_uri: `${BASE_URL}/`, 44 44 - }, 45 45 - identityResolver: defaultIdentityResolver({ 46 46 - handleResolver, 47 47 - didDocumentResolver, 48 48 - }), 49 49 - }); 2 2 + POLL, 3 3 + VOTE, 4 4 + agent, 5 5 + currentDid, 6 6 + setAgent, 7 7 + setCurrentDid, 8 8 + polls, 9 9 + login, 10 10 + logout, 11 11 + handleCallback, 12 12 + restoreSession, 13 13 + fetchPolls, 14 14 + fetchPoll, 15 15 + fetchVoters, 16 16 + loadUserVotes, 17 17 + createPoll, 18 18 + vote, 19 19 + resolveHandle, 20 20 + fetchPollFromPDS, 21 21 + type Poll, 22 22 + } from "./lib/api"; 23 23 + import { esc, ago } from "./lib/utils"; 50 24 51 25 const app = document.getElementById("app")!; 52 26 const nav = document.getElementById("nav")!; 53 27 const status = document.getElementById("status")!; 54 28 55 55 - let agent: OAuthUserAgent | null = null; 56 56 - let currentDid: string | null = null; 57 57 - let jetstream: WebSocket | null = null; 58 58 - 59 29 const setStatus = (msg: string) => (status.textContent = msg); 60 30 61 61 - type Poll = { 62 62 - uri: string; 63 63 - repo: string; 64 64 - rkey: string; 65 65 - text: string; 66 66 - options: string[]; 67 67 - createdAt: string; 68 68 - votes: Map<string, number>; 69 69 - voteCount?: number; // from backend, used when votes map is empty 70 70 - }; 31 31 + // track if a vote is in progress to prevent double-clicks 32 32 + let votingInProgress = false; 71 33 72 72 - const polls = new Map<string, Poll>(); 34 34 + // jetstream - replay last 24h on connect, then live updates 35 35 + let jetstream: WebSocket | null = null; 73 36 74 74 - // jetstream - replay last 24h on connect, then live updates 75 37 const connectJetstream = () => { 76 38 if (jetstream?.readyState === WebSocket.OPEN) return; 77 39 78 78 - // cursor is microseconds since epoch - go back 24 hours 79 40 const cursor = (Date.now() - 24 * 60 * 60 * 1000) * 1000; 80 41 const url = `wss://jetstream1.us-east.bsky.network/subscribe?wantedCollections=${POLL}&wantedCollections=${VOTE}&cursor=${cursor}`; 81 42 jetstream = new WebSocket(url); ··· 113 74 render(); 114 75 } 115 76 } else if (commit.operation === "delete") { 116 116 - // find and remove vote from its poll 117 77 for (const poll of polls.values()) { 118 78 if (poll.votes.has(uri)) { 119 79 poll.votes.delete(uri); ··· 136 96 const match = path.match(/^\/poll\/([^/]+)\/([^/]+)$/); 137 97 138 98 if (match) { 139 139 - renderPoll(match[1], match[2]); 99 99 + renderPollPage(match[1], match[2]); 140 100 } else if (path === "/new") { 141 101 renderCreate(); 102 102 + } else if (path === "/mine") { 103 103 + renderHome(true); 142 104 } else { 143 143 - renderHome(); 105 105 + renderHome(false); 144 106 } 145 107 }; 146 108 147 109 const renderNav = () => { 148 110 if (agent) { 149 149 - nav.innerHTML = `<a href="/">my polls</a> · <a href="/new">new</a> · <a href="#" id="logout">logout</a>`; 111 111 + nav.innerHTML = `<a href="/">all</a> · <a href="/mine">mine</a> · <a href="/new">new</a> · <a href="#" id="logout">logout</a>`; 150 112 document.getElementById("logout")!.onclick = async (e) => { 151 113 e.preventDefault(); 152 152 - if (currentDid) { 153 153 - await deleteStoredSession(currentDid as `did:${string}:${string}`); 154 154 - localStorage.removeItem("lastDid"); 155 155 - } 156 156 - agent = null; 157 157 - currentDid = null; 114 114 + await logout(); 115 115 + setAgent(null); 116 116 + setCurrentDid(null); 158 117 render(); 159 118 }; 160 119 } else { ··· 164 123 if (!handle) return; 165 124 setStatus("redirecting..."); 166 125 try { 167 167 - const url = await createAuthorizationUrl({ 168 168 - scope: `atproto repo:${POLL} repo:${VOTE}`, 169 169 - target: { type: "account", identifier: handle }, 170 170 - }); 171 171 - location.assign(url); 126 126 + await login(handle); 172 127 } catch (e) { 173 128 setStatus(`error: ${e}`); 174 129 } ··· 176 131 } 177 132 }; 178 133 179 179 - const BACKEND_URL = import.meta.env.VITE_BACKEND_URL || "https://pollz-backend.fly.dev"; 180 180 - 181 181 - // fetch user's existing votes from their PDS 182 182 - const loadUserVotes = async () => { 183 183 - if (!agent || !currentDid) return; 184 184 - 185 185 - try { 186 186 - const rpc = new Client({ handler: agent }); 187 187 - const res = await rpc.get("com.atproto.repo.listRecords", { 188 188 - params: { repo: currentDid, collection: VOTE, limit: 100 }, 189 189 - }); 190 190 - 191 191 - if (res.ok) { 192 192 - for (const record of res.data.records) { 193 193 - const val = record.value as { subject?: string; option?: number }; 194 194 - if (val.subject && typeof val.option === "number") { 195 195 - const poll = polls.get(val.subject); 196 196 - if (poll) { 197 197 - poll.votes.set(record.uri, val.option); 198 198 - } 199 199 - } 200 200 - } 201 201 - } 202 202 - } catch (e) { 203 203 - console.error("failed to load user votes:", e); 204 204 - } 205 205 - }; 206 206 - 207 207 - const renderHome = async () => { 134 134 + const renderHome = async (mineOnly: boolean = false) => { 208 135 app.innerHTML = "<p>loading polls...</p>"; 209 136 210 137 try { 211 211 - // fetch all polls from backend 212 212 - const res = await fetch(`${BACKEND_URL}/api/polls`); 213 213 - if (!res.ok) throw new Error("failed to fetch polls"); 138 138 + await fetchPolls(); 139 139 + await loadUserVotes(); 214 140 215 215 - const backendPolls = await res.json() as Array<{ 216 216 - uri: string; 217 217 - repo: string; 218 218 - rkey: string; 219 219 - text: string; 220 220 - options: string[]; 221 221 - createdAt: string; 222 222 - voteCount: number; 223 223 - }>; 224 224 - 225 225 - // merge into local state 226 226 - for (const p of backendPolls) { 227 227 - const existing = polls.get(p.uri); 228 228 - if (existing) { 229 229 - // update vote count from backend 230 230 - existing.voteCount = p.voteCount; 231 231 - } else { 232 232 - polls.set(p.uri, { 233 233 - uri: p.uri, 234 234 - repo: p.repo, 235 235 - rkey: p.rkey, 236 236 - text: p.text, 237 237 - options: p.options, 238 238 - createdAt: p.createdAt, 239 239 - votes: new Map(), 240 240 - voteCount: p.voteCount, 241 241 - }); 242 242 - } 141 141 + let filteredPolls = Array.from(polls.values()); 142 142 + if (mineOnly && currentDid) { 143 143 + filteredPolls = filteredPolls.filter((p) => p.repo === currentDid); 243 144 } 244 244 - 245 245 - // load user's votes now that polls are in memory 246 246 - await loadUserVotes(); 247 247 - 248 248 - const allPolls = Array.from(polls.values()) 249 249 - .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()); 145 145 + filteredPolls.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()); 250 146 251 147 const newLink = agent ? `<p><a href="/new">+ new poll</a></p>` : `<p>login to create polls</p>`; 148 148 + const heading = mineOnly ? `<p><strong>my polls</strong></p>` : ""; 252 149 253 253 - if (allPolls.length === 0) { 254 254 - app.innerHTML = newLink + "<p>no polls yet</p>"; 150 150 + if (filteredPolls.length === 0) { 151 151 + const msg = mineOnly ? "you haven't created any polls yet" : "no polls yet"; 152 152 + app.innerHTML = newLink + heading + `<p>${msg}</p>`; 255 153 } else { 256 256 - app.innerHTML = newLink + allPolls.map(renderPollCard).join(""); 154 154 + app.innerHTML = newLink + heading + filteredPolls.map(renderPollCard).join(""); 257 155 attachVoteHandlers(); 258 156 } 259 157 } catch (e) { ··· 263 161 }; 264 162 265 163 const renderPollCard = (p: Poll) => { 266 266 - // always use backend voteCount for total 267 164 const total = p.voteCount ?? 0; 165 165 + const disabled = votingInProgress ? " disabled" : ""; 268 166 269 167 const opts = p.options 270 270 - .map((opt, i) => { 271 271 - return ` 272 272 - <div class="option" data-vote="${i}" data-poll="${p.uri}"> 273 273 - <span class="option-text">${esc(opt)}</span> 274 274 - </div> 275 275 - `; 276 276 - }) 168 168 + .map((opt, i) => ` 169 169 + <div class="option${disabled}" data-vote="${i}" data-poll="${p.uri}"> 170 170 + <span class="option-text">${esc(opt)}</span> 171 171 + </div> 172 172 + `) 277 173 .join(""); 278 174 279 175 return ` ··· 285 181 `; 286 182 }; 287 183 288 288 - const esc = (s: string) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"); 289 289 - 290 290 - const ago = (date: string) => { 291 291 - const seconds = Math.floor((Date.now() - new Date(date).getTime()) / 1000); 292 292 - if (seconds < 60) return "just now"; 293 293 - const minutes = Math.floor(seconds / 60); 294 294 - if (minutes < 60) return `${minutes}m ago`; 295 295 - const hours = Math.floor(minutes / 60); 296 296 - if (hours < 24) return `${hours}h ago`; 297 297 - const days = Math.floor(hours / 24); 298 298 - if (days < 30) return `${days}d ago`; 299 299 - return new Date(date).toLocaleDateString(); 300 300 - }; 301 301 - 302 302 - const attachVoteHandlers = () => { 303 303 - app.querySelectorAll("[data-vote]").forEach((el) => { 304 304 - el.addEventListener("click", async (e) => { 305 305 - e.preventDefault(); 306 306 - const t = e.currentTarget as HTMLElement; 307 307 - await vote(t.dataset.poll!, parseInt(t.dataset.vote!, 10)); 308 308 - }); 309 309 - }); 310 310 - 311 311 - // attach hover handlers for vote counts 312 312 - app.querySelectorAll(".vote-count").forEach((el) => { 313 313 - el.addEventListener("mouseenter", showVotersTooltip); 314 314 - el.addEventListener("mouseleave", hideVotersTooltip); 315 315 - }); 316 316 - }; 317 317 - 318 318 - type Vote = { voter: string; option: number; uri: string; createdAt?: string; handle?: string }; 319 319 - const votersCache = new Map<string, Vote[]>(); 320 320 - const handleCache = new Map<string, string>(); 184 184 + // voters tooltip 185 185 + type VoteInfo = { voter: string; option: number; uri: string; createdAt?: string; handle?: string }; 186 186 + const votersCache = new Map<string, VoteInfo[]>(); 321 187 let activeTooltip: HTMLElement | null = null; 322 188 let tooltipTimeout: ReturnType<typeof setTimeout> | null = null; 323 189 324 324 - // resolve DID to handle 325 325 - const resolveHandle = async (did: string): Promise<string> => { 326 326 - if (handleCache.has(did)) return handleCache.get(did)!; 327 327 - try { 328 328 - const res = await fetch(`https://public.api.bsky.app/xrpc/app.bsky.actor.getProfile?actor=${did}`); 329 329 - if (res.ok) { 330 330 - const data = await res.json(); 331 331 - if (data.handle) { 332 332 - handleCache.set(did, data.handle); 333 333 - return data.handle; 334 334 - } 335 335 - } 336 336 - } catch {} 337 337 - return did; // fallback to DID 338 338 - }; 339 339 - 340 190 const showVotersTooltip = async (e: Event) => { 341 191 const el = e.target as HTMLElement; 342 192 const pollUri = el.dataset.pollUri; 343 193 if (!pollUri) return; 344 194 345 345 - // clear any pending hide 346 195 if (tooltipTimeout) { 347 196 clearTimeout(tooltipTimeout); 348 197 tooltipTimeout = null; 349 198 } 350 199 351 351 - // fetch voters if not cached 352 200 if (!votersCache.has(pollUri)) { 353 201 try { 354 354 - const res = await fetch(`${BACKEND_URL}/api/polls/${encodeURIComponent(pollUri)}/votes`); 355 355 - if (res.ok) { 356 356 - votersCache.set(pollUri, await res.json()); 357 357 - } 202 202 + const voters = await fetchVoters(pollUri); 203 203 + votersCache.set(pollUri, voters); 358 204 } catch (err) { 359 205 console.error("failed to fetch voters:", err); 360 206 return; ··· 364 210 const voters = votersCache.get(pollUri); 365 211 if (!voters || voters.length === 0) return; 366 212 367 367 - // resolve handles for all voters 368 213 await Promise.all(voters.map(async (v) => { 369 214 if (!v.handle) { 370 215 v.handle = await resolveHandle(v.voter); 371 216 } 372 217 })); 373 218 374 374 - // get poll options for display 375 219 const poll = polls.get(pollUri); 376 220 const options = poll?.options || []; 377 221 378 378 - // remove existing tooltip if any 379 222 if (activeTooltip) activeTooltip.remove(); 380 223 381 381 - // create tooltip 382 224 const tooltip = document.createElement("div"); 383 225 tooltip.className = "voters-tooltip"; 384 226 tooltip.innerHTML = voters ··· 391 233 }) 392 234 .join(""); 393 235 394 394 - // keep tooltip visible when hovering over it 395 236 tooltip.addEventListener("mouseenter", () => { 396 237 if (tooltipTimeout) { 397 238 clearTimeout(tooltipTimeout); ··· 400 241 }); 401 242 tooltip.addEventListener("mouseleave", hideVotersTooltip); 402 243 403 403 - // position tooltip 404 244 const rect = el.getBoundingClientRect(); 405 245 tooltip.style.position = "fixed"; 406 246 tooltip.style.left = `${rect.left}px`; ··· 411 251 }; 412 252 413 253 const hideVotersTooltip = () => { 414 414 - // delay hiding so user can move to tooltip 415 254 tooltipTimeout = setTimeout(() => { 416 255 if (activeTooltip) { 417 256 activeTooltip.remove(); ··· 420 259 }, 150); 421 260 }; 422 261 262 262 + const attachVoteHandlers = () => { 263 263 + app.querySelectorAll("[data-vote]").forEach((el) => { 264 264 + el.addEventListener("click", async (e) => { 265 265 + e.preventDefault(); 266 266 + const t = e.currentTarget as HTMLElement; 267 267 + await handleVote(t.dataset.poll!, parseInt(t.dataset.vote!, 10)); 268 268 + }); 269 269 + }); 270 270 + 271 271 + app.querySelectorAll(".vote-count").forEach((el) => { 272 272 + el.addEventListener("mouseenter", showVotersTooltip); 273 273 + el.addEventListener("mouseleave", hideVotersTooltip); 274 274 + }); 275 275 + }; 276 276 + 277 277 + const handleVote = async (pollUri: string, option: number) => { 278 278 + console.log("[handleVote] called", { pollUri, option, votingInProgress, agent: !!agent, currentDid }); 279 279 + 280 280 + if (!agent || !currentDid) { 281 281 + setStatus("login to vote"); 282 282 + console.log("[handleVote] not logged in, returning"); 283 283 + return; 284 284 + } 285 285 + 286 286 + if (votingInProgress) { 287 287 + console.log("[handleVote] vote already in progress, returning"); 288 288 + return; 289 289 + } 290 290 + 291 291 + votingInProgress = true; 292 292 + setStatus("voting..."); 293 293 + console.log("[handleVote] set votingInProgress=true, calling vote()"); 294 294 + 295 295 + // disable all vote options visually 296 296 + app.querySelectorAll("[data-vote]").forEach((el) => { 297 297 + el.classList.add("disabled"); 298 298 + }); 299 299 + 300 300 + try { 301 301 + await vote(pollUri, option); 302 302 + console.log("[handleVote] vote() completed successfully"); 303 303 + setStatus("confirming..."); 304 304 + 305 305 + // poll backend until vote is confirmed (tap needs time to process) 306 306 + const maxWait = 10000; 307 307 + const pollInterval = 500; 308 308 + const start = Date.now(); 309 309 + 310 310 + while (Date.now() - start < maxWait) { 311 311 + const voters = await fetchVoters(pollUri); 312 312 + const myVote = voters.find(v => v.voter === currentDid); 313 313 + console.log("[handleVote] polling backend", { myVote, elapsed: Date.now() - start }); 314 314 + if (myVote && myVote.option === option) { 315 315 + console.log("[handleVote] vote confirmed in backend"); 316 316 + break; 317 317 + } 318 318 + await new Promise(r => setTimeout(r, pollInterval)); 319 319 + } 320 320 + 321 321 + setStatus(""); 322 322 + console.log("[handleVote] calling render()"); 323 323 + render(); 324 324 + } catch (e) { 325 325 + console.error("[handleVote] error:", e); 326 326 + setStatus(`error: ${e}`); 327 327 + setTimeout(() => { 328 328 + setStatus(""); 329 329 + render(); 330 330 + }, 2000); 331 331 + } finally { 332 332 + votingInProgress = false; 333 333 + console.log("[handleVote] finally, votingInProgress=false"); 334 334 + } 335 335 + }; 336 336 + 423 337 const attachShareHandler = () => { 424 338 const btn = app.querySelector(".share-btn") as HTMLButtonElement; 425 339 if (!btn) return; ··· 435 349 btn.classList.remove("copied"); 436 350 }, 2000); 437 351 } catch { 438 438 - // fallback for older browsers 439 352 const input = document.createElement("input"); 440 353 input.value = url; 441 354 document.body.appendChild(input); ··· 452 365 }); 453 366 }; 454 367 455 455 - const renderPoll = async (repo: string, rkey: string) => { 368 368 + const renderPollPage = async (repo: string, rkey: string) => { 456 369 const uri = `at://${repo}/${POLL}/${rkey}`; 457 370 app.innerHTML = "<p>loading...</p>"; 458 371 459 372 try { 460 460 - // fetch poll with vote counts from backend 461 461 - const res = await fetch(`${BACKEND_URL}/api/polls/${encodeURIComponent(uri)}`); 373 373 + const data = await fetchPoll(uri); 462 374 463 463 - if (res.ok) { 464 464 - const data = await res.json() as { 465 465 - uri: string; 466 466 - repo: string; 467 467 - rkey: string; 468 468 - text: string; 469 469 - options: Array<{ text: string; count: number }>; 470 470 - createdAt: string; 471 471 - }; 472 472 - 473 473 - // render poll with vote counts from backend 375 375 + if (data) { 474 376 const total = data.options.reduce((sum, o) => sum + o.count, 0); 377 377 + const disabled = votingInProgress ? " disabled" : ""; 378 378 + 475 379 const opts = data.options 476 380 .map((opt, i) => { 477 381 const pct = total > 0 ? Math.round((opt.count / total) * 100) : 0; 478 382 return ` 479 479 - <div class="option" data-vote="${i}" data-poll="${uri}"> 480 480 - <div class="option-bar" style="width: ${pct}%"></div> 481 481 - <span class="option-text">${esc(opt.text)}</span> 482 482 - <span class="option-count">${opt.count} (${pct}%)</span> 483 483 - </div>`; 383 383 + <div class="option${disabled}" data-vote="${i}" data-poll="${uri}"> 384 384 + <div class="option-bar" style="width: ${pct}%"></div> 385 385 + <span class="option-text">${esc(opt.text)}</span> 386 386 + <span class="option-count">${opt.count} (${pct}%)</span> 387 387 + </div>`; 484 388 }) 485 389 .join(""); 486 390 ··· 501 405 } 502 406 503 407 // fallback to direct PDS fetch if backend doesn't have it 504 504 - const didDoc = await didDocumentResolver.resolve(repo as `did:${string}:${string}`); 505 505 - const pds = didDoc?.service?.find((s: { id: string }) => s.id === "#atproto_pds") as { serviceEndpoint?: string } | undefined; 506 506 - const pdsUrl = pds?.serviceEndpoint || "https://bsky.social"; 507 507 - 508 508 - const pdsClient = new Client({ 509 509 - handler: simpleFetchHandler({ service: pdsUrl }), 510 510 - }); 511 511 - 512 512 - const pdsRes = await pdsClient.get("com.atproto.repo.getRecord", { 513 513 - params: { repo, collection: POLL, rkey }, 514 514 - }); 515 515 - if (!pdsRes.ok) { 408 408 + const pdsData = await fetchPollFromPDS(repo, rkey); 409 409 + if (!pdsData) { 516 410 app.innerHTML = "<p>not found</p>"; 517 411 return; 518 412 } 519 519 - const rec = pdsRes.data.value as { text: string; options: string[]; createdAt: string }; 520 520 - const poll = { uri: pdsRes.data.uri, repo, rkey, text: rec.text, options: rec.options, createdAt: rec.createdAt, votes: new Map() }; 413 413 + 414 414 + const poll: Poll = { ...pdsData, votes: new Map() }; 521 415 polls.set(uri, poll); 522 416 523 417 app.innerHTML = `<p><a href="/">&larr; back</a></p>${renderPollCard(poll)}`; ··· 540 434 <button id="create">create</button> 541 435 </div> 542 436 `; 543 543 - document.getElementById("create")!.onclick = create; 437 437 + document.getElementById("create")!.onclick = handleCreate; 544 438 }; 545 439 546 546 - const create = async () => { 440 440 + const handleCreate = async () => { 547 441 if (!agent || !currentDid) return; 548 442 549 443 const text = (document.getElementById("question") as HTMLInputElement).value.trim(); ··· 558 452 } 559 453 560 454 setStatus("creating..."); 561 561 - const rpc = new Client({ handler: agent }); 562 562 - const res = await rpc.post("com.atproto.repo.createRecord", { 563 563 - input: { 564 564 - repo: currentDid, 565 565 - collection: POLL, 566 566 - record: { $type: POLL, text, options, createdAt: new Date().toISOString() }, 567 567 - }, 568 568 - }); 569 569 - 570 570 - if (!res.ok) { 571 571 - setStatus(`error: ${res.data.error}`); 572 572 - return; 573 573 - } 574 574 - 575 575 - const rkey = res.data.uri.split("/").pop()!; 576 576 - polls.set(res.data.uri, { 577 577 - uri: res.data.uri, 578 578 - repo: currentDid, 579 579 - rkey, 580 580 - text, 581 581 - options, 582 582 - createdAt: new Date().toISOString(), 583 583 - votes: new Map(), 584 584 - }); 585 585 - 586 586 - setStatus(""); 587 587 - history.pushState(null, "", "/"); 588 588 - render(); 589 589 - }; 590 590 - 591 591 - const vote = async (pollUri: string, option: number) => { 592 592 - if (!agent || !currentDid) { 593 593 - setStatus("login to vote"); 594 594 - return; 595 595 - } 596 596 - 597 597 - setStatus("voting..."); 598 598 - const rpc = new Client({ handler: agent }); 599 599 - 600 600 - // first, find and delete any existing votes on this poll 601 455 try { 602 602 - const existing = await rpc.get("com.atproto.repo.listRecords", { 603 603 - params: { repo: currentDid, collection: VOTE, limit: 100 }, 604 604 - }); 605 605 - if (existing.ok) { 606 606 - for (const record of existing.data.records) { 607 607 - const val = record.value as { subject?: string }; 608 608 - if (val.subject === pollUri) { 609 609 - const rkey = record.uri.split("/").pop()!; 610 610 - await rpc.post("com.atproto.repo.deleteRecord", { 611 611 - input: { repo: currentDid, collection: VOTE, rkey }, 612 612 - }); 613 613 - } 614 614 - } 615 615 - } 456 456 + await createPoll(text, options); 457 457 + setStatus(""); 458 458 + history.pushState(null, "", "/"); 459 459 + render(); 616 460 } catch (e) { 617 617 - console.error("error checking existing votes:", e); 461 461 + setStatus(`error: ${e}`); 618 462 } 619 619 - 620 620 - const res = await rpc.post("com.atproto.repo.createRecord", { 621 621 - input: { 622 622 - repo: currentDid, 623 623 - collection: VOTE, 624 624 - record: { $type: VOTE, subject: pollUri, option, createdAt: new Date().toISOString() }, 625 625 - }, 626 626 - }); 627 627 - 628 628 - if (!res.ok) { 629 629 - console.error("vote error:", res.status, res.data); 630 630 - setStatus(`error: ${res.data.error || res.data.message || "unknown"}`); 631 631 - setTimeout(() => setStatus(""), 3000); 632 632 - return; 633 633 - } 634 634 - 635 635 - // update local state 636 636 - const poll = polls.get(pollUri); 637 637 - if (poll) { 638 638 - // remove any existing vote from this user 639 639 - for (const [uri, _] of poll.votes) { 640 640 - if (uri.startsWith(`at://${currentDid}/${VOTE}/`)) { 641 641 - poll.votes.delete(uri); 642 642 - } 643 643 - } 644 644 - poll.votes.set(res.data.uri, option); 645 645 - } 646 646 - 647 647 - setStatus(""); 648 648 - render(); 649 463 }; 650 464 651 651 - // oauth 652 652 - const handleCallback = async () => { 465 465 + // oauth callback handler 466 466 + const handleOAuthCallback = async () => { 653 467 const params = new URLSearchParams(location.hash.slice(1)); 654 468 if (!params.has("state")) return false; 655 469 656 656 - history.replaceState(null, "", "/"); 657 470 setStatus("logging in..."); 658 471 659 472 try { 660 660 - const { session } = await finalizeAuthorization(params); 661 661 - agent = new OAuthUserAgent(session); 662 662 - currentDid = session.info.sub; 663 663 - localStorage.setItem("lastDid", currentDid); 473 473 + const success = await handleCallback(); 664 474 setStatus(""); 665 665 - return true; 475 475 + return success; 666 476 } catch (e) { 667 477 setStatus(`login failed: ${e}`); 668 478 return false; 669 479 } 670 480 }; 671 481 672 672 - const restoreSession = async () => { 673 673 - const lastDid = localStorage.getItem("lastDid"); 674 674 - if (!lastDid) return; 675 675 - 676 676 - try { 677 677 - const session = await getSession(lastDid as `did:${string}:${string}`); 678 678 - agent = new OAuthUserAgent(session); 679 679 - currentDid = session.info.sub; 680 680 - } catch { 681 681 - localStorage.removeItem("lastDid"); 682 682 - } 683 683 - }; 684 684 - 685 482 // routing 686 483 window.addEventListener("popstate", render); 687 484 document.addEventListener("click", (e) => { ··· 695 492 696 493 // init 697 494 (async () => { 698 698 - await handleCallback(); 495 495 + await handleOAuthCallback(); 699 496 await restoreSession(); 700 497 connectJetstream(); 701 498 render();

+30

tap/fly.toml

··· 1 1 + app = 'pollz-tap' 2 2 + primary_region = 'iad' 3 3 + 4 4 + [build] 5 5 + image = 'ghcr.io/bluesky-social/indigo/tap:latest' 6 6 + 7 7 + [env] 8 8 + TAP_DATABASE_URL = 'sqlite:///data/tap.db' 9 9 + TAP_BIND = ':2480' 10 10 + TAP_SIGNAL_COLLECTION = 'tech.waow.poll' 11 11 + TAP_COLLECTION_FILTERS = 'tech.waow.poll,tech.waow.vote' 12 12 + TAP_DISABLE_ACKS = 'true' 13 13 + TAP_LOG_LEVEL = 'info' 14 14 + TAP_CURSOR_SAVE_INTERVAL = '5s' 15 15 + 16 16 + [http_service] 17 17 + internal_port = 2480 18 18 + force_https = false 19 19 + auto_stop_machines = 'off' 20 20 + auto_start_machines = true 21 21 + min_machines_running = 1 22 22 + 23 23 + [[vm]] 24 24 + memory = '512mb' 25 25 + cpu_kind = 'shared' 26 26 + cpus = 1 27 27 + 28 28 + [mounts] 29 29 + source = 'tap_data' 30 30 + destination = '/data'

+17

tap/justfile

··· 1 1 + # tap instance for pollz 2 2 + 3 3 + # deploy tap to fly.io 4 4 + deploy: 5 5 + fly deploy --app pollz-tap 6 6 + 7 7 + # check tap status 8 8 + status: 9 9 + fly status --app pollz-tap 10 10 + 11 11 + # view tap logs 12 12 + logs: 13 13 + fly logs --app pollz-tap 14 14 + 15 15 + # ssh into tap instance 16 16 + ssh: 17 17 + fly ssh console --app pollz-tap