+11 -7

AGENTS.md

Reviewed

··· 19 19 - `src/App.tsx`: provider wiring only. Keep this small. It should compose app-wide providers and render `AppRoutes`. 20 20 - `src/routes.tsx`: the declarative route table. Repo routes are nested under `/:owner/:repo` and use `RepoLayout`. 21 21 - `src/layout.tsx`: global shell and topbar. Preserve the `.untangled-shell` wrapper so app pages keep the intended width and padding. There is intentionally no footer. 22 22 - - `src/views/home.tsx`: home page and repository jump/recent/own-repo UI. 23 23 - - `src/views/oauth-callback.tsx`: OAuth callback completion page. 24 24 - - `src/views/not-found.tsx`: not-found page. 22 22 + - `src/pages/home.tsx`: home page and repository jump/recent/own-repo UI. 23 23 + - `src/pages/oauth-callback.tsx`: OAuth callback completion page. 24 24 + - `src/pages/not-found.tsx`: not-found page. 25 25 + - `src/pages/search.tsx`: global search page. 25 26 - `src/pages/repo.tsx`: barrel exports for repo routes only. 26 27 - `src/pages/repo/shared.tsx`: repo layout/context, shared repo frame/header/tabs, repo query keys, and `useRepoQuery`. 27 28 - `src/pages/repo/code.tsx`: repo overview/tree page and blob/file viewer. ··· 33 34 - `src/components/common.tsx`: generic UI primitives such as `Avatar`, `LoadingState`, `StateBadge`, and form/button/card style helpers. 34 35 - `src/components/repo.tsx`: repo presentation components such as tabs, file rows, README/comment cards, `CodeView`, `DiffView`, branch pills, and repo skeletons. 35 36 - `src/lib/api.ts`: compatibility facade that re-exports domain APIs. Do not add implementation here. 36 36 - - `src/lib/api/core.ts`: current low-level API implementation and shared private helpers. 37 37 - `src/lib/api/constants.ts`: public service URLs and OAuth scope exports. 38 38 + - `src/lib/api/appview.ts`: appview JSON transport, fallback, and appview response types. 39 39 + - `src/lib/api/backlinks.ts`: Constellation backlink traversal and backlink pagination helpers. 40 40 + - `src/lib/api/client.ts`: shared ATProto RPC client creation and service URL normalization. 41 41 + - `src/lib/api/hydration.ts`: record hydration from appview/PDS records into resolved authors. 38 42 - `src/lib/api/identity.ts`: auth RPC, identity resolver, actor resolution, avatar resolution. 39 43 - `src/lib/api/repos.ts`: repo records, repo metadata, tree/blob/branch/tag/log/language APIs, compare APIs, and related response types. 40 44 - `src/lib/api/issues.ts`: issue list/detail/create/comment/state APIs and issue types. ··· 65 69 import { createIssue } from '../../lib/api/issues'; 66 70 ``` 67 71 68 68 - The facade `src/lib/api.ts` remains for compatibility with existing imports, but new implementation should go into the relevant domain module or, if it truly must share private internals, into `src/lib/api/core.ts` and be re-exported through the domain module. 72 72 + The facade `src/lib/api.ts` remains for compatibility with existing imports, but new implementation should go into the relevant domain module. Shared internals should stay in a narrowly scoped helper such as `src/lib/api/appview.ts`, `src/lib/api/backlinks.ts`, `src/lib/api/client.ts`, `src/lib/api/hydration.ts`, `src/lib/api/records.ts`, or `src/lib/api/stateful.ts`. 69 73 70 74 Guidelines: 71 75 ··· 145 149 - Keep `src/App.tsx` small. 146 150 - Keep route declarations in `src/routes.tsx`. 147 151 - Keep global shell/topbar work in `src/layout.tsx`. 148 148 - - Keep top-level non-repo pages in `src/views`. 152 152 + - Keep top-level non-repo pages in `src/pages`. 149 153 - Keep repo-route behavior in `src/pages/repo/*.tsx`. 150 154 - Keep repo-route pure helpers in nearby `src/pages/repo/*-helpers.ts` files. 151 155 - Keep generic display components in `src/components/common.tsx`. ··· 165 169 - `src/pages/repo/code.tsx`: largest repo route; split further if code/blob logic grows. 166 170 - `src/pages/repo/pulls.tsx`: pull routes and patch/diff UI. 167 171 - `src/pages/repo/issues.tsx`: issue routes. 168 168 - - `src/lib/api/core.ts`: compatibility implementation backend; prefer new domain modules for new API surfaces. 172 172 + - `src/lib/api/*`: domain modules own their public implementations; shared plumbing is split across focused helper modules. 169 173 170 174 171 175 <!-- headroom:rtk-instructions -->

+1 -1

src/components/common.tsx

Reviewed

··· 13 13 import { A } from '@solidjs/router'; 14 14 import { Match, Show, Switch, createEffect, createMemo, createSignal, type Component } from 'solid-js'; 15 15 import { createQuery } from '@tanstack/solid-query'; 16 16 - import { resolveAvatarUrl } from '../lib/api'; 16 16 + import { resolveAvatarUrl } from '../lib/api/identity'; 17 17 18 18 export const ToggleButton: Component<{ 19 19 active: boolean;

+1 -1

src/components/repo.tsx

Reviewed

··· 20 20 import { marked } from 'marked'; 21 21 import { A } from '@solidjs/router'; 22 22 import { For, Show, createMemo, createSignal, type Component, type JSX } from 'solid-js'; 23 23 - import type { TreeEntry } from '../lib/api'; 23 23 + import type { TreeEntry } from '../lib/api/repos'; 24 24 import { formatRelativeTime } from '../lib/repo-utils'; 25 25 import { Avatar, SkeletonBlock, cardStyles } from './common'; 26 26

+1 -1

src/layout.tsx

Reviewed

··· 5 5 import { For, Show, createEffect, createSignal, onCleanup, onMount, type Component, type JSX } from 'solid-js'; 6 6 7 7 import { Avatar, buttonStyles, inputStyles } from './components/common'; 8 8 - import { clearApiCaches, resolveActor } from './lib/api'; 8 8 + import { clearApiCaches, resolveActor } from './lib/api/identity'; 9 9 import { useAuth } from './lib/auth'; 10 10 import { useLiveEvents, type LiveEvent } from './lib/live-events'; 11 11 import { formatRelativeTime } from './lib/repo-utils';

+67

src/lib/api/appview-cache.ts

Reviewed

··· 1 1 + interface AppviewCursorCheckpoint { 2 2 + matchingSeen: number; 3 3 + scannedSeen: number; 4 4 + cursor?: string; 5 5 + exhausted: boolean; 6 6 + } 7 7 + 8 8 + const APPVIEW_CURSOR_CACHE_LIMIT = 64; 9 9 + const appviewPageCursorCache = new Map<string, Map<number, AppviewCursorCheckpoint>>(); 10 10 + 11 11 + export const clearAppviewStatefulCursorCache = () => { 12 12 + appviewPageCursorCache.clear(); 13 13 + }; 14 14 + 15 15 + export const rememberAppviewCursorCheckpoint = (cacheKey: string, checkpoint: AppviewCursorCheckpoint) => { 16 16 + let checkpoints = appviewPageCursorCache.get(cacheKey); 17 17 + if (!checkpoints) { 18 18 + checkpoints = new Map(); 19 19 + appviewPageCursorCache.set(cacheKey, checkpoints); 20 20 + } 21 21 + 22 22 + const existing = checkpoints.get(checkpoint.matchingSeen); 23 23 + if (!existing || checkpoint.scannedSeen >= existing.scannedSeen) { 24 24 + checkpoints.set(checkpoint.matchingSeen, checkpoint); 25 25 + } 26 26 + 27 27 + while (checkpoints.size > APPVIEW_CURSOR_CACHE_LIMIT) { 28 28 + const first = checkpoints.keys().next().value; 29 29 + if (first === undefined) break; 30 30 + checkpoints.delete(first); 31 31 + } 32 32 + }; 33 33 + 34 34 + export const getNearestAppviewCursorCheckpoint = ( 35 35 + cacheKey: string, 36 36 + offset: number, 37 37 + ): AppviewCursorCheckpoint => { 38 38 + const checkpoints = appviewPageCursorCache.get(cacheKey); 39 39 + const start: AppviewCursorCheckpoint = { 40 40 + matchingSeen: 0, 41 41 + scannedSeen: 0, 42 42 + exhausted: false, 43 43 + }; 44 44 + 45 45 + if (!checkpoints) { 46 46 + return start; 47 47 + } 48 48 + 49 49 + let nearest = start; 50 50 + for (const checkpoint of checkpoints.values()) { 51 51 + if (checkpoint.matchingSeen > offset) { 52 52 + continue; 53 53 + } 54 54 + 55 55 + if ( 56 56 + checkpoint.matchingSeen > nearest.matchingSeen || 57 57 + ( 58 58 + checkpoint.matchingSeen === nearest.matchingSeen && 59 59 + checkpoint.scannedSeen > nearest.scannedSeen 60 60 + ) 61 61 + ) { 62 62 + nearest = checkpoint; 63 63 + } 64 64 + } 65 65 + 66 66 + return nearest; 67 67 + };

+232

src/lib/api/appview.ts

Reviewed

··· 1 1 + import type { ResourceUri } from '@atcute/lexicons/syntax'; 2 2 + 3 3 + import { normalizeServiceUrl } from './client'; 4 4 + import { 5 5 + getRouteKnotRequestsThroughAppview, 6 6 + getTangledAppviewService, 7 7 + } from '../settings'; 8 8 + 9 9 + export interface AppviewRecordView<T> { 10 10 + uri: ResourceUri; 11 11 + cid?: string | null; 12 12 + value: T; 13 13 + } 14 14 + 15 15 + export interface AppviewListResponse<T> { 16 16 + items: Array<AppviewRecordView<T>>; 17 17 + cursor?: string | null; 18 18 + } 19 19 + 20 20 + export interface AppviewBulkResponse<T> { 21 21 + items: Array<AppviewRecordView<T>>; 22 22 + } 23 23 + 24 24 + export interface AppviewStatefulRecordView<T> extends AppviewRecordView<T> { 25 25 + state?: string; 26 26 + stateUpdatedAt?: string; 27 27 + commentCount?: number; 28 28 + } 29 29 + 30 30 + export interface AppviewStatefulListResponse<T> { 31 31 + items: Array<AppviewStatefulRecordView<T>>; 32 32 + cursor?: string | null; 33 33 + } 34 34 + 35 35 + export interface AppviewSearchHit<T> extends AppviewRecordView<T> { 36 36 + nsid: string; 37 37 + score: number; 38 38 + } 39 39 + 40 40 + export interface AppviewSearchResponse<T> { 41 41 + hits: Array<AppviewSearchHit<T>>; 42 42 + cursor?: string | null; 43 43 + } 44 44 + 45 45 + interface AppviewCountResponse { 46 46 + count: number; 47 47 + distinctAuthors?: number; 48 48 + distinct_authors?: number; 49 49 + } 50 50 + 51 51 + export type AppviewParamValue = string | number | boolean | null | undefined; 52 52 + 53 53 + export class AppviewResponseError extends Error { 54 54 + readonly status: number; 55 55 + 56 56 + constructor(status: number, message: string) { 57 57 + super(message); 58 58 + this.name = 'AppviewResponseError'; 59 59 + this.status = status; 60 60 + } 61 61 + } 62 62 + 63 63 + export class AppviewUnavailableError extends Error { 64 64 + readonly cause: unknown; 65 65 + 66 66 + constructor(cause: unknown) { 67 67 + super(cause instanceof Error ? cause.message : 'Appview unavailable'); 68 68 + this.name = 'AppviewUnavailableError'; 69 69 + this.cause = cause; 70 70 + } 71 71 + } 72 72 + 73 73 + export const appviewJson = async <T>( 74 74 + nsid: string, 75 75 + params: Record<string, AppviewParamValue> = {}, 76 76 + signal?: AbortSignal, 77 77 + ): Promise<T> => { 78 78 + const url = new URL(`/xrpc/${nsid}`, normalizeServiceUrl(getTangledAppviewService())); 79 79 + for (const [key, value] of Object.entries(params)) { 80 80 + if (value !== undefined && value !== null) { 81 81 + url.searchParams.set(key, String(value)); 82 82 + } 83 83 + } 84 84 + 85 85 + let response: Response; 86 86 + try { 87 87 + response = await fetch(url, { 88 88 + headers: { 89 89 + accept: 'application/json', 90 90 + }, 91 91 + signal, 92 92 + }); 93 93 + } catch (cause) { 94 94 + throw new AppviewUnavailableError(cause); 95 95 + } 96 96 + 97 97 + if (!response.ok) { 98 98 + let message = `${response.status} ${response.statusText}`.trim(); 99 99 + try { 100 100 + const body = (await response.json()) as { message?: unknown; error?: unknown }; 101 101 + const bodyMessage = typeof body.message === 'string' ? body.message : body.error; 102 102 + if (typeof bodyMessage === 'string') { 103 103 + message = bodyMessage; 104 104 + } 105 105 + } catch { 106 106 + // Keep the HTTP status message when the appview does not return JSON. 107 107 + } 108 108 + 109 109 + throw new AppviewResponseError(response.status, `Appview ${nsid} failed (${response.status}): ${message}`); 110 110 + } 111 111 + 112 112 + return (await response.json()) as T; 113 113 + }; 114 114 + 115 115 + export const appviewJsonUrl = async <T>(url: URL, signal?: AbortSignal): Promise<T> => { 116 116 + let response: Response; 117 117 + try { 118 118 + response = await fetch(url, { 119 119 + headers: { 120 120 + accept: 'application/json', 121 121 + }, 122 122 + signal, 123 123 + }); 124 124 + } catch (cause) { 125 125 + throw new AppviewUnavailableError(cause); 126 126 + } 127 127 + 128 128 + if (!response.ok) { 129 129 + let message = `${response.status} ${response.statusText}`.trim(); 130 130 + try { 131 131 + const body = (await response.json()) as { message?: unknown; error?: unknown }; 132 132 + const bodyMessage = typeof body.message === 'string' ? body.message : body.error; 133 133 + if (typeof bodyMessage === 'string') { 134 134 + message = bodyMessage; 135 135 + } 136 136 + } catch { 137 137 + // Keep the HTTP status message when the appview does not return JSON. 138 138 + } 139 139 + 140 140 + throw new AppviewResponseError(response.status, `Appview ${url.pathname.slice('/xrpc/'.length)} failed (${response.status}): ${message}`); 141 141 + } 142 142 + 143 143 + return (await response.json()) as T; 144 144 + }; 145 145 + 146 146 + export const appviewFallback = async <T>(primary: () => Promise<T>, fallback: () => Promise<T>): Promise<T> => { 147 147 + try { 148 148 + return await primary(); 149 149 + } catch (cause) { 150 150 + if (!(cause instanceof AppviewUnavailableError)) { 151 151 + throw cause; 152 152 + } 153 153 + 154 154 + return fallback(); 155 155 + } 156 156 + }; 157 157 + 158 158 + export const listAllAppviewRecords = async <T>( 159 159 + nsid: string, 160 160 + subject: string, 161 161 + extraParams: Record<string, AppviewParamValue> = {}, 162 162 + ): Promise<Array<AppviewRecordView<T>>> => { 163 163 + const records: Array<AppviewRecordView<T>> = []; 164 164 + let cursor: string | undefined; 165 165 + 166 166 + do { 167 167 + const page = await appviewJson<AppviewListResponse<T>>(nsid, { 168 168 + subject, 169 169 + limit: 100, 170 170 + cursor, 171 171 + ...extraParams, 172 172 + }); 173 173 + records.push(...page.items); 174 174 + cursor = page.cursor ?? undefined; 175 175 + } while (cursor); 176 176 + 177 177 + return records; 178 178 + }; 179 179 + 180 180 + export const appviewBulkRecords = async <T>( 181 181 + nsid: string, 182 182 + paramName: string, 183 183 + uris: ResourceUri[], 184 184 + ): Promise<Array<AppviewRecordView<T>>> => { 185 185 + if (uris.length === 0) { 186 186 + return []; 187 187 + } 188 188 + 189 189 + const records: Array<AppviewRecordView<T>> = []; 190 190 + for (let index = 0; index < uris.length; index += 50) { 191 191 + const url = new URL(`/xrpc/${nsid}`, normalizeServiceUrl(getTangledAppviewService())); 192 192 + for (const uri of uris.slice(index, index + 50)) { 193 193 + url.searchParams.append(paramName, uri); 194 194 + } 195 195 + 196 196 + const page = await appviewJsonUrl<AppviewBulkResponse<T>>(url); 197 197 + records.push(...page.items); 198 198 + } 199 199 + 200 200 + return records; 201 201 + }; 202 202 + 203 203 + export const getAppviewRecordCount = async (nsid: string, subject: string): Promise<number> => { 204 204 + const count = await appviewJson<AppviewCountResponse>(nsid, { subject }); 205 205 + return count.count; 206 206 + }; 207 207 + 208 208 + export const getDistinctAppviewRecordCount = async (nsid: string, subject: string): Promise<number> => { 209 209 + const count = await appviewJson<AppviewCountResponse>(nsid, { subject }); 210 210 + return count.distinctAuthors ?? count.distinct_authors ?? count.count; 211 211 + }; 212 212 + 213 213 + export const getRepoViaAppview = async <T>( 214 214 + nsid: string, 215 215 + repo: { record: { uri: string } }, 216 216 + params: Record<string, AppviewParamValue> = {}, 217 217 + ): Promise<T> => 218 218 + appviewJson<T>(nsid, { 219 219 + repo: repo.record.uri, 220 220 + ...params, 221 221 + }); 222 222 + 223 223 + export const appviewOptionalKnotRequest = async <T>( 224 224 + appview: () => Promise<T>, 225 225 + direct: () => Promise<T>, 226 226 + ): Promise<T> => { 227 227 + if (!getRouteKnotRequestsThroughAppview()) { 228 228 + return direct(); 229 229 + } 230 230 + 231 231 + return appviewFallback(appview, direct); 232 232 + };

+269

src/lib/api/backlinks.ts

Reviewed

··· 1 1 + import { ok } from '@atcute/client'; 2 2 + import type { Did, GenericUri, ResourceUri } from '@atcute/lexicons/syntax'; 3 3 + 4 4 + import { CONSTELLATION_SERVICE, STAR_COLLECTION } from './constants'; 5 5 + import { getRpc } from './client'; 6 6 + import { hydrateBacklinks } from './hydration'; 7 7 + import { 8 8 + type BacklinkRecordRef, 9 9 + type HydratedRecord, 10 10 + type PaginatedResult, 11 11 + sortByCreatedAt, 12 12 + timestampFromTid, 13 13 + toNumberMap, 14 14 + } from './records'; 15 15 + import { 16 16 + paginateStatefulRecords, 17 17 + sortStatefulRecordsByUpdatedAt, 18 18 + statefulRecordMatchesQuery, 19 19 + type StatefulHydratedRecord, 20 20 + type StatefulPageOptions, 21 21 + } from './stateful'; 22 22 + 23 23 + export const getBacklinksPage = async ( 24 24 + subject: GenericUri, 25 25 + source: string, 26 26 + limit: number, 27 27 + cursor?: string, 28 28 + ): Promise<{ records: BacklinkRecordRef[]; cursor?: string; total?: number }> => { 29 29 + const constellation = getRpc(CONSTELLATION_SERVICE); 30 30 + const page = await ok( 31 31 + constellation.get('blue.microcosm.links.getBacklinks', { 32 32 + params: { 33 33 + subject, 34 34 + source, 35 35 + limit, 36 36 + ...(cursor ? { cursor } : {}), 37 37 + }, 38 38 + }), 39 39 + ); 40 40 + 41 41 + return page as { records: BacklinkRecordRef[]; cursor?: string; total?: number }; 42 42 + }; 43 43 + 44 44 + const getBacklinkDidsPage = async ( 45 45 + subject: GenericUri, 46 46 + source: string, 47 47 + limit: number, 48 48 + cursor?: string, 49 49 + ): Promise<{ linking_dids: Did[]; cursor?: string | null; total?: number }> => { 50 50 + const constellation = getRpc(CONSTELLATION_SERVICE); 51 51 + const page = await ok( 52 52 + constellation.get('blue.microcosm.links.getBacklinkDids', { 53 53 + params: { 54 54 + subject, 55 55 + source, 56 56 + limit, 57 57 + ...(cursor ? { cursor } : {}), 58 58 + }, 59 59 + }), 60 60 + ); 61 61 + 62 62 + return page as { linking_dids: Did[]; cursor?: string | null; total?: number }; 63 63 + }; 64 64 + 65 65 + export const getBacklinkDids = async (subject: GenericUri, source: string): Promise<Did[]> => { 66 66 + const dids: Did[] = []; 67 67 + let cursor: string | null = null; 68 68 + 69 69 + do { 70 70 + const page = await getBacklinkDidsPage(subject, source, 100, cursor ?? undefined); 71 71 + dids.push(...page.linking_dids); 72 72 + cursor = page.cursor ?? null; 73 73 + } while (cursor); 74 74 + 75 75 + return dids; 76 76 + }; 77 77 + 78 78 + const findBacklinkRefByDidForSource = async ( 79 79 + subject: GenericUri, 80 80 + source: string, 81 81 + did: Did, 82 82 + ): Promise<BacklinkRecordRef | undefined> => { 83 83 + let cursor: string | null = null; 84 84 + 85 85 + do { 86 86 + const page = await getBacklinksPage(subject, source, 100, cursor ?? undefined); 87 87 + const ref = page.records.find((record) => record.did === did && record.collection === STAR_COLLECTION); 88 88 + if (ref) { 89 89 + return ref; 90 90 + } 91 91 + cursor = page.cursor ?? null; 92 92 + } while (cursor); 93 93 + }; 94 94 + 95 95 + export const findBacklinkRefByDid = async ( 96 96 + subject: GenericUri, 97 97 + sources: string[], 98 98 + did: Did, 99 99 + ): Promise<BacklinkRecordRef | undefined> => { 100 100 + const refs = await Promise.all(sources.map((source) => findBacklinkRefByDidForSource(subject, source, did))); 101 101 + return refs.find((ref) => ref); 102 102 + }; 103 103 + 104 104 + export const getBacklinks = async (subject: GenericUri, source: string): Promise<BacklinkRecordRef[]> => { 105 105 + const records: BacklinkRecordRef[] = []; 106 106 + let cursor: string | null = null; 107 107 + const constellation = getRpc(CONSTELLATION_SERVICE); 108 108 + 109 109 + do { 110 110 + const page: { records: BacklinkRecordRef[]; cursor?: string | null } = await ok( 111 111 + constellation.get('blue.microcosm.links.getBacklinks', { 112 112 + params: { 113 113 + subject, 114 114 + source, 115 115 + limit: 100, 116 116 + ...(cursor ? { cursor } : {}), 117 117 + }, 118 118 + }), 119 119 + ); 120 120 + records.push(...page.records); 121 121 + cursor = page.cursor ?? null; 122 122 + } while (cursor); 123 123 + 124 124 + return records; 125 125 + }; 126 126 + 127 127 + export const latestBacklinkRefByRkey = (refs: BacklinkRecordRef[]): BacklinkRecordRef | undefined => 128 128 + [...refs].sort((left, right) => left.rkey.localeCompare(right.rkey)).at(-1); 129 129 + 130 130 + export const getUniqueBacklinkRefs = async ( 131 131 + subject: GenericUri, 132 132 + source: string | string[], 133 133 + ): Promise<BacklinkRecordRef[]> => 134 134 + Array.from( 135 135 + new Map( 136 136 + ( 137 137 + await Promise.all( 138 138 + (Array.isArray(source) ? source : [source]).map((entry) => getBacklinks(subject, entry)), 139 139 + ) 140 140 + ) 141 141 + .flat() 142 142 + .map((ref) => [`${ref.did}/${ref.collection}/${ref.rkey}`, ref] as const), 143 143 + ).values(), 144 144 + ); 145 145 + 146 146 + export const getLatestBacklinkTimestamp = async ( 147 147 + subject: GenericUri, 148 148 + source: string | string[], 149 149 + ): Promise<number> => { 150 150 + try { 151 151 + return timestampFromTid(latestBacklinkRefByRkey(await getUniqueBacklinkRefs(subject, source))?.rkey); 152 152 + } catch { 153 153 + return 0; 154 154 + } 155 155 + }; 156 156 + 157 157 + const BACKLINK_BATCH_LIMIT = 50; 158 158 + 159 159 + export const listBacklinkedRecordsPage = async <T extends { createdAt?: string }, State extends string>( 160 160 + subject: GenericUri, 161 161 + source: string | string[], 162 162 + options: StatefulPageOptions<State>, 163 163 + getState: (uri: ResourceUri) => Promise<State>, 164 164 + getUpdatedAt?: (record: StatefulHydratedRecord<T, State>) => Promise<number>, 165 165 + hydrateRefs: (refs: BacklinkRecordRef[]) => Promise<Array<HydratedRecord<T>>> = hydrateBacklinks<T>, 166 166 + ): Promise<PaginatedResult<StatefulHydratedRecord<T, State>>> => { 167 167 + if (getUpdatedAt) { 168 168 + const hydrated = await hydrateRefs(await getUniqueBacklinkRefs(subject, source)); 169 169 + const numbers = toNumberMap(hydrated); 170 170 + const states = await Promise.all(hydrated.map((record) => getState(record.uri))); 171 171 + const items = hydrated.map((record, index) => ({ 172 172 + ...record, 173 173 + number: numbers.get(record.uri) ?? index + 1, 174 174 + state: states[index], 175 175 + })); 176 176 + const ordered = await sortStatefulRecordsByUpdatedAt(items, getUpdatedAt); 177 177 + 178 178 + return paginateStatefulRecords(ordered, options); 179 179 + } 180 180 + 181 181 + const requestedEnd = options.offset + options.limit; 182 182 + const items: Array<StatefulHydratedRecord<T, State>> = []; 183 183 + const sources = Array.isArray(source) ? source : [source]; 184 184 + const batchLimit = Math.min(BACKLINK_BATCH_LIMIT, Math.max(options.limit + 1, 1)); 185 185 + const cursors = new Map(sources.map((entry) => [entry, undefined as string | undefined])); 186 186 + const exhausted = new Set<string>(); 187 187 + const seenRefs = new Set<string>(); 188 188 + let matchingSeen = 0; 189 189 + let scannedSeen = 0; 190 190 + let total: number | undefined; 191 191 + 192 192 + while (items.length <= options.limit) { 193 193 + const pages = await Promise.all( 194 194 + sources 195 195 + .filter((entry) => !exhausted.has(entry)) 196 196 + .map(async (entry) => ({ 197 197 + source: entry, 198 198 + page: await getBacklinksPage(subject, entry, batchLimit, cursors.get(entry)), 199 199 + })), 200 200 + ); 201 201 + 202 202 + if (pages.length === 0) { 203 203 + return { items, totalCount: matchingSeen, hasNext: false }; 204 204 + } 205 205 + 206 206 + const refs = pages 207 207 + .flatMap(({ source: entry, page }) => { 208 208 + total = sources.length === 1 ? page.total ?? total : undefined; 209 209 + cursors.set(entry, page.cursor); 210 210 + if (!page.cursor) { 211 211 + exhausted.add(entry); 212 212 + } 213 213 + return page.records; 214 214 + }) 215 215 + .filter((ref) => { 216 216 + const key = `${ref.did}/${ref.collection}/${ref.rkey}`; 217 217 + if (seenRefs.has(key)) { 218 218 + return false; 219 219 + } 220 220 + seenRefs.add(key); 221 221 + return true; 222 222 + }); 223 223 + 224 224 + if (refs.length === 0) { 225 225 + if (exhausted.size === sources.length) { 226 226 + return { items, totalCount: matchingSeen, hasNext: false }; 227 227 + } 228 228 + continue; 229 229 + } 230 230 + 231 231 + if (pages.every(({ page }) => page.records.length === 0)) { 232 232 + return { items, totalCount: matchingSeen, hasNext: false }; 233 233 + } 234 234 + 235 235 + const hydrated = await hydrateRefs(refs); 236 236 + hydrated.sort(sortByCreatedAt).reverse(); 237 237 + const states = await Promise.all(hydrated.map((record) => getState(record.uri))); 238 238 + 239 239 + for (let index = 0; index < hydrated.length; index += 1) { 240 240 + const record = hydrated[index]; 241 241 + const state = states[index]; 242 242 + const number = total ? Math.max(total - scannedSeen, 1) : scannedSeen + 1; 243 243 + scannedSeen += 1; 244 244 + 245 245 + if (state !== options.state) { 246 246 + continue; 247 247 + } 248 248 + 249 249 + if (!statefulRecordMatchesQuery(record.value, options.query)) { 250 250 + continue; 251 251 + } 252 252 + 253 253 + if (matchingSeen >= options.offset && matchingSeen < requestedEnd + 1) { 254 254 + items.push({ ...record, number, state }); 255 255 + } 256 256 + 257 257 + matchingSeen += 1; 258 258 + if (matchingSeen > requestedEnd) { 259 259 + return { items: items.slice(0, options.limit), hasNext: true }; 260 260 + } 261 261 + } 262 262 + 263 263 + if (exhausted.size === sources.length) { 264 264 + return { items, totalCount: matchingSeen, hasNext: false }; 265 265 + } 266 266 + } 267 267 + 268 268 + return { items: items.slice(0, options.limit), hasNext: true }; 269 269 + };

+34

src/lib/api/client.ts

Reviewed

··· 1 1 + import { Client, simpleFetchHandler } from '@atcute/client'; 2 2 + import type { OAuthUserAgent } from '@atcute/oauth-browser-client'; 3 3 + 4 4 + const rpcCache = new Map<string, Client>(); 5 5 + 6 6 + export const normalizeServiceUrl = (input: string): string => { 7 7 + if (input.startsWith('http://') || input.startsWith('https://')) { 8 8 + return input; 9 9 + } 10 10 + 11 11 + return `https://${input}`; 12 12 + }; 13 13 + 14 14 + export const getRpc = (service: string): Client => { 15 15 + const normalized = normalizeServiceUrl(service); 16 16 + const existing = rpcCache.get(normalized); 17 17 + if (existing) { 18 18 + return existing; 19 19 + } 20 20 + 21 21 + const client = new Client({ 22 22 + handler: simpleFetchHandler({ 23 23 + service: normalized, 24 24 + }), 25 25 + }); 26 26 + 27 27 + rpcCache.set(normalized, client); 28 28 + return client; 29 29 + }; 30 30 + 31 31 + export const createAuthRpc = (agent: OAuthUserAgent): Client => 32 32 + new Client({ 33 33 + handler: agent, 34 34 + });

+22 -8

src/lib/api/constants.ts

Reviewed

··· 1 1 - export { 2 2 - CONSTELLATION_SERVICE, 3 3 - PUBLIC_API_SERVICE, 4 4 - SLINGSHOT_SERVICE, 5 5 - SPACEDUST_SERVICE, 6 6 - TANGLED_APPVIEW_SERVICE, 7 7 - TANGLED_OAUTH_SCOPE, 8 8 - } from './core'; 1 1 + import type { Nsid } from '@atcute/lexicons/syntax'; 2 2 + 3 3 + import { DEFAULT_TANGLED_APPVIEW_SERVICE } from '../settings'; 4 4 + 5 5 + export const PUBLIC_API_SERVICE = 'https://public.api.bsky.app'; 6 6 + export const CONSTELLATION_SERVICE = 'https://constellation.microcosm.blue'; 7 7 + export const SLINGSHOT_SERVICE = 'https://slingshot.microcosm.blue'; 8 8 + export const SPACEDUST_SERVICE = 'wss://spacedust.microcosm.blue/subscribe'; 9 9 + export const TANGLED_APPVIEW_SERVICE = DEFAULT_TANGLED_APPVIEW_SERVICE; 10 10 + 11 11 + export const TANGLED_OAUTH_SCOPE = import.meta.env.VITE_OAUTH_SCOPE; 12 12 + 13 13 + export const REPO_COLLECTION: Nsid = 'sh.tangled.repo'; 14 14 + export const STAR_COLLECTION: Nsid = 'sh.tangled.feed.star'; 15 15 + export const ACTOR_PROFILE_COLLECTION: Nsid = 'sh.tangled.actor.profile'; 16 16 + export const APP_BSKY_PROFILE_COLLECTION: Nsid = 'app.bsky.actor.profile'; 17 17 + export const ISSUE_COLLECTION: Nsid = 'sh.tangled.repo.issue'; 18 18 + export const ISSUE_COMMENT_COLLECTION: Nsid = 'sh.tangled.repo.issue.comment'; 19 19 + export const ISSUE_STATE_COLLECTION: Nsid = 'sh.tangled.repo.issue.state'; 20 20 + export const PULL_COLLECTION: Nsid = 'sh.tangled.repo.pull'; 21 21 + export const PULL_COMMENT_COLLECTION: Nsid = 'sh.tangled.repo.pull.comment'; 22 22 + export const PULL_STATUS_COLLECTION: Nsid = 'sh.tangled.repo.pull.status';

-2784

src/lib/api/core.ts

Reviewed

··· 1 1 - import { Client, ClientResponseError, ok, simpleFetchHandler } from '@atcute/client'; 2 2 - import { 3 3 - type ActorResolver, 4 4 - type ResolveActorOptions, 5 5 - type ResolvedActor, 6 6 - } from '@atcute/identity-resolver'; 7 7 - import type { 8 8 - ActorIdentifier, 9 9 - Did, 10 10 - Handle, 11 11 - Nsid, 12 12 - ResourceUri, 13 13 - } from '@atcute/lexicons/syntax'; 14 14 - import type { GenericUri } from '@atcute/lexicons/syntax'; 15 15 - import type { OAuthUserAgent } from '@atcute/oauth-browser-client'; 16 16 - import { 17 17 - ShTangledActorProfile, 18 18 - ShTangledFeedStar, 19 19 - ShTangledLabelDefinition, 20 20 - ShTangledRepo, 21 21 - ShTangledRepoIssue, 22 22 - ShTangledRepoIssueComment, 23 23 - ShTangledRepoIssueState, 24 24 - ShTangledRepoPull, 25 25 - ShTangledRepoPullComment, 26 26 - ShTangledRepoPullStatus, 27 27 - ShTangledString, 28 28 - } from '@atcute/tangled'; 29 29 - import { gunzipSync, gzipSync, strFromU8, strToU8 } from 'fflate'; 30 30 - 31 31 - import type {} from '@atcute/atproto'; 32 32 - import type {} from '@atcute/microcosm'; 33 33 - import type {} from '@atcute/tangled'; 34 34 - 35 35 - import { 36 36 - DEFAULT_TANGLED_APPVIEW_SERVICE, 37 37 - getRouteKnotRequestsThroughAppview, 38 38 - getTangledAppviewService, 39 39 - } from '../settings'; 40 40 - 41 41 - export const PUBLIC_API_SERVICE = 'https://public.api.bsky.app'; 42 42 - export const CONSTELLATION_SERVICE = 'https://constellation.microcosm.blue'; 43 43 - export const SLINGSHOT_SERVICE = 'https://slingshot.microcosm.blue'; 44 44 - export const SPACEDUST_SERVICE = 'wss://spacedust.microcosm.blue/subscribe'; 45 45 - export const TANGLED_APPVIEW_SERVICE = DEFAULT_TANGLED_APPVIEW_SERVICE; 46 46 - 47 47 - export const TANGLED_OAUTH_SCOPE = import.meta.env.VITE_OAUTH_SCOPE; 48 48 - 49 49 - const REPO_COLLECTION: Nsid = 'sh.tangled.repo'; 50 50 - const STAR_COLLECTION: Nsid = 'sh.tangled.feed.star'; 51 51 - const ACTOR_PROFILE_COLLECTION: Nsid = 'sh.tangled.actor.profile'; 52 52 - const APP_BSKY_PROFILE_COLLECTION: Nsid = 'app.bsky.actor.profile'; 53 53 - const ISSUE_COLLECTION: Nsid = 'sh.tangled.repo.issue'; 54 54 - const ISSUE_COMMENT_COLLECTION: Nsid = 'sh.tangled.repo.issue.comment'; 55 55 - const ISSUE_STATE_COLLECTION: Nsid = 'sh.tangled.repo.issue.state'; 56 56 - const PULL_COLLECTION: Nsid = 'sh.tangled.repo.pull'; 57 57 - const PULL_COMMENT_COLLECTION: Nsid = 'sh.tangled.repo.pull.comment'; 58 58 - const PULL_STATUS_COLLECTION: Nsid = 'sh.tangled.repo.pull.status'; 59 59 - 60 60 - interface MiniDocResponse { 61 61 - did: Did; 62 62 - handle: Handle; 63 63 - pds: string; 64 64 - } 65 65 - 66 66 - class AppviewFirstActorResolver implements ActorResolver { 67 67 - async resolve(actor: ActorIdentifier, options?: ResolveActorOptions): Promise<ResolvedActor> { 68 68 - try { 69 69 - return normalizeResolvedActor( 70 70 - await appviewJson<MiniDocResponse>( 71 71 - 'com.bad-example.identity.resolveMiniDoc', 72 72 - { identifier: actor }, 73 73 - options?.signal, 74 74 - ), 75 75 - ); 76 76 - } catch (cause) { 77 77 - if (!(cause instanceof AppviewUnavailableError)) { 78 78 - throw cause; 79 79 - } 80 80 - 81 81 - const resolved = await ok( 82 82 - getRpc(SLINGSHOT_SERVICE).get('blue.microcosm.identity.resolveMiniDoc', { 83 83 - params: { 84 84 - identifier: actor, 85 85 - }, 86 86 - signal: options?.signal, 87 87 - }), 88 88 - ); 89 89 - 90 90 - return normalizeResolvedActor(resolved); 91 91 - } 92 92 - } 93 93 - } 94 94 - 95 95 - export const identityResolver = new AppviewFirstActorResolver(); 96 96 - 97 97 - export interface RepoContext { 98 98 - owner: ResolvedActor; 99 99 - record: RepoRecord; 100 100 - repoDid: Did; 101 101 - slug: string; 102 102 - rkey: string; 103 103 - knot: string; 104 104 - } 105 105 - 106 106 - export interface RepoRecord { 107 107 - uri: ResourceUri; 108 108 - cid: string; 109 109 - rkey: string; 110 110 - value: ShTangledRepo.Main; 111 111 - } 112 112 - 113 113 - export interface HydratedRecord<T> { 114 114 - author: ResolvedActor; 115 115 - collection: Nsid; 116 116 - rkey: string; 117 117 - uri: ResourceUri; 118 118 - cid?: string; 119 119 - value: T; 120 120 - } 121 121 - 122 122 - export interface IssueSummary extends HydratedRecord<ShTangledRepoIssue.Main> { 123 123 - number: number; 124 124 - state: 'open' | 'closed'; 125 125 - } 126 126 - 127 127 - export interface PullSummary extends HydratedRecord<ShTangledRepoPull.Main> { 128 128 - number: number; 129 129 - state: 'open' | 'closed' | 'merged'; 130 130 - } 131 131 - 132 132 - type StatefulHydratedRecord<T, State extends string> = HydratedRecord<T> & { 133 133 - number: number; 134 134 - state: State; 135 135 - }; 136 136 - 137 137 - type StatefulPageOptions<State extends string> = { 138 138 - offset: number; 139 139 - limit: number; 140 140 - state: State; 141 141 - author?: Did; 142 142 - query?: string; 143 143 - }; 144 144 - 145 145 - export interface IssueComment extends HydratedRecord<ShTangledRepoIssueComment.Main> {} 146 146 - export interface PullComment extends HydratedRecord<ShTangledRepoPullComment.Main> {} 147 147 - 148 148 - export interface IssueDetail { 149 149 - issue: IssueSummary; 150 150 - comments: IssueComment[]; 151 151 - } 152 152 - 153 153 - export interface PullDetail { 154 154 - pull: PullSummary; 155 155 - comments: PullComment[]; 156 156 - } 157 157 - 158 158 - export type SearchCollection = 159 159 - | 'sh.tangled.actor.profile' 160 160 - | 'sh.tangled.repo' 161 161 - | 'sh.tangled.repo.issue' 162 162 - | 'sh.tangled.repo.issue.comment' 163 163 - | 'sh.tangled.repo.pull' 164 164 - | 'sh.tangled.repo.pull.comment' 165 165 - | 'sh.tangled.string' 166 166 - | 'sh.tangled.label.definition'; 167 167 - 168 168 - export type SearchRecordValue = 169 169 - | ShTangledActorProfile.Main 170 170 - | ShTangledRepo.Main 171 171 - | ShTangledRepoIssue.Main 172 172 - | ShTangledRepoIssueComment.Main 173 173 - | ShTangledRepoPull.Main 174 174 - | ShTangledRepoPullComment.Main 175 175 - | ShTangledString.Main 176 176 - | ShTangledLabelDefinition.Main; 177 177 - 178 178 - export interface SearchHit extends HydratedRecord<SearchRecordValue> { 179 179 - nsid: SearchCollection; 180 180 - score: number; 181 181 - } 182 182 - 183 183 - export interface SearchResponse { 184 184 - hits: SearchHit[]; 185 185 - cursor?: string; 186 186 - } 187 187 - 188 188 - export interface SearchRecordsOptions { 189 189 - q: string; 190 190 - nsid?: SearchCollection; 191 191 - author?: Did; 192 192 - repo?: Did; 193 193 - since?: string; 194 194 - until?: string; 195 195 - cursor?: string; 196 196 - limit?: number; 197 197 - } 198 198 - 199 199 - export interface PaginatedResult<T> { 200 200 - items: T[]; 201 201 - totalCount?: number; 202 202 - hasNext: boolean; 203 203 - } 204 204 - 205 205 - export interface TreeResponse { 206 206 - ref: string; 207 207 - parent?: string; 208 208 - dotdot?: string; 209 209 - lastCommit?: CommitHeadline; 210 210 - readme?: { 211 211 - contents: string; 212 212 - filename: string; 213 213 - }; 214 214 - files: TreeEntry[]; 215 215 - } 216 216 - 217 217 - export interface TreeEntry { 218 218 - name: string; 219 219 - mode: string; 220 220 - size: number; 221 221 - last_commit?: CommitHeadline; 222 222 - } 223 223 - 224 224 - export interface CommitHeadline { 225 225 - hash: string; 226 226 - message: string; 227 227 - when: string; 228 228 - author?: { 229 229 - email: string; 230 230 - name: string; 231 231 - when: string; 232 232 - }; 233 233 - } 234 234 - 235 235 - export interface BranchResponse { 236 236 - branches: BranchEntry[]; 237 237 - } 238 238 - 239 239 - export interface DefaultBranchResponse { 240 240 - name?: string; 241 241 - branch?: string; 242 242 - reference?: { 243 243 - name?: string; 244 244 - }; 245 245 - hash?: string; 246 246 - when?: string; 247 247 - } 248 248 - 249 249 - export interface BranchEntry { 250 250 - reference: { 251 251 - name: string; 252 252 - hash: string; 253 253 - }; 254 254 - commit?: { 255 255 - Message: string; 256 256 - Author?: { 257 257 - Name: string; 258 258 - Email: string; 259 259 - When: string; 260 260 - }; 261 261 - Committer?: { 262 262 - Name: string; 263 263 - Email: string; 264 264 - When: string; 265 265 - }; 266 266 - }; 267 267 - is_default?: boolean; 268 268 - } 269 269 - 270 270 - export interface TagResponse { 271 271 - tags: Array<{ 272 272 - name: string; 273 273 - hash: string; 274 274 - message?: string; 275 275 - tag?: { 276 276 - Name: string; 277 277 - Message: string; 278 278 - Tagger?: { 279 279 - Name: string; 280 280 - Email: string; 281 281 - When: string; 282 282 - }; 283 283 - }; 284 284 - }>; 285 285 - } 286 286 - 287 287 - export interface LanguageResponse { 288 288 - ref: string; 289 289 - totalFiles?: number; 290 290 - totalSize?: number; 291 291 - languages: Array<{ 292 292 - name: string; 293 293 - percentage: number; 294 294 - size: number; 295 295 - color?: string; 296 296 - }>; 297 297 - } 298 298 - 299 299 - export interface LogResponse { 300 300 - ref: string; 301 301 - total: number; 302 302 - page: number; 303 303 - per_page: number; 304 304 - log: boolean; 305 305 - commits: Array<{ 306 306 - this: string; 307 307 - message: string; 308 308 - author?: { 309 309 - Name: string; 310 310 - Email: string; 311 311 - When: string; 312 312 - }; 313 313 - committer?: { 314 314 - Name: string; 315 315 - Email: string; 316 316 - When: string; 317 317 - }; 318 318 - pgp_signature?: string; 319 319 - parent?: string; 320 320 - parent_hashes?: number[][]; 321 321 - }>; 322 322 - } 323 323 - 324 324 - export interface BlobResponse { 325 325 - path: string; 326 326 - ref: string; 327 327 - content?: string; 328 328 - encoding?: 'base64' | 'utf-8'; 329 329 - fileTooLarge?: boolean; 330 330 - isBinary?: boolean; 331 331 - mimeType?: string; 332 332 - size?: number; 333 333 - lastCommit?: CommitHeadline; 334 334 - submodule?: { 335 335 - name: string; 336 336 - url: string; 337 337 - branch?: string; 338 338 - }; 339 339 - } 340 340 - 341 341 - export interface ComparePatch { 342 342 - Title: string; 343 343 - Body: string; 344 344 - Raw: string; 345 345 - SHA: string; 346 346 - Author?: string; 347 347 - Committer?: string; 348 348 - AuthorDate?: string; 349 349 - CommitterDate?: string; 350 350 - SubjectPrefix?: string; 351 351 - RawHeaders?: string; 352 352 - BodyAppendix?: string; 353 353 - } 354 354 - 355 355 - export interface CompareResponse { 356 356 - rev1: string; 357 357 - rev2: string; 358 358 - patch: string; 359 359 - format_patch: ComparePatch[]; 360 360 - } 361 361 - 362 362 - export interface CreateIssueInput { 363 363 - title: string; 364 364 - body: string; 365 365 - } 366 366 - 367 367 - export interface CreatePullInput { 368 368 - title: string; 369 369 - body: string; 370 370 - targetBranch: string; 371 371 - sourceBranch: string; 372 372 - patch: string; 373 373 - } 374 374 - 375 375 - export interface RecordCreationResult { 376 376 - uri: ResourceUri; 377 377 - rkey: string; 378 378 - } 379 379 - 380 380 - interface BacklinkRecordRef { 381 381 - did: Did; 382 382 - collection: Nsid; 383 383 - rkey: string; 384 384 - } 385 385 - 386 386 - interface ProfileWithAvatar { 387 387 - avatar?: unknown; 388 388 - } 389 389 - 390 390 - interface AppviewRecordView<T> { 391 391 - uri: ResourceUri; 392 392 - cid?: string | null; 393 393 - value: T; 394 394 - } 395 395 - 396 396 - interface AppviewListResponse<T> { 397 397 - items: Array<AppviewRecordView<T>>; 398 398 - cursor?: string | null; 399 399 - } 400 400 - 401 401 - interface AppviewBulkResponse<T> { 402 402 - items: Array<AppviewRecordView<T>>; 403 403 - } 404 404 - 405 405 - interface AppviewStatefulRecordView<T> extends AppviewRecordView<T> { 406 406 - state?: string; 407 407 - stateUpdatedAt?: string; 408 408 - commentCount?: number; 409 409 - } 410 410 - 411 411 - interface AppviewStatefulListResponse<T> { 412 412 - items: Array<AppviewStatefulRecordView<T>>; 413 413 - cursor?: string | null; 414 414 - } 415 415 - 416 416 - interface AppviewSearchHit<T> extends AppviewRecordView<T> { 417 417 - nsid: SearchCollection; 418 418 - score: number; 419 419 - } 420 420 - 421 421 - interface AppviewSearchResponse<T> { 422 422 - hits: Array<AppviewSearchHit<T>>; 423 423 - cursor?: string | null; 424 424 - } 425 425 - 426 426 - interface AppviewCountResponse { 427 427 - count: number; 428 428 - distinctAuthors?: number; 429 429 - distinct_authors?: number; 430 430 - } 431 431 - 432 432 - type AppviewParamValue = string | number | boolean | null | undefined; 433 433 - 434 434 - const actorCache = new Map<string, Promise<ResolvedActor>>(); 435 435 - const rpcCache = new Map<string, Client>(); 436 436 - const SORTABLE_BASE32_ALPHABET = '234567abcdefghijklmnopqrstuvwxyz'; 437 437 - const TID_PATTERN = /^[234567abcdefghij][234567abcdefghijklmnopqrstuvwxyz]{12}$/; 438 438 - 439 439 - interface AppviewCursorCheckpoint { 440 440 - matchingSeen: number; 441 441 - scannedSeen: number; 442 442 - cursor?: string; 443 443 - exhausted: boolean; 444 444 - } 445 445 - 446 446 - const APPVIEW_PAGE_BATCH_LIMIT = 100; 447 447 - const SEARCH_PAGE_BATCH_LIMIT = 100; 448 448 - const APPVIEW_CURSOR_CACHE_LIMIT = 64; 449 449 - const appviewPageCursorCache = new Map<string, Map<number, AppviewCursorCheckpoint>>(); 450 450 - 451 451 - export const clearApiCaches = () => { 452 452 - actorCache.clear(); 453 453 - appviewPageCursorCache.clear(); 454 454 - }; 455 455 - 456 456 - const timestampFromDate = (value?: string): number => { 457 457 - if (!value) { 458 458 - return 0; 459 459 - } 460 460 - 461 461 - const timestamp = new Date(value).getTime(); 462 462 - return Number.isFinite(timestamp) ? timestamp : 0; 463 463 - }; 464 464 - 465 465 - const timestampFromTid = (rkey?: string): number => { 466 466 - if (!rkey || !TID_PATTERN.test(rkey)) { 467 467 - return 0; 468 468 - } 469 469 - 470 470 - let micros = 0; 471 471 - for (const char of rkey.slice(0, 11)) { 472 472 - const value = SORTABLE_BASE32_ALPHABET.indexOf(char); 473 473 - if (value < 0) { 474 474 - return 0; 475 475 - } 476 476 - micros = micros * 32 + value; 477 477 - } 478 478 - 479 479 - return Math.floor(micros / 1000); 480 480 - }; 481 481 - 482 482 - const maxTimestamp = (...values: number[]): number => 483 483 - values.reduce((latest, value) => Math.max(latest, value), 0); 484 484 - 485 485 - const getAppviewRecordSortTimestamp = <T extends { createdAt?: string }>( 486 486 - record: HydratedRecord<T>, 487 487 - ): number => 488 488 - maxTimestamp( 489 489 - timestampFromDate(record.value.createdAt), 490 490 - timestampFromTid(record.rkey), 491 491 - ); 492 492 - 493 493 - const sortStatefulRecordsByNewestRecord = <T extends { createdAt?: string }, State extends string>( 494 494 - items: Array<StatefulHydratedRecord<T, State>>, 495 495 - ): Array<StatefulHydratedRecord<T, State>> => 496 496 - [...items].sort((left, right) => { 497 497 - const timestampDiff = getAppviewRecordSortTimestamp(right) - getAppviewRecordSortTimestamp(left); 498 498 - if (timestampDiff !== 0) { 499 499 - return timestampDiff; 500 500 - } 501 501 - 502 502 - if (left.number !== right.number) { 503 503 - return right.number - left.number; 504 504 - } 505 505 - 506 506 - return right.rkey.localeCompare(left.rkey); 507 507 - }); 508 508 - 509 509 - const sortStatefulRecordsByUpdatedAt = async <T, State extends string>( 510 510 - items: Array<StatefulHydratedRecord<T, State>>, 511 511 - getUpdatedAt: (item: StatefulHydratedRecord<T, State>) => Promise<number>, 512 512 - ): Promise<Array<StatefulHydratedRecord<T, State>>> => { 513 513 - const decorated = await Promise.all( 514 514 - items.map(async (item) => ({ 515 515 - item, 516 516 - updatedAt: await getUpdatedAt(item), 517 517 - })), 518 518 - ); 519 519 - 520 520 - decorated.sort((left, right) => { 521 521 - const updatedDiff = right.updatedAt - left.updatedAt; 522 522 - if (updatedDiff !== 0) { 523 523 - return updatedDiff; 524 524 - } 525 525 - 526 526 - if (left.item.number !== right.item.number) { 527 527 - return right.item.number - left.item.number; 528 528 - } 529 529 - 530 530 - return right.item.rkey.localeCompare(left.item.rkey); 531 531 - }); 532 532 - 533 533 - return decorated.map(({ item }) => item); 534 534 - }; 535 535 - 536 536 - const paginateStatefulRecords = <T, State extends string>( 537 537 - items: Array<StatefulHydratedRecord<T, State>>, 538 538 - options: StatefulPageOptions<State>, 539 539 - ): PaginatedResult<StatefulHydratedRecord<T, State>> => { 540 540 - const offset = Math.max(options.offset, 0); 541 541 - const limit = Math.max(options.limit, 1); 542 542 - const matching = items.filter((item) => 543 543 - item.state === options.state && 544 544 - (!options.author || item.author.did === options.author) && 545 545 - statefulRecordMatchesQuery(item.value, options.query), 546 546 - ); 547 547 - 548 548 - return { 549 549 - items: matching.slice(offset, offset + limit), 550 550 - totalCount: matching.length, 551 551 - hasNext: offset + limit < matching.length, 552 552 - }; 553 553 - }; 554 554 - 555 555 - const statefulRecordMatchesQuery = (value: unknown, query?: string): boolean => { 556 556 - const normalized = query?.trim().toLowerCase(); 557 557 - if (!normalized) { 558 558 - return true; 559 559 - } 560 560 - 561 561 - const record = value as { title?: unknown; body?: unknown }; 562 562 - return [record.title, record.body] 563 563 - .filter((part): part is string => typeof part === 'string') 564 564 - .some((part) => part.toLowerCase().includes(normalized)); 565 565 - }; 566 566 - 567 567 - const normalizeServiceUrl = (input: string): string => { 568 568 - if (input.startsWith('http://') || input.startsWith('https://')) { 569 569 - return input; 570 570 - } 571 571 - 572 572 - return `https://${input}`; 573 573 - }; 574 574 - 575 575 - const normalizeResolvedActor = (resolved: MiniDocResponse): ResolvedActor => ({ 576 576 - did: resolved.did, 577 577 - handle: resolved.handle, 578 578 - pds: normalizeServiceUrl(resolved.pds), 579 579 - }); 580 580 - 581 581 - const unresolvedActorFromDid = (did: Did): ResolvedActor => ({ 582 582 - did, 583 583 - handle: did as unknown as Handle, 584 584 - pds: '', 585 585 - }); 586 586 - 587 587 - const resolveActorForDisplay = async (did: Did): Promise<ResolvedActor> => { 588 588 - try { 589 589 - return await resolveActor(did); 590 590 - } catch { 591 591 - return unresolvedActorFromDid(did); 592 592 - } 593 593 - }; 594 594 - 595 595 - const getRpc = (service: string): Client => { 596 596 - const normalized = normalizeServiceUrl(service); 597 597 - const existing = rpcCache.get(normalized); 598 598 - if (existing) { 599 599 - return existing; 600 600 - } 601 601 - 602 602 - const client = new Client({ 603 603 - handler: simpleFetchHandler({ 604 604 - service: normalized, 605 605 - }), 606 606 - }); 607 607 - 608 608 - rpcCache.set(normalized, client); 609 609 - return client; 610 610 - }; 611 611 - 612 612 - class AppviewResponseError extends Error { 613 613 - readonly status: number; 614 614 - 615 615 - constructor(status: number, message: string) { 616 616 - super(message); 617 617 - this.name = 'AppviewResponseError'; 618 618 - this.status = status; 619 619 - } 620 620 - } 621 621 - 622 622 - class AppviewUnavailableError extends Error { 623 623 - readonly cause: unknown; 624 624 - 625 625 - constructor(cause: unknown) { 626 626 - super(cause instanceof Error ? cause.message : 'Appview unavailable'); 627 627 - this.name = 'AppviewUnavailableError'; 628 628 - this.cause = cause; 629 629 - } 630 630 - } 631 631 - 632 632 - const appviewJson = async <T>( 633 633 - nsid: string, 634 634 - params: Record<string, AppviewParamValue> = {}, 635 635 - signal?: AbortSignal, 636 636 - ): Promise<T> => { 637 637 - const url = new URL(`/xrpc/${nsid}`, normalizeServiceUrl(getTangledAppviewService())); 638 638 - for (const [key, value] of Object.entries(params)) { 639 639 - if (value !== undefined && value !== null) { 640 640 - url.searchParams.set(key, String(value)); 641 641 - } 642 642 - } 643 643 - 644 644 - let response: Response; 645 645 - try { 646 646 - response = await fetch(url, { 647 647 - headers: { 648 648 - accept: 'application/json', 649 649 - }, 650 650 - signal, 651 651 - }); 652 652 - } catch (cause) { 653 653 - throw new AppviewUnavailableError(cause); 654 654 - } 655 655 - 656 656 - if (!response.ok) { 657 657 - let message = `${response.status} ${response.statusText}`.trim(); 658 658 - try { 659 659 - const body = (await response.json()) as { message?: unknown; error?: unknown }; 660 660 - const bodyMessage = typeof body.message === 'string' ? body.message : body.error; 661 661 - if (typeof bodyMessage === 'string') { 662 662 - message = bodyMessage; 663 663 - } 664 664 - } catch { 665 665 - // Keep the HTTP status message when the appview does not return JSON. 666 666 - } 667 667 - 668 668 - throw new AppviewResponseError(response.status, `Appview ${nsid} failed (${response.status}): ${message}`); 669 669 - } 670 670 - 671 671 - return (await response.json()) as T; 672 672 - }; 673 673 - 674 674 - const appviewJsonUrl = async <T>(url: URL, signal?: AbortSignal): Promise<T> => { 675 675 - let response: Response; 676 676 - try { 677 677 - response = await fetch(url, { 678 678 - headers: { 679 679 - accept: 'application/json', 680 680 - }, 681 681 - signal, 682 682 - }); 683 683 - } catch (cause) { 684 684 - throw new AppviewUnavailableError(cause); 685 685 - } 686 686 - 687 687 - if (!response.ok) { 688 688 - let message = `${response.status} ${response.statusText}`.trim(); 689 689 - try { 690 690 - const body = (await response.json()) as { message?: unknown; error?: unknown }; 691 691 - const bodyMessage = typeof body.message === 'string' ? body.message : body.error; 692 692 - if (typeof bodyMessage === 'string') { 693 693 - message = bodyMessage; 694 694 - } 695 695 - } catch { 696 696 - // Keep the HTTP status message when the appview does not return JSON. 697 697 - } 698 698 - 699 699 - throw new AppviewResponseError(response.status, `Appview ${url.pathname.slice('/xrpc/'.length)} failed (${response.status}): ${message}`); 700 700 - } 701 701 - 702 702 - return (await response.json()) as T; 703 703 - }; 704 704 - 705 705 - const appviewFallback = async <T>(primary: () => Promise<T>, fallback: () => Promise<T>): Promise<T> => { 706 706 - try { 707 707 - return await primary(); 708 708 - } catch (cause) { 709 709 - if (!(cause instanceof AppviewUnavailableError)) { 710 710 - throw cause; 711 711 - } 712 712 - 713 713 - return fallback(); 714 714 - } 715 715 - }; 716 716 - 717 717 - const listAllAppviewRecords = async <T>( 718 718 - nsid: string, 719 719 - subject: string, 720 720 - extraParams: Record<string, AppviewParamValue> = {}, 721 721 - ): Promise<Array<AppviewRecordView<T>>> => { 722 722 - const records: Array<AppviewRecordView<T>> = []; 723 723 - let cursor: string | undefined; 724 724 - 725 725 - do { 726 726 - const page = await appviewJson<AppviewListResponse<T>>(nsid, { 727 727 - subject, 728 728 - limit: 100, 729 729 - cursor, 730 730 - ...extraParams, 731 731 - }); 732 732 - records.push(...page.items); 733 733 - cursor = page.cursor ?? undefined; 734 734 - } while (cursor); 735 735 - 736 736 - return records; 737 737 - }; 738 738 - 739 739 - const appviewBulkRecords = async <T>( 740 740 - nsid: string, 741 741 - paramName: string, 742 742 - uris: ResourceUri[], 743 743 - ): Promise<Array<AppviewRecordView<T>>> => { 744 744 - if (uris.length === 0) { 745 745 - return []; 746 746 - } 747 747 - 748 748 - const records: Array<AppviewRecordView<T>> = []; 749 749 - for (let index = 0; index < uris.length; index += 50) { 750 750 - const url = new URL(`/xrpc/${nsid}`, normalizeServiceUrl(getTangledAppviewService())); 751 751 - for (const uri of uris.slice(index, index + 50)) { 752 752 - url.searchParams.append(paramName, uri); 753 753 - } 754 754 - 755 755 - const page = await appviewJsonUrl<AppviewBulkResponse<T>>(url); 756 756 - records.push(...page.items); 757 757 - } 758 758 - 759 759 - return records; 760 760 - }; 761 761 - 762 762 - const appviewRecordToHydrated = async <T>(record: AppviewRecordView<T>): Promise<HydratedRecord<T>> => { 763 763 - const parsed = parseAtUri(record.uri); 764 764 - const author = await resolveActorForDisplay(parsed.did); 765 765 - 766 766 - return { 767 767 - author, 768 768 - collection: parsed.collection, 769 769 - rkey: parsed.rkey, 770 770 - uri: record.uri, 771 771 - cid: record.cid ?? undefined, 772 772 - value: record.value, 773 773 - }; 774 774 - }; 775 775 - 776 776 - const appviewCursorCacheKey = ( 777 777 - nsid: string, 778 778 - subject: string, 779 779 - state: string, 780 780 - extraParams: Record<string, AppviewParamValue> = {}, 781 781 - ): string => { 782 782 - const extras = Object.entries(extraParams) 783 783 - .filter(([, value]) => value !== undefined && value !== null) 784 784 - .sort(([left], [right]) => left.localeCompare(right)) 785 785 - .map(([key, value]) => `${key}=${String(value)}`) 786 786 - .join('&'); 787 787 - 788 788 - return [ 789 789 - normalizeServiceUrl(getTangledAppviewService()), 790 790 - nsid, 791 791 - subject, 792 792 - state, 793 793 - extras, 794 794 - ].join('|'); 795 795 - }; 796 796 - 797 797 - const rememberAppviewCursorCheckpoint = (cacheKey: string, checkpoint: AppviewCursorCheckpoint) => { 798 798 - let checkpoints = appviewPageCursorCache.get(cacheKey); 799 799 - if (!checkpoints) { 800 800 - checkpoints = new Map(); 801 801 - appviewPageCursorCache.set(cacheKey, checkpoints); 802 802 - } 803 803 - 804 804 - const existing = checkpoints.get(checkpoint.matchingSeen); 805 805 - if (!existing || checkpoint.scannedSeen >= existing.scannedSeen) { 806 806 - checkpoints.set(checkpoint.matchingSeen, checkpoint); 807 807 - } 808 808 - 809 809 - while (checkpoints.size > APPVIEW_CURSOR_CACHE_LIMIT) { 810 810 - const first = checkpoints.keys().next().value; 811 811 - if (first === undefined) break; 812 812 - checkpoints.delete(first); 813 813 - } 814 814 - }; 815 815 - 816 816 - const getNearestAppviewCursorCheckpoint = ( 817 817 - cacheKey: string, 818 818 - offset: number, 819 819 - ): AppviewCursorCheckpoint => { 820 820 - const checkpoints = appviewPageCursorCache.get(cacheKey); 821 821 - const start: AppviewCursorCheckpoint = { 822 822 - matchingSeen: 0, 823 823 - scannedSeen: 0, 824 824 - exhausted: false, 825 825 - }; 826 826 - 827 827 - if (!checkpoints) { 828 828 - return start; 829 829 - } 830 830 - 831 831 - let nearest = start; 832 832 - for (const checkpoint of checkpoints.values()) { 833 833 - if (checkpoint.matchingSeen > offset) { 834 834 - continue; 835 835 - } 836 836 - 837 837 - if ( 838 838 - checkpoint.matchingSeen > nearest.matchingSeen || 839 839 - ( 840 840 - checkpoint.matchingSeen === nearest.matchingSeen && 841 841 - checkpoint.scannedSeen > nearest.scannedSeen 842 842 - ) 843 843 - ) { 844 844 - nearest = checkpoint; 845 845 - } 846 846 - } 847 847 - 848 848 - return nearest; 849 849 - }; 850 850 - 851 851 - const listAppviewStatefulRecordsPage = async <T extends { createdAt?: string }, State extends string>( 852 852 - nsid: string, 853 853 - subject: string, 854 854 - options: StatefulPageOptions<State>, 855 855 - normalizeState: (value?: string) => State, 856 856 - extraParams: Record<string, AppviewParamValue> = {}, 857 857 - getUpdatedAt?: ( 858 858 - record: StatefulHydratedRecord<T, State>, 859 859 - appviewRecord: AppviewStatefulRecordView<T>, 860 860 - ) => Promise<number>, 861 861 - ): Promise<PaginatedResult<StatefulHydratedRecord<T, State>>> => { 862 862 - if (getUpdatedAt) { 863 863 - const records = await listAllAppviewRecords<T>(nsid, subject, extraParams) as Array<AppviewStatefulRecordView<T>>; 864 864 - const hydrated = await Promise.all(records.map((record) => appviewRecordToHydrated(record))); 865 865 - const numbers = toNumberMap(hydrated); 866 866 - const decorated = await Promise.all( 867 867 - hydrated.map(async (record, index) => { 868 868 - const item: StatefulHydratedRecord<T, State> = { 869 869 - ...record, 870 870 - number: numbers.get(record.uri) ?? index + 1, 871 871 - state: normalizeState(records[index].state), 872 872 - }; 873 873 - 874 874 - return { 875 875 - item, 876 876 - updatedAt: await getUpdatedAt(item, records[index]), 877 877 - }; 878 878 - }), 879 879 - ); 880 880 - 881 881 - decorated.sort((left, right) => { 882 882 - const updatedDiff = right.updatedAt - left.updatedAt; 883 883 - if (updatedDiff !== 0) { 884 884 - return updatedDiff; 885 885 - } 886 886 - 887 887 - if (left.item.number !== right.item.number) { 888 888 - return right.item.number - left.item.number; 889 889 - } 890 890 - 891 891 - return right.item.rkey.localeCompare(left.item.rkey); 892 892 - }); 893 893 - 894 894 - return paginateStatefulRecords( 895 895 - decorated.map(({ item }) => item), 896 896 - options, 897 897 - ); 898 898 - } 899 899 - 900 900 - // Bobbin exposes cursor pagination, while the UI still uses offsets. Cache 901 901 - // page-boundary cursors so sequential pages can resume from the prior page. 902 902 - const offset = Math.max(options.offset, 0); 903 903 - const limit = Math.max(options.limit, 1); 904 904 - const requestedEnd = offset + limit; 905 905 - const cacheKey = appviewCursorCacheKey(nsid, subject, options.state, extraParams); 906 906 - const start = getNearestAppviewCursorCheckpoint(cacheKey, offset); 907 907 - const pendingItems: Array<{ 908 908 - record: AppviewStatefulRecordView<T>; 909 909 - number: number; 910 910 - state: State; 911 911 - }> = []; 912 912 - 913 913 - if (start.exhausted) { 914 914 - return { 915 915 - items: [], 916 916 - totalCount: start.matchingSeen, 917 917 - hasNext: false, 918 918 - }; 919 919 - } 920 920 - 921 921 - let cursor = start.cursor; 922 922 - let matchingSeen = start.matchingSeen; 923 923 - let scannedSeen = start.scannedSeen; 924 924 - 925 925 - while (true) { 926 926 - const pageLimit = Math.min( 927 927 - APPVIEW_PAGE_BATCH_LIMIT, 928 928 - Math.max(matchingSeen < requestedEnd ? requestedEnd - matchingSeen : 1, 1), 929 929 - ); 930 930 - const page = await appviewJson<AppviewStatefulListResponse<T>>(nsid, { 931 931 - subject, 932 932 - limit: pageLimit, 933 933 - cursor, 934 934 - ...extraParams, 935 935 - }); 936 936 - 937 937 - for (const record of page.items) { 938 938 - const state = normalizeState(record.state); 939 939 - const number = scannedSeen + 1; 940 940 - scannedSeen += 1; 941 941 - 942 942 - if (state !== options.state) { 943 943 - continue; 944 944 - } 945 945 - 946 946 - if (!statefulRecordMatchesQuery(record.value, options.query)) { 947 947 - continue; 948 948 - } 949 949 - 950 950 - if (matchingSeen >= offset && matchingSeen < requestedEnd) { 951 951 - pendingItems.push({ record, number, state }); 952 952 - } 953 953 - 954 954 - matchingSeen += 1; 955 955 - } 956 956 - 957 957 - cursor = page.cursor ?? undefined; 958 958 - const exhausted = !cursor; 959 959 - rememberAppviewCursorCheckpoint(cacheKey, { 960 960 - matchingSeen, 961 961 - scannedSeen, 962 962 - cursor, 963 963 - exhausted, 964 964 - }); 965 965 - 966 966 - if (matchingSeen > requestedEnd) { 967 967 - const visibleItems = pendingItems.slice(0, limit); 968 968 - const hydrated = await Promise.all( 969 969 - visibleItems.map(({ record }) => appviewRecordToHydrated(record)), 970 970 - ); 971 971 - 972 972 - return { 973 973 - items: hydrated.map((item, index) => ({ 974 974 - ...item, 975 975 - number: visibleItems[index].number, 976 976 - state: visibleItems[index].state, 977 977 - })), 978 978 - hasNext: true, 979 979 - }; 980 980 - } 981 981 - 982 982 - if (exhausted || page.items.length === 0) { 983 983 - const hydrated = await Promise.all( 984 984 - pendingItems.map(({ record }) => appviewRecordToHydrated(record)), 985 985 - ); 986 986 - 987 987 - return { 988 988 - items: hydrated.map((item, index) => ({ 989 989 - ...item, 990 990 - number: pendingItems[index].number, 991 991 - state: pendingItems[index].state, 992 992 - })), 993 993 - totalCount: matchingSeen, 994 994 - hasNext: false, 995 995 - }; 996 996 - } 997 997 - } 998 998 - }; 999 999 - 1000 1000 - const listSearchedStatefulRecordsPage = async <T, State extends string>( 1001 1001 - nsid: SearchCollection, 1002 1002 - repo: RepoContext, 1003 1003 - options: StatefulPageOptions<State>, 1004 1004 - getState: (uri: ResourceUri) => Promise<State>, 1005 1005 - ): Promise<PaginatedResult<StatefulHydratedRecord<T, State>>> => { 1006 1006 - const query = options.query?.trim(); 1007 1007 - if (!query) { 1008 1008 - return { items: [], totalCount: 0, hasNext: false }; 1009 1009 - } 1010 1010 - 1011 1011 - const offset = Math.max(options.offset, 0); 1012 1012 - const limit = Math.max(options.limit, 1); 1013 1013 - const requestedEnd = offset + limit; 1014 1014 - const items: Array<StatefulHydratedRecord<T, State>> = []; 1015 1015 - let cursor: string | undefined; 1016 1016 - let matchingSeen = 0; 1017 1017 - 1018 1018 - while (true) { 1019 1019 - const page = await appviewJson<AppviewSearchResponse<T>>('sh.tangled.search.query', { 1020 1020 - q: query, 1021 1021 - nsid, 1022 1022 - author: options.author, 1023 1023 - repo: repo.repoDid, 1024 1024 - cursor, 1025 1025 - limit: SEARCH_PAGE_BATCH_LIMIT, 1026 1026 - }); 1027 1027 - const hydrated = await Promise.all(page.hits.map((hit) => appviewRecordToHydrated(hit))); 1028 1028 - const states = await Promise.all(hydrated.map((record) => getState(record.uri))); 1029 1029 - 1030 1030 - for (const [index, record] of hydrated.entries()) { 1031 1031 - const state = states[index]; 1032 1032 - if (state !== options.state) { 1033 1033 - continue; 1034 1034 - } 1035 1035 - 1036 1036 - if (matchingSeen >= offset && matchingSeen < requestedEnd) { 1037 1037 - items.push({ 1038 1038 - ...record, 1039 1039 - number: 0, 1040 1040 - state, 1041 1041 - }); 1042 1042 - } 1043 1043 - 1044 1044 - matchingSeen += 1; 1045 1045 - if (matchingSeen > requestedEnd) { 1046 1046 - return { 1047 1047 - items: items.slice(0, limit), 1048 1048 - hasNext: true, 1049 1049 - }; 1050 1050 - } 1051 1051 - } 1052 1052 - 1053 1053 - cursor = page.cursor ?? undefined; 1054 1054 - if (!cursor || page.hits.length === 0) { 1055 1055 - return { 1056 1056 - items, 1057 1057 - totalCount: matchingSeen, 1058 1058 - hasNext: false, 1059 1059 - }; 1060 1060 - } 1061 1061 - } 1062 1062 - }; 1063 1063 - 1064 1064 - const getRepoViaAppview = async <T>( 1065 1065 - nsid: string, 1066 1066 - repo: RepoContext, 1067 1067 - params: Record<string, AppviewParamValue> = {}, 1068 1068 - ): Promise<T> => 1069 1069 - appviewJson<T>(nsid, { 1070 1070 - repo: repo.record.uri, 1071 1071 - ...params, 1072 1072 - }); 1073 1073 - 1074 1074 - const appviewOptionalKnotRequest = async <T>( 1075 1075 - appview: () => Promise<T>, 1076 1076 - direct: () => Promise<T>, 1077 1077 - ): Promise<T> => { 1078 1078 - if (!getRouteKnotRequestsThroughAppview()) { 1079 1079 - return direct(); 1080 1080 - } 1081 1081 - 1082 1082 - return appviewFallback(appview, direct); 1083 1083 - }; 1084 1084 - 1085 1085 - export const createAuthRpc = (agent: OAuthUserAgent): Client => 1086 1086 - new Client({ 1087 1087 - handler: agent, 1088 1088 - }); 1089 1089 - 1090 1090 - export const resolveActor = async (identifier: string): Promise<ResolvedActor> => { 1091 1091 - const key = identifier.toLowerCase(); 1092 1092 - const cached = actorCache.get(key); 1093 1093 - if (cached) { 1094 1094 - return cached; 1095 1095 - } 1096 1096 - 1097 1097 - const promise = identityResolver.resolve(asActorIdentifier(identifier)); 1098 1098 - actorCache.set(key, promise); 1099 1099 - return promise; 1100 1100 - }; 1101 1101 - 1102 1102 - const fetchAllRepoRecords = async ( 1103 1103 - actor: ResolvedActor, 1104 1104 - collection: Nsid, 1105 1105 - ): Promise<Array<{ uri: ResourceUri; cid: string; value: unknown }>> => { 1106 1106 - const rpc = getRpc(actor.pds); 1107 1107 - const records: Array<{ uri: ResourceUri; cid: string; value: unknown }> = []; 1108 1108 - let cursor: string | undefined; 1109 1109 - 1110 1110 - do { 1111 1111 - const page = await ok( 1112 1112 - rpc.get('com.atproto.repo.listRecords', { 1113 1113 - params: { 1114 1114 - repo: actor.did, 1115 1115 - collection, 1116 1116 - limit: 100, 1117 1117 - cursor, 1118 1118 - reverse: true, 1119 1119 - }, 1120 1120 - }), 1121 1121 - ); 1122 1122 - 1123 1123 - records.push(...page.records); 1124 1124 - cursor = page.cursor; 1125 1125 - } while (cursor); 1126 1126 - 1127 1127 - return records; 1128 1128 - }; 1129 1129 - 1130 1130 - const listRepoRecordsFromAppview = async (owner: string | ResolvedActor): Promise<RepoRecord[]> => { 1131 1131 - const actor = typeof owner === 'string' ? await resolveActor(owner) : owner; 1132 1132 - const records = await listAllAppviewRecords<ShTangledRepo.Main>('sh.tangled.repo.listRepos', actor.did); 1133 1133 - 1134 1134 - return records.map((record) => ({ 1135 1135 - uri: record.uri, 1136 1136 - cid: record.cid ?? '', 1137 1137 - rkey: parseAtUri(record.uri).rkey, 1138 1138 - value: record.value, 1139 1139 - })); 1140 1140 - }; 1141 1141 - 1142 1142 - const listRepoRecordsFromPds = async (owner: string | ResolvedActor): Promise<RepoRecord[]> => { 1143 1143 - const actor = typeof owner === 'string' ? await resolveActor(owner) : owner; 1144 1144 - const records = await fetchAllRepoRecords(actor, REPO_COLLECTION); 1145 1145 - 1146 1146 - return records.map((record) => ({ 1147 1147 - uri: record.uri, 1148 1148 - cid: record.cid, 1149 1149 - rkey: parseAtUri(record.uri).rkey, 1150 1150 - value: record.value as ShTangledRepo.Main, 1151 1151 - })); 1152 1152 - }; 1153 1153 - 1154 1154 - export const listRepoRecords = async (owner: string | ResolvedActor): Promise<RepoRecord[]> => 1155 1155 - appviewFallback( 1156 1156 - () => listRepoRecordsFromAppview(owner), 1157 1157 - () => listRepoRecordsFromPds(owner), 1158 1158 - ); 1159 1159 - 1160 1160 - export interface RepoStarSummary { 1161 1161 - count: number; 1162 1162 - isStarred: boolean; 1163 1163 - currentUserStarRkey?: string; 1164 1164 - } 1165 1165 - 1166 1166 - const STAR_BACKLINK_SOURCES = [ 1167 1167 - 'sh.tangled.feed.star:subject.did', 1168 1168 - 'sh.tangled.feed.star:subjectDid', 1169 1169 - ]; 1170 1170 - 1171 1171 - const getRepoStarSummaryFromBacklinks = async (repo: RepoContext, viewerDid?: Did | null): Promise<RepoStarSummary> => { 1172 1172 - const starrers = new Set<Did>(); 1173 1173 - const backlinkDidGroups = await Promise.all(STAR_BACKLINK_SOURCES.map((source) => getBacklinkDids(repo.repoDid, source))); 1174 1174 - 1175 1175 - for (const did of backlinkDidGroups.flat()) { 1176 1176 - starrers.add(did); 1177 1177 - } 1178 1178 - 1179 1179 - const currentUserStar = 1180 1180 - viewerDid && starrers.has(viewerDid) 1181 1181 - ? await findBacklinkRefByDid(repo.repoDid, STAR_BACKLINK_SOURCES, viewerDid) 1182 1182 - : undefined; 1183 1183 - 1184 1184 - return { 1185 1185 - count: starrers.size, 1186 1186 - isStarred: !!currentUserStar, 1187 1187 - currentUserStarRkey: currentUserStar?.rkey, 1188 1188 - }; 1189 1189 - }; 1190 1190 - 1191 1191 - const getRepoStarCountFromBacklinks = async (repo: RepoContext): Promise<number> => { 1192 1192 - const summary = await getRepoStarSummaryFromBacklinks(repo); 1193 1193 - return summary.count; 1194 1194 - }; 1195 1195 - 1196 1196 - const appviewStarSubjectDid = (star: ShTangledFeedStar.Main): Did | null => { 1197 1197 - const subject = star.subject as { did?: unknown; subjectDid?: unknown }; 1198 1198 - const did = subject.did ?? subject.subjectDid; 1199 1199 - return typeof did === 'string' && did.startsWith('did:') ? (did as Did) : null; 1200 1200 - }; 1201 1201 - 1202 1202 - const getRepoStarCountFromAppview = async (repo: RepoContext): Promise<number> => { 1203 1203 - const count = await appviewJson<AppviewCountResponse>('sh.tangled.feed.countStars', { 1204 1204 - subject: repo.repoDid, 1205 1205 - }); 1206 1206 - return count.distinctAuthors ?? count.distinct_authors ?? count.count; 1207 1207 - }; 1208 1208 - 1209 1209 - const getAppviewRecordCount = async (nsid: string, subject: string): Promise<number> => { 1210 1210 - const count = await appviewJson<AppviewCountResponse>(nsid, { subject }); 1211 1211 - return count.count; 1212 1212 - }; 1213 1213 - 1214 1214 - const findCurrentUserStarFromAppview = async ( 1215 1215 - repo: RepoContext, 1216 1216 - viewerDid: Did, 1217 1217 - ): Promise<AppviewRecordView<ShTangledFeedStar.Main> | undefined> => { 1218 1218 - const stars = await listAllAppviewRecords<ShTangledFeedStar.Main>('sh.tangled.feed.listStarsBy', viewerDid); 1219 1219 - return stars.find((star) => appviewStarSubjectDid(star.value) === repo.repoDid); 1220 1220 - }; 1221 1221 - 1222 1222 - const getRepoStarSummaryFromAppview = async ( 1223 1223 - repo: RepoContext, 1224 1224 - viewerDid?: Did | null, 1225 1225 - ): Promise<RepoStarSummary> => { 1226 1226 - const [count, currentUserStar] = await Promise.all([ 1227 1227 - getRepoStarCountFromAppview(repo), 1228 1228 - viewerDid ? findCurrentUserStarFromAppview(repo, viewerDid) : undefined, 1229 1229 - ]); 1230 1230 - 1231 1231 - return { 1232 1232 - count, 1233 1233 - isStarred: !!currentUserStar, 1234 1234 - currentUserStarRkey: currentUserStar ? parseAtUri(currentUserStar.uri).rkey : undefined, 1235 1235 - }; 1236 1236 - }; 1237 1237 - 1238 1238 - export const getRepoStarSummary = async (repo: RepoContext, viewerDid?: Did | null): Promise<RepoStarSummary> => 1239 1239 - appviewFallback( 1240 1240 - () => getRepoStarSummaryFromAppview(repo, viewerDid), 1241 1241 - () => getRepoStarSummaryFromBacklinks(repo, viewerDid), 1242 1242 - ); 1243 1243 - 1244 1244 - export const getRepoStarCount = async (repo: RepoContext): Promise<number> => 1245 1245 - appviewFallback( 1246 1246 - () => getRepoStarCountFromAppview(repo), 1247 1247 - () => getRepoStarCountFromBacklinks(repo), 1248 1248 - ); 1249 1249 - 1250 1250 - export const createRepoStar = async (agent: OAuthUserAgent, repo: RepoContext): Promise<RecordCreationResult> => { 1251 1251 - const rpc = createAuthRpc(agent); 1252 1252 - const record: ShTangledFeedStar.Main = { 1253 1253 - $type: 'sh.tangled.feed.star', 1254 1254 - subject: { 1255 1255 - $type: 'sh.tangled.feed.star#repo', 1256 1256 - did: repo.repoDid, 1257 1257 - }, 1258 1258 - createdAt: new Date().toISOString(), 1259 1259 - }; 1260 1260 - const result = await ok( 1261 1261 - rpc.post('com.atproto.repo.createRecord', { 1262 1262 - input: { 1263 1263 - repo: agent.sub, 1264 1264 - collection: STAR_COLLECTION, 1265 1265 - record, 1266 1266 - }, 1267 1267 - }), 1268 1268 - ); 1269 1269 - 1270 1270 - return { 1271 1271 - uri: result.uri, 1272 1272 - rkey: parseAtUri(result.uri).rkey, 1273 1273 - }; 1274 1274 - }; 1275 1275 - 1276 1276 - export const deleteRepoStar = async (agent: OAuthUserAgent, rkey: string): Promise<void> => { 1277 1277 - const rpc = createAuthRpc(agent); 1278 1278 - await ok( 1279 1279 - rpc.post('com.atproto.repo.deleteRecord', { 1280 1280 - input: { 1281 1281 - repo: agent.sub, 1282 1282 - collection: STAR_COLLECTION, 1283 1283 - rkey, 1284 1284 - }, 1285 1285 - }), 1286 1286 - ); 1287 1287 - }; 1288 1288 - 1289 1289 - export const getRepo = async (ownerIdentifier: string, repoSlug: string): Promise<RepoContext> => { 1290 1290 - const owner = await resolveActor(ownerIdentifier); 1291 1291 - const all = await listRepoRecords(owner); 1292 1292 - const wanted = repoSlug.trim().toLowerCase(); 1293 1293 - const match = all.find((record) => { 1294 1294 - const name = record.value.name?.trim().toLowerCase(); 1295 1295 - return name === wanted || record.rkey.toLowerCase() === wanted; 1296 1296 - }); 1297 1297 - 1298 1298 - if (!match) { 1299 1299 - throw new Error(`Repository not found: ${ownerIdentifier}/${repoSlug}`); 1300 1300 - } 1301 1301 - 1302 1302 - if (!match.value.repoDid) { 1303 1303 - throw new Error(`Repository is missing repoDid metadata`); 1304 1304 - } 1305 1305 - 1306 1306 - const slug = match.value.name?.trim() || match.rkey; 1307 1307 - 1308 1308 - return { 1309 1309 - owner, 1310 1310 - record: match, 1311 1311 - repoDid: match.value.repoDid, 1312 1312 - slug, 1313 1313 - rkey: match.rkey, 1314 1314 - knot: normalizeServiceUrl(match.value.knot), 1315 1315 - }; 1316 1316 - }; 1317 1317 - 1318 1318 - export const getRepoByDid = async (repoDid: Did): Promise<RepoContext> => { 1319 1319 - const record = await appviewJson<AppviewRecordView<ShTangledRepo.Main>>( 1320 1320 - 'sh.tangled.repo.getRepoByRepoDid', 1321 1321 - { repoDid }, 1322 1322 - ); 1323 1323 - const parsed = parseAtUri(record.uri); 1324 1324 - const owner = await resolveActor(parsed.did); 1325 1325 - const slug = record.value.name?.trim() || parsed.rkey; 1326 1326 - 1327 1327 - if (!record.value.repoDid) { 1328 1328 - throw new Error(`Repository is missing repoDid metadata`); 1329 1329 - } 1330 1330 - 1331 1331 - return { 1332 1332 - owner, 1333 1333 - record: { 1334 1334 - uri: record.uri, 1335 1335 - cid: record.cid ?? '', 1336 1336 - rkey: parsed.rkey, 1337 1337 - value: record.value, 1338 1338 - }, 1339 1339 - repoDid: record.value.repoDid, 1340 1340 - slug, 1341 1341 - rkey: parsed.rkey, 1342 1342 - knot: normalizeServiceUrl(record.value.knot), 1343 1343 - }; 1344 1344 - }; 1345 1345 - 1346 1346 - export const searchRecords = async (options: SearchRecordsOptions): Promise<SearchResponse> => { 1347 1347 - const q = options.q.trim(); 1348 1348 - if (!q) { 1349 1349 - return { hits: [] }; 1350 1350 - } 1351 1351 - 1352 1352 - const response = await appviewJson<AppviewSearchResponse<SearchRecordValue>>( 1353 1353 - 'sh.tangled.search.query', 1354 1354 - { 1355 1355 - q, 1356 1356 - nsid: options.nsid, 1357 1357 - author: options.author, 1358 1358 - repo: options.repo, 1359 1359 - since: options.since, 1360 1360 - until: options.until, 1361 1361 - cursor: options.cursor, 1362 1362 - limit: options.limit, 1363 1363 - }, 1364 1364 - ); 1365 1365 - const hits = await Promise.all( 1366 1366 - response.hits.map(async (hit) => ({ 1367 1367 - ...(await appviewRecordToHydrated(hit)), 1368 1368 - nsid: hit.nsid, 1369 1369 - score: hit.score, 1370 1370 - })), 1371 1371 - ); 1372 1372 - 1373 1373 - return { 1374 1374 - hits, 1375 1375 - cursor: response.cursor ?? undefined, 1376 1376 - }; 1377 1377 - }; 1378 1378 - 1379 1379 - export const getIssueRecord = async (issueUri: ResourceUri): Promise<HydratedRecord<ShTangledRepoIssue.Main>> => { 1380 1380 - const record = await appviewJson<AppviewRecordView<ShTangledRepoIssue.Main>>( 1381 1381 - 'sh.tangled.repo.getIssue', 1382 1382 - { issue: issueUri }, 1383 1383 - ); 1384 1384 - return appviewRecordToHydrated(record); 1385 1385 - }; 1386 1386 - 1387 1387 - export const getPullRecord = async (pullUri: ResourceUri): Promise<HydratedRecord<ShTangledRepoPull.Main>> => { 1388 1388 - const record = await appviewJson<AppviewRecordView<ShTangledRepoPull.Main>>( 1389 1389 - 'sh.tangled.repo.getPull', 1390 1390 - { pull: pullUri }, 1391 1391 - ); 1392 1392 - return appviewRecordToHydrated(record); 1393 1393 - }; 1394 1394 - 1395 1395 - const getRepoTreeFromKnot = async ( 1396 1396 - repo: RepoContext, 1397 1397 - ref: string, 1398 1398 - path = '', 1399 1399 - ): Promise<TreeResponse> => 1400 1400 - (await ok( 1401 1401 - getRpc(repo.knot).get('sh.tangled.repo.tree', { 1402 1402 - params: { 1403 1403 - repo: repo.repoDid, 1404 1404 - ref, 1405 1405 - path, 1406 1406 - }, 1407 1407 - }), 1408 1408 - )) as TreeResponse; 1409 1409 - 1410 1410 - const getRepoBranchesFromKnot = async (repo: RepoContext): Promise<BranchResponse> => 1411 1411 - (await ok( 1412 1412 - getRpc(repo.knot).get('sh.tangled.repo.branches', { 1413 1413 - params: { 1414 1414 - repo: repo.repoDid, 1415 1415 - }, 1416 1416 - as: 'json', 1417 1417 - }), 1418 1418 - )) as BranchResponse; 1419 1419 - 1420 1420 - const branchUpdatedTimestamp = (branch: BranchEntry): number => 1421 1421 - maxTimestamp( 1422 1422 - timestampFromDate(branch.commit?.Committer?.When), 1423 1423 - timestampFromDate(branch.commit?.Author?.When), 1424 1424 - ); 1425 1425 - 1426 1426 - const sortBranchResponseByUpdatedAt = (response: BranchResponse): BranchResponse => ({ 1427 1427 - ...response, 1428 1428 - branches: [...response.branches].sort((left, right) => { 1429 1429 - const updatedDiff = branchUpdatedTimestamp(right) - branchUpdatedTimestamp(left); 1430 1430 - if (updatedDiff !== 0) { 1431 1431 - return updatedDiff; 1432 1432 - } 1433 1433 - 1434 1434 - if (left.is_default !== right.is_default) { 1435 1435 - return left.is_default ? -1 : 1; 1436 1436 - } 1437 1437 - 1438 1438 - return left.reference.name.localeCompare(right.reference.name); 1439 1439 - }), 1440 1440 - }); 1441 1441 - 1442 1442 - const getRepoDefaultBranchFromKnot = async (repo: RepoContext): Promise<DefaultBranchResponse> => 1443 1443 - (await ok( 1444 1444 - getRpc(repo.knot).get('sh.tangled.repo.getDefaultBranch', { 1445 1445 - params: { 1446 1446 - repo: repo.repoDid, 1447 1447 - }, 1448 1448 - }), 1449 1449 - )) as DefaultBranchResponse; 1450 1450 - 1451 1451 - const getRepoTagsFromKnot = async (repo: RepoContext): Promise<TagResponse> => 1452 1452 - (await ok( 1453 1453 - getRpc(repo.knot).get('sh.tangled.repo.tags', { 1454 1454 - params: { 1455 1455 - repo: repo.repoDid, 1456 1456 - }, 1457 1457 - as: 'json', 1458 1458 - }), 1459 1459 - )) as TagResponse; 1460 1460 - 1461 1461 - const getRepoLanguagesFromKnot = async (repo: RepoContext, ref: string): Promise<LanguageResponse> => 1462 1462 - (await ok( 1463 1463 - getRpc(repo.knot).get('sh.tangled.repo.languages', { 1464 1464 - params: { 1465 1465 - repo: repo.repoDid, 1466 1466 - ref, 1467 1467 - }, 1468 1468 - }), 1469 1469 - )) as LanguageResponse; 1470 1470 - 1471 1471 - const getRepoLogFromKnot = async (repo: RepoContext, ref: string): Promise<LogResponse> => 1472 1472 - (await ok( 1473 1473 - getRpc(repo.knot).get('sh.tangled.repo.log', { 1474 1474 - params: { 1475 1475 - repo: repo.repoDid, 1476 1476 - ref, 1477 1477 - limit: 8, 1478 1478 - }, 1479 1479 - as: 'json', 1480 1480 - }), 1481 1481 - )) as LogResponse; 1482 1482 - 1483 1483 - const getRepoBlobFromKnot = async ( 1484 1484 - repo: RepoContext, 1485 1485 - ref: string, 1486 1486 - path: string, 1487 1487 - ): Promise<BlobResponse> => 1488 1488 - (await ok( 1489 1489 - getRpc(repo.knot).get('sh.tangled.repo.blob', { 1490 1490 - params: { 1491 1491 - repo: repo.repoDid, 1492 1492 - ref, 1493 1493 - path, 1494 1494 - }, 1495 1495 - }), 1496 1496 - )) as BlobResponse; 1497 1497 - 1498 1498 - const compareBranchesFromKnot = async ( 1499 1499 - repo: RepoContext, 1500 1500 - rev1: string, 1501 1501 - rev2: string, 1502 1502 - ): Promise<CompareResponse> => 1503 1503 - (await ok( 1504 1504 - getRpc(repo.knot).get('sh.tangled.repo.compare', { 1505 1505 - params: { 1506 1506 - repo: repo.repoDid, 1507 1507 - rev1, 1508 1508 - rev2, 1509 1509 - }, 1510 1510 - as: 'json', 1511 1511 - }), 1512 1512 - )) as CompareResponse; 1513 1513 - 1514 1514 - export const getRepoTree = async ( 1515 1515 - repo: RepoContext, 1516 1516 - ref: string, 1517 1517 - path = '', 1518 1518 - ): Promise<TreeResponse> => 1519 1519 - appviewOptionalKnotRequest( 1520 1520 - () => getRepoViaAppview<TreeResponse>('sh.tangled.repo.tree', repo, { ref, path }), 1521 1521 - () => getRepoTreeFromKnot(repo, ref, path), 1522 1522 - ); 1523 1523 - 1524 1524 - export const getRepoBranches = async (repo: RepoContext): Promise<BranchResponse> => 1525 1525 - appviewOptionalKnotRequest( 1526 1526 - () => getRepoViaAppview<BranchResponse>('sh.tangled.repo.branches', repo), 1527 1527 - () => getRepoBranchesFromKnot(repo), 1528 1528 - ).then(sortBranchResponseByUpdatedAt); 1529 1529 - 1530 1530 - export const getRepoDefaultBranch = async (repo: RepoContext): Promise<DefaultBranchResponse> => 1531 1531 - appviewOptionalKnotRequest( 1532 1532 - () => getRepoViaAppview<DefaultBranchResponse>('sh.tangled.repo.getDefaultBranch', repo), 1533 1533 - () => getRepoDefaultBranchFromKnot(repo), 1534 1534 - ); 1535 1535 - 1536 1536 - export const getRepoTags = async (repo: RepoContext): Promise<TagResponse> => 1537 1537 - appviewOptionalKnotRequest( 1538 1538 - () => getRepoViaAppview<TagResponse>('sh.tangled.repo.tags', repo), 1539 1539 - () => getRepoTagsFromKnot(repo), 1540 1540 - ); 1541 1541 - 1542 1542 - export const getRepoLanguages = async (repo: RepoContext, ref: string): Promise<LanguageResponse> => 1543 1543 - appviewOptionalKnotRequest( 1544 1544 - () => getRepoViaAppview<LanguageResponse>('sh.tangled.repo.languages', repo, { ref }), 1545 1545 - () => getRepoLanguagesFromKnot(repo, ref), 1546 1546 - ); 1547 1547 - 1548 1548 - export const getRepoLog = async (repo: RepoContext, ref: string): Promise<LogResponse> => 1549 1549 - appviewOptionalKnotRequest( 1550 1550 - () => getRepoViaAppview<LogResponse>('sh.tangled.repo.log', repo, { ref, limit: 8 }), 1551 1551 - () => getRepoLogFromKnot(repo, ref), 1552 1552 - ); 1553 1553 - 1554 1554 - export const getRepoBlob = async ( 1555 1555 - repo: RepoContext, 1556 1556 - ref: string, 1557 1557 - path: string, 1558 1558 - ): Promise<BlobResponse> => 1559 1559 - appviewOptionalKnotRequest( 1560 1560 - () => getRepoViaAppview<BlobResponse>('sh.tangled.repo.blob', repo, { ref, path }), 1561 1561 - () => getRepoBlobFromKnot(repo, ref, path), 1562 1562 - ); 1563 1563 - 1564 1564 - export const compareBranches = async ( 1565 1565 - repo: RepoContext, 1566 1566 - rev1: string, 1567 1567 - rev2: string, 1568 1568 - ): Promise<CompareResponse> => 1569 1569 - appviewOptionalKnotRequest( 1570 1570 - () => getRepoViaAppview<CompareResponse>('sh.tangled.repo.compare', repo, { rev1, rev2 }), 1571 1571 - () => compareBranchesFromKnot(repo, rev1, rev2), 1572 1572 - ); 1573 1573 - 1574 1574 - const getBacklinksPage = async ( 1575 1575 - subject: GenericUri, 1576 1576 - source: string, 1577 1577 - limit: number, 1578 1578 - cursor?: string, 1579 1579 - ): Promise<{ records: BacklinkRecordRef[]; cursor?: string; total?: number }> => { 1580 1580 - const constellation = getRpc(CONSTELLATION_SERVICE); 1581 1581 - const page = await ok( 1582 1582 - constellation.get('blue.microcosm.links.getBacklinks', { 1583 1583 - params: { 1584 1584 - subject, 1585 1585 - source, 1586 1586 - limit, 1587 1587 - ...(cursor ? { cursor } : {}), 1588 1588 - }, 1589 1589 - }), 1590 1590 - ); 1591 1591 - 1592 1592 - return page as { records: BacklinkRecordRef[]; cursor?: string; total?: number }; 1593 1593 - }; 1594 1594 - 1595 1595 - const getBacklinkDidsPage = async ( 1596 1596 - subject: GenericUri, 1597 1597 - source: string, 1598 1598 - limit: number, 1599 1599 - cursor?: string, 1600 1600 - ): Promise<{ linking_dids: Did[]; cursor?: string | null; total?: number }> => { 1601 1601 - const constellation = getRpc(CONSTELLATION_SERVICE); 1602 1602 - const page = await ok( 1603 1603 - constellation.get('blue.microcosm.links.getBacklinkDids', { 1604 1604 - params: { 1605 1605 - subject, 1606 1606 - source, 1607 1607 - limit, 1608 1608 - ...(cursor ? { cursor } : {}), 1609 1609 - }, 1610 1610 - }), 1611 1611 - ); 1612 1612 - 1613 1613 - return page as { linking_dids: Did[]; cursor?: string | null; total?: number }; 1614 1614 - }; 1615 1615 - 1616 1616 - const getBacklinkDids = async (subject: GenericUri, source: string): Promise<Did[]> => { 1617 1617 - const dids: Did[] = []; 1618 1618 - let cursor: string | null = null; 1619 1619 - 1620 1620 - do { 1621 1621 - const page = await getBacklinkDidsPage(subject, source, 100, cursor ?? undefined); 1622 1622 - dids.push(...page.linking_dids); 1623 1623 - cursor = page.cursor ?? null; 1624 1624 - } while (cursor); 1625 1625 - 1626 1626 - return dids; 1627 1627 - }; 1628 1628 - 1629 1629 - const findBacklinkRefByDidForSource = async ( 1630 1630 - subject: GenericUri, 1631 1631 - source: string, 1632 1632 - did: Did, 1633 1633 - ): Promise<BacklinkRecordRef | undefined> => { 1634 1634 - let cursor: string | null = null; 1635 1635 - 1636 1636 - do { 1637 1637 - const page = await getBacklinksPage(subject, source, 100, cursor ?? undefined); 1638 1638 - const ref = page.records.find((record) => record.did === did && record.collection === STAR_COLLECTION); 1639 1639 - if (ref) { 1640 1640 - return ref; 1641 1641 - } 1642 1642 - cursor = page.cursor ?? null; 1643 1643 - } while (cursor); 1644 1644 - }; 1645 1645 - 1646 1646 - const findBacklinkRefByDid = async ( 1647 1647 - subject: GenericUri, 1648 1648 - sources: string[], 1649 1649 - did: Did, 1650 1650 - ): Promise<BacklinkRecordRef | undefined> => { 1651 1651 - const refs = await Promise.all(sources.map((source) => findBacklinkRefByDidForSource(subject, source, did))); 1652 1652 - return refs.find((ref) => ref); 1653 1653 - }; 1654 1654 - 1655 1655 - const getBacklinks = async (subject: GenericUri, source: string): Promise<BacklinkRecordRef[]> => { 1656 1656 - const records: BacklinkRecordRef[] = []; 1657 1657 - let cursor: string | null = null; 1658 1658 - const constellation = getRpc(CONSTELLATION_SERVICE); 1659 1659 - 1660 1660 - do { 1661 1661 - const page: { records: BacklinkRecordRef[]; cursor?: string | null } = await ok( 1662 1662 - constellation.get('blue.microcosm.links.getBacklinks', { 1663 1663 - params: { 1664 1664 - subject, 1665 1665 - source, 1666 1666 - limit: 100, 1667 1667 - ...(cursor ? { cursor } : {}), 1668 1668 - }, 1669 1669 - }), 1670 1670 - ); 1671 1671 - records.push(...page.records); 1672 1672 - cursor = page.cursor ?? null; 1673 1673 - } while (cursor); 1674 1674 - 1675 1675 - return records; 1676 1676 - }; 1677 1677 - 1678 1678 - const hydrateRecord = async <T>( 1679 1679 - ref: BacklinkRecordRef | { did: Did; collection: Nsid; rkey: string }, 1680 1680 - ): Promise<HydratedRecord<T>> => { 1681 1681 - const actor = await resolveActor(ref.did); 1682 1682 - const record = await ok( 1683 1683 - getRpc(actor.pds).get('com.atproto.repo.getRecord', { 1684 1684 - params: { 1685 1685 - repo: ref.did, 1686 1686 - collection: ref.collection, 1687 1687 - rkey: ref.rkey, 1688 1688 - }, 1689 1689 - }), 1690 1690 - ); 1691 1691 - 1692 1692 - return { 1693 1693 - author: actor, 1694 1694 - collection: ref.collection, 1695 1695 - rkey: ref.rkey, 1696 1696 - uri: record.uri, 1697 1697 - cid: record.cid, 1698 1698 - value: record.value as T, 1699 1699 - }; 1700 1700 - }; 1701 1701 - 1702 1702 - const fetchRecordValue = async <T>( 1703 1703 - ref: BacklinkRecordRef | { did: Did; collection: Nsid; rkey: string }, 1704 1704 - ): Promise<T> => { 1705 1705 - const actor = await resolveActor(ref.did); 1706 1706 - const record = await ok( 1707 1707 - getRpc(actor.pds).get('com.atproto.repo.getRecord', { 1708 1708 - params: { 1709 1709 - repo: ref.did, 1710 1710 - collection: ref.collection, 1711 1711 - rkey: ref.rkey, 1712 1712 - }, 1713 1713 - }), 1714 1714 - ); 1715 1715 - 1716 1716 - return record.value as T; 1717 1717 - }; 1718 1718 - 1719 1719 - const hydrateBacklinks = async <T>(refs: BacklinkRecordRef[]): Promise<Array<HydratedRecord<T>>> => 1720 1720 - Promise.all(refs.map((ref) => hydrateRecord<T>(ref))); 1721 1721 - 1722 1722 - const backlinkRefToUri = (ref: BacklinkRecordRef): ResourceUri => 1723 1723 - `at://${ref.did}/${ref.collection}/${ref.rkey}` as ResourceUri; 1724 1724 - 1725 1725 - const hydrateBacklinksFromAppview = async <T>( 1726 1726 - refs: BacklinkRecordRef[], 1727 1727 - nsid: string, 1728 1728 - paramName: string, 1729 1729 - ): Promise<Array<HydratedRecord<T>>> => 1730 1730 - appviewFallback( 1731 1731 - async () => { 1732 1732 - const records = await appviewBulkRecords<T>( 1733 1733 - nsid, 1734 1734 - paramName, 1735 1735 - refs.map(backlinkRefToUri), 1736 1736 - ); 1737 1737 - return Promise.all(records.map((record) => appviewRecordToHydrated(record))); 1738 1738 - }, 1739 1739 - () => hydrateBacklinks<T>(refs), 1740 1740 - ); 1741 1741 - 1742 1742 - const hydrateIssueBacklinks = (refs: BacklinkRecordRef[]): Promise<Array<HydratedRecord<ShTangledRepoIssue.Main>>> => 1743 1743 - hydrateBacklinksFromAppview<ShTangledRepoIssue.Main>( 1744 1744 - refs, 1745 1745 - 'sh.tangled.repo.getIssues', 1746 1746 - 'issues', 1747 1747 - ); 1748 1748 - 1749 1749 - const hydratePullBacklinks = (refs: BacklinkRecordRef[]): Promise<Array<HydratedRecord<ShTangledRepoPull.Main>>> => 1750 1750 - hydrateBacklinksFromAppview<ShTangledRepoPull.Main>( 1751 1751 - refs, 1752 1752 - 'sh.tangled.repo.getPulls', 1753 1753 - 'pulls', 1754 1754 - ); 1755 1755 - 1756 1756 - const getOptionalRecord = async <T>( 1757 1757 - actor: ResolvedActor, 1758 1758 - collection: Nsid, 1759 1759 - rkey: string, 1760 1760 - ): Promise<T | null> => { 1761 1761 - try { 1762 1762 - const record = await ok( 1763 1763 - getRpc(actor.pds).get('com.atproto.repo.getRecord', { 1764 1764 - params: { 1765 1765 - repo: actor.did, 1766 1766 - collection, 1767 1767 - rkey, 1768 1768 - }, 1769 1769 - }), 1770 1770 - ); 1771 1771 - 1772 1772 - return record.value as T; 1773 1773 - } catch (cause) { 1774 1774 - if ( 1775 1775 - cause instanceof ClientResponseError && 1776 1776 - (cause.status === 400 || cause.status === 404) 1777 1777 - ) { 1778 1778 - return null; 1779 1779 - } 1780 1780 - 1781 1781 - throw cause; 1782 1782 - } 1783 1783 - }; 1784 1784 - 1785 1785 - const toNumberMap = <T extends { uri: string; rkey: string; value: { createdAt?: string } }>( 1786 1786 - items: T[], 1787 1787 - ): Map<string, number> => { 1788 1788 - const ordered = [...items].sort((left, right) => { 1789 1789 - const leftTime = timestampFromDate(left.value.createdAt); 1790 1790 - const rightTime = timestampFromDate(right.value.createdAt); 1791 1791 - if (leftTime !== rightTime) { 1792 1792 - return leftTime - rightTime; 1793 1793 - } 1794 1794 - 1795 1795 - return left.rkey.localeCompare(right.rkey); 1796 1796 - }); 1797 1797 - 1798 1798 - return new Map(ordered.map((item, index) => [item.uri, index + 1])); 1799 1799 - }; 1800 1800 - 1801 1801 - const normalizeIssueState = (value?: string): 'open' | 'closed' => 1802 1802 - value === 'closed' || value?.endsWith('.closed') ? 'closed' : 'open'; 1803 1803 - 1804 1804 - const normalizePullStatus = (value?: string): 'open' | 'closed' | 'merged' => { 1805 1805 - if (value === 'merged' || value?.endsWith('.merged')) { 1806 1806 - return 'merged'; 1807 1807 - } 1808 1808 - 1809 1809 - if (value === 'closed' || value?.endsWith('.closed')) { 1810 1810 - return 'closed'; 1811 1811 - } 1812 1812 - 1813 1813 - return 'open'; 1814 1814 - }; 1815 1815 - 1816 1816 - const latestBacklinkRefByRkey = (refs: BacklinkRecordRef[]): BacklinkRecordRef | undefined => 1817 1817 - [...refs].sort((left, right) => left.rkey.localeCompare(right.rkey)).at(-1); 1818 1818 - 1819 1819 - const getUniqueBacklinkRefs = async ( 1820 1820 - subject: GenericUri, 1821 1821 - source: string | string[], 1822 1822 - ): Promise<BacklinkRecordRef[]> => 1823 1823 - Array.from( 1824 1824 - new Map( 1825 1825 - ( 1826 1826 - await Promise.all( 1827 1827 - (Array.isArray(source) ? source : [source]).map((entry) => getBacklinks(subject, entry)), 1828 1828 - ) 1829 1829 - ) 1830 1830 - .flat() 1831 1831 - .map((ref) => [`${ref.did}/${ref.collection}/${ref.rkey}`, ref] as const), 1832 1832 - ).values(), 1833 1833 - ); 1834 1834 - 1835 1835 - const getLatestBacklinkTimestamp = async ( 1836 1836 - subject: GenericUri, 1837 1837 - source: string | string[], 1838 1838 - ): Promise<number> => { 1839 1839 - try { 1840 1840 - return timestampFromTid(latestBacklinkRefByRkey(await getUniqueBacklinkRefs(subject, source))?.rkey); 1841 1841 - } catch { 1842 1842 - return 0; 1843 1843 - } 1844 1844 - }; 1845 1845 - 1846 1846 - const BACKLINK_BATCH_LIMIT = 50; 1847 1847 - 1848 1848 - const listBacklinkedRecordsPage = async <T extends { createdAt?: string }, State extends string>( 1849 1849 - subject: GenericUri, 1850 1850 - source: string | string[], 1851 1851 - options: StatefulPageOptions<State>, 1852 1852 - getState: (uri: ResourceUri) => Promise<State>, 1853 1853 - getUpdatedAt?: (record: StatefulHydratedRecord<T, State>) => Promise<number>, 1854 1854 - hydrateRefs: (refs: BacklinkRecordRef[]) => Promise<Array<HydratedRecord<T>>> = hydrateBacklinks<T>, 1855 1855 - ): Promise<PaginatedResult<StatefulHydratedRecord<T, State>>> => { 1856 1856 - if (getUpdatedAt) { 1857 1857 - const hydrated = await hydrateRefs(await getUniqueBacklinkRefs(subject, source)); 1858 1858 - const numbers = toNumberMap(hydrated); 1859 1859 - const states = await Promise.all(hydrated.map((record) => getState(record.uri))); 1860 1860 - const items = hydrated.map((record, index) => ({ 1861 1861 - ...record, 1862 1862 - number: numbers.get(record.uri) ?? index + 1, 1863 1863 - state: states[index], 1864 1864 - })); 1865 1865 - const ordered = await sortStatefulRecordsByUpdatedAt(items, getUpdatedAt); 1866 1866 - 1867 1867 - return paginateStatefulRecords(ordered, options); 1868 1868 - } 1869 1869 - 1870 1870 - const requestedEnd = options.offset + options.limit; 1871 1871 - const items: Array<StatefulHydratedRecord<T, State>> = []; 1872 1872 - const sources = Array.isArray(source) ? source : [source]; 1873 1873 - const batchLimit = Math.min(BACKLINK_BATCH_LIMIT, Math.max(options.limit + 1, 1)); 1874 1874 - const cursors = new Map(sources.map((entry) => [entry, undefined as string | undefined])); 1875 1875 - const exhausted = new Set<string>(); 1876 1876 - const seenRefs = new Set<string>(); 1877 1877 - let matchingSeen = 0; 1878 1878 - let scannedSeen = 0; 1879 1879 - let total: number | undefined; 1880 1880 - 1881 1881 - while (items.length <= options.limit) { 1882 1882 - const pages = await Promise.all( 1883 1883 - sources 1884 1884 - .filter((entry) => !exhausted.has(entry)) 1885 1885 - .map(async (entry) => ({ 1886 1886 - source: entry, 1887 1887 - page: await getBacklinksPage(subject, entry, batchLimit, cursors.get(entry)), 1888 1888 - })), 1889 1889 - ); 1890 1890 - 1891 1891 - if (pages.length === 0) { 1892 1892 - return { items, totalCount: matchingSeen, hasNext: false }; 1893 1893 - } 1894 1894 - 1895 1895 - const refs = pages 1896 1896 - .flatMap(({ source: entry, page }) => { 1897 1897 - total = sources.length === 1 ? page.total ?? total : undefined; 1898 1898 - cursors.set(entry, page.cursor); 1899 1899 - if (!page.cursor) { 1900 1900 - exhausted.add(entry); 1901 1901 - } 1902 1902 - return page.records; 1903 1903 - }) 1904 1904 - .filter((ref) => { 1905 1905 - const key = `${ref.did}/${ref.collection}/${ref.rkey}`; 1906 1906 - if (seenRefs.has(key)) { 1907 1907 - return false; 1908 1908 - } 1909 1909 - seenRefs.add(key); 1910 1910 - return true; 1911 1911 - }); 1912 1912 - 1913 1913 - if (refs.length === 0) { 1914 1914 - if (exhausted.size === sources.length) { 1915 1915 - return { items, totalCount: matchingSeen, hasNext: false }; 1916 1916 - } 1917 1917 - continue; 1918 1918 - } 1919 1919 - 1920 1920 - if (pages.every(({ page }) => page.records.length === 0)) { 1921 1921 - return { items, totalCount: matchingSeen, hasNext: false }; 1922 1922 - } 1923 1923 - 1924 1924 - const hydrated = await hydrateRefs(refs); 1925 1925 - hydrated.sort(sortByCreatedAt).reverse(); 1926 1926 - const states = await Promise.all(hydrated.map((record) => getState(record.uri))); 1927 1927 - 1928 1928 - for (let index = 0; index < hydrated.length; index += 1) { 1929 1929 - const record = hydrated[index]; 1930 1930 - const state = states[index]; 1931 1931 - const number = total ? Math.max(total - scannedSeen, 1) : scannedSeen + 1; 1932 1932 - scannedSeen += 1; 1933 1933 - 1934 1934 - if (state !== options.state) { 1935 1935 - continue; 1936 1936 - } 1937 1937 - 1938 1938 - if (!statefulRecordMatchesQuery(record.value, options.query)) { 1939 1939 - continue; 1940 1940 - } 1941 1941 - 1942 1942 - if (matchingSeen >= options.offset && matchingSeen < requestedEnd + 1) { 1943 1943 - items.push({ ...record, number, state }); 1944 1944 - } 1945 1945 - 1946 1946 - matchingSeen += 1; 1947 1947 - if (matchingSeen > requestedEnd) { 1948 1948 - return { items: items.slice(0, options.limit), hasNext: true }; 1949 1949 - } 1950 1950 - } 1951 1951 - 1952 1952 - if (exhausted.size === sources.length) { 1953 1953 - return { items, totalCount: matchingSeen, hasNext: false }; 1954 1954 - } 1955 1955 - } 1956 1956 - 1957 1957 - return { items: items.slice(0, options.limit), hasNext: true }; 1958 1958 - }; 1959 1959 - 1960 1960 - const getLatestIssueState = async (issueUri: ResourceUri): Promise<'open' | 'closed'> => { 1961 1961 - const refs = await getBacklinks(issueUri, 'sh.tangled.repo.issue.state:issue'); 1962 1962 - if (refs.length === 0) { 1963 1963 - return 'open'; 1964 1964 - } 1965 1965 - 1966 1966 - const state = await fetchRecordValue<ShTangledRepoIssueState.Main>(latestBacklinkRefByRkey(refs)!); 1967 1967 - return normalizeIssueState(state.state); 1968 1968 - }; 1969 1969 - 1970 1970 - const getLatestPullStatus = async (pullUri: ResourceUri): Promise<'open' | 'closed' | 'merged'> => { 1971 1971 - const refs = await getBacklinks(pullUri, 'sh.tangled.repo.pull.status:pull'); 1972 1972 - if (refs.length === 0) { 1973 1973 - return 'open'; 1974 1974 - } 1975 1975 - 1976 1976 - const status = await fetchRecordValue<ShTangledRepoPullStatus.Main>(latestBacklinkRefByRkey(refs)!); 1977 1977 - return normalizePullStatus(status.status); 1978 1978 - }; 1979 1979 - 1980 1980 - const getIssueUpdatedAt = async ( 1981 1981 - issue: HydratedRecord<ShTangledRepoIssue.Main>, 1982 1982 - stateUpdatedAt?: string, 1983 1983 - ): Promise<number> => 1984 1984 - maxTimestamp( 1985 1985 - timestampFromDate(issue.value.createdAt), 1986 1986 - timestampFromTid(issue.rkey), 1987 1987 - timestampFromDate(stateUpdatedAt), 1988 1988 - await getLatestBacklinkTimestamp(issue.uri, [ 1989 1989 - `${ISSUE_COMMENT_COLLECTION}:issue`, 1990 1990 - `${ISSUE_STATE_COLLECTION}:issue`, 1991 1991 - ]), 1992 1992 - ); 1993 1993 - 1994 1994 - const getPullUpdatedAt = async ( 1995 1995 - pull: HydratedRecord<ShTangledRepoPull.Main>, 1996 1996 - stateUpdatedAt?: string, 1997 1997 - ): Promise<number> => 1998 1998 - maxTimestamp( 1999 1999 - timestampFromDate(pull.value.createdAt), 2000 2000 - timestampFromTid(pull.rkey), 2001 2001 - ...pull.value.rounds.map((round) => timestampFromDate(round.createdAt)), 2002 2002 - timestampFromDate(stateUpdatedAt), 2003 2003 - await getLatestBacklinkTimestamp(pull.uri, [ 2004 2004 - `${PULL_COMMENT_COLLECTION}:pull`, 2005 2005 - `${PULL_STATUS_COLLECTION}:pull`, 2006 2006 - ]), 2007 2007 - ); 2008 2008 - 2009 2009 - const listIssuesFromBacklinks = async (repo: RepoContext): Promise<IssueSummary[]> => { 2010 2010 - const refs = await getUniqueBacklinkRefs(repo.repoDid, [ 2011 2011 - 'sh.tangled.repo.issue:repoDid', 2012 2012 - 'sh.tangled.repo.issue:repo', 2013 2013 - ]); 2014 2014 - const issues = await hydrateIssueBacklinks(refs); 2015 2015 - const numbers = toNumberMap(issues); 2016 2016 - const states = await Promise.all(issues.map((issue) => getLatestIssueState(issue.uri))); 2017 2017 - 2018 2018 - const summaries = issues 2019 2019 - .map((issue, index) => ({ 2020 2020 - ...issue, 2021 2021 - number: numbers.get(issue.uri) ?? index + 1, 2022 2022 - state: states[index], 2023 2023 - })); 2024 2024 - 2025 2025 - return sortStatefulRecordsByUpdatedAt(summaries, (issue) => getIssueUpdatedAt(issue)); 2026 2026 - }; 2027 2027 - 2028 2028 - const listIssuesPageFromBacklinks = async ( 2029 2029 - repo: RepoContext, 2030 2030 - options: StatefulPageOptions<'open' | 'closed'>, 2031 2031 - ): Promise<PaginatedResult<IssueSummary>> => 2032 2032 - listBacklinkedRecordsPage<ShTangledRepoIssue.Main, 'open' | 'closed'>( 2033 2033 - repo.repoDid, 2034 2034 - ['sh.tangled.repo.issue:repoDid', 'sh.tangled.repo.issue:repo'], 2035 2035 - options, 2036 2036 - getLatestIssueState, 2037 2037 - (issue) => getIssueUpdatedAt(issue), 2038 2038 - hydrateIssueBacklinks, 2039 2039 - ); 2040 2040 - 2041 2041 - const getIssueCountFromBacklinks = async (repo: RepoContext): Promise<number> => 2042 2042 - (await getUniqueBacklinkRefs(repo.repoDid, [ 2043 2043 - 'sh.tangled.repo.issue:repoDid', 2044 2044 - 'sh.tangled.repo.issue:repo', 2045 2045 - ])).length; 2046 2046 - 2047 2047 - const getIssueFromBacklinks = async (repo: RepoContext, issueRef: string): Promise<IssueDetail> => { 2048 2048 - const issues = await listIssuesFromBacklinks(repo); 2049 2049 - const issue = findNumberedRecord(issues, issueRef); 2050 2050 - if (!issue) { 2051 2051 - throw new Error(`Issue not found`); 2052 2052 - } 2053 2053 - 2054 2054 - const commentRefs = await getBacklinks(issue.uri, 'sh.tangled.repo.issue.comment:issue'); 2055 2055 - const comments = await hydrateBacklinks<ShTangledRepoIssueComment.Main>(commentRefs); 2056 2056 - comments.sort(sortByCreatedAt); 2057 2057 - 2058 2058 - return { 2059 2059 - issue, 2060 2060 - comments, 2061 2061 - }; 2062 2062 - }; 2063 2063 - 2064 2064 - const listPullsFromBacklinks = async (repo: RepoContext): Promise<PullSummary[]> => { 2065 2065 - const refs = await getBacklinks(repo.repoDid, 'sh.tangled.repo.pull:target.repo'); 2066 2066 - const pulls = await hydratePullBacklinks(refs); 2067 2067 - const numbers = toNumberMap(pulls); 2068 2068 - const states = await Promise.all(pulls.map((pull) => getLatestPullStatus(pull.uri))); 2069 2069 - 2070 2070 - const summaries = pulls 2071 2071 - .map((pull, index) => ({ 2072 2072 - ...pull, 2073 2073 - number: numbers.get(pull.uri) ?? index + 1, 2074 2074 - state: states[index], 2075 2075 - })); 2076 2076 - 2077 2077 - return sortStatefulRecordsByUpdatedAt(summaries, (pull) => getPullUpdatedAt(pull)); 2078 2078 - }; 2079 2079 - 2080 2080 - const listPullsPageFromBacklinks = async ( 2081 2081 - repo: RepoContext, 2082 2082 - options: StatefulPageOptions<'open' | 'closed' | 'merged'>, 2083 2083 - ): Promise<PaginatedResult<PullSummary>> => 2084 2084 - listBacklinkedRecordsPage<ShTangledRepoPull.Main, 'open' | 'closed' | 'merged'>( 2085 2085 - repo.repoDid, 2086 2086 - 'sh.tangled.repo.pull:target.repo', 2087 2087 - options, 2088 2088 - getLatestPullStatus, 2089 2089 - (pull) => getPullUpdatedAt(pull), 2090 2090 - hydratePullBacklinks, 2091 2091 - ); 2092 2092 - 2093 2093 - const getPullCountFromBacklinks = async (repo: RepoContext): Promise<number> => 2094 2094 - (await getBacklinksPage(repo.repoDid, 'sh.tangled.repo.pull:target.repo', 1)).total ?? 2095 2095 - (await getBacklinks(repo.repoDid, 'sh.tangled.repo.pull:target.repo')).length; 2096 2096 - 2097 2097 - const getPullFromBacklinks = async (repo: RepoContext, pullRef: string): Promise<PullDetail> => { 2098 2098 - const pulls = await listPullsFromBacklinks(repo); 2099 2099 - const pull = findNumberedRecord(pulls, pullRef); 2100 2100 - if (!pull) { 2101 2101 - throw new Error(`Pull request not found`); 2102 2102 - } 2103 2103 - 2104 2104 - const commentRefs = await getBacklinks(pull.uri, 'sh.tangled.repo.pull.comment:pull'); 2105 2105 - const comments = await hydrateBacklinks<ShTangledRepoPullComment.Main>(commentRefs); 2106 2106 - comments.sort(sortByCreatedAt); 2107 2107 - 2108 2108 - return { 2109 2109 - pull, 2110 2110 - comments, 2111 2111 - }; 2112 2112 - }; 2113 2113 - 2114 2114 - const listIssueCommentsFromAppview = async (issueUri: ResourceUri): Promise<IssueComment[]> => { 2115 2115 - const records = await listAllAppviewRecords<ShTangledRepoIssueComment.Main>( 2116 2116 - 'sh.tangled.repo.issue.listComments', 2117 2117 - issueUri, 2118 2118 - ); 2119 2119 - const comments = await Promise.all(records.map((record) => appviewRecordToHydrated(record))); 2120 2120 - comments.sort(sortByCreatedAt); 2121 2121 - return comments; 2122 2122 - }; 2123 2123 - 2124 2124 - const listPullCommentsFromAppview = async (pullUri: ResourceUri): Promise<PullComment[]> => { 2125 2125 - const records = await listAllAppviewRecords<ShTangledRepoPullComment.Main>( 2126 2126 - 'sh.tangled.repo.pull.listComments', 2127 2127 - pullUri, 2128 2128 - ); 2129 2129 - const comments = await Promise.all(records.map((record) => appviewRecordToHydrated(record))); 2130 2130 - comments.sort(sortByCreatedAt); 2131 2131 - return comments; 2132 2132 - }; 2133 2133 - 2134 2134 - const listIssuesFromAppview = async (repo: RepoContext): Promise<IssueSummary[]> => { 2135 2135 - const records = await listAllAppviewRecords<ShTangledRepoIssue.Main>( 2136 2136 - 'sh.tangled.repo.listIssues', 2137 2137 - repo.repoDid, 2138 2138 - ) as Array<AppviewStatefulRecordView<ShTangledRepoIssue.Main>>; 2139 2139 - const issues = await Promise.all(records.map((record) => appviewRecordToHydrated(record))); 2140 2140 - const numbers = toNumberMap(issues); 2141 2141 - 2142 2142 - const summaries = issues 2143 2143 - .map((issue, index) => ({ 2144 2144 - ...issue, 2145 2145 - number: numbers.get(issue.uri) ?? index + 1, 2146 2146 - state: normalizeIssueState(records[index].state), 2147 2147 - })); 2148 2148 - 2149 2149 - return sortStatefulRecordsByNewestRecord(summaries); 2150 2150 - }; 2151 2151 - 2152 2152 - const listIssuesPageFromAppview = async ( 2153 2153 - repo: RepoContext, 2154 2154 - options: StatefulPageOptions<'open' | 'closed'>, 2155 2155 - ): Promise<PaginatedResult<IssueSummary>> => { 2156 2156 - if (options.query?.trim()) { 2157 2157 - // Appview search can scope to repo/author/nsid. State is still derived 2158 2158 - // from separate state records, so filter state after each search hit. 2159 2159 - return listSearchedStatefulRecordsPage<ShTangledRepoIssue.Main, 'open' | 'closed'>( 2160 2160 - 'sh.tangled.repo.issue', 2161 2161 - repo, 2162 2162 - options, 2163 2163 - getLatestIssueState, 2164 2164 - ); 2165 2165 - } 2166 2166 - 2167 2167 - // Temporary until Bobbin exposes newest-first/reverse repo issue pagination. 2168 2168 - // This loads all appview issue records, but sorts without per-item backlinks. 2169 2169 - return listAppviewStatefulRecordsPage<ShTangledRepoIssue.Main, 'open' | 'closed'>( 2170 2170 - 'sh.tangled.repo.listIssues', 2171 2171 - repo.repoDid, 2172 2172 - options, 2173 2173 - normalizeIssueState, 2174 2174 - options.author ? { author: options.author } : {}, 2175 2175 - (issue) => Promise.resolve(getAppviewRecordSortTimestamp(issue)), 2176 2176 - ); 2177 2177 - }; 2178 2178 - 2179 2179 - const getIssueFromAppview = async (repo: RepoContext, issueRef: string): Promise<IssueDetail> => { 2180 2180 - const directUri = parseDirectRecordRef(issueRef, ISSUE_COLLECTION); 2181 2181 - if (directUri) { 2182 2182 - const issueRecord = await getIssueRecord(directUri); 2183 2183 - if (issueRecord.value.repo !== repo.repoDid) { 2184 2184 - throw new Error(`Issue not found`); 2185 2185 - } 2186 2186 - 2187 2187 - const issue: IssueSummary = { 2188 2188 - ...issueRecord, 2189 2189 - number: 0, 2190 2190 - state: await getLatestIssueState(issueRecord.uri), 2191 2191 - }; 2192 2192 - 2193 2193 - return { 2194 2194 - issue, 2195 2195 - comments: await listIssueCommentsFromAppview(issue.uri), 2196 2196 - }; 2197 2197 - } 2198 2198 - 2199 2199 - const issues = await listIssuesFromAppview(repo); 2200 2200 - const issue = findNumberedRecord(issues, issueRef); 2201 2201 - if (!issue) { 2202 2202 - throw new Error(`Issue not found`); 2203 2203 - } 2204 2204 - 2205 2205 - return { 2206 2206 - issue, 2207 2207 - comments: await listIssueCommentsFromAppview(issue.uri), 2208 2208 - }; 2209 2209 - }; 2210 2210 - 2211 2211 - const listPullsFromAppview = async (repo: RepoContext): Promise<PullSummary[]> => { 2212 2212 - const records = await listAllAppviewRecords<ShTangledRepoPull.Main>( 2213 2213 - 'sh.tangled.repo.listPulls', 2214 2214 - repo.repoDid, 2215 2215 - ) as Array<AppviewStatefulRecordView<ShTangledRepoPull.Main>>; 2216 2216 - const pulls = await Promise.all(records.map((record) => appviewRecordToHydrated(record))); 2217 2217 - const numbers = toNumberMap(pulls); 2218 2218 - 2219 2219 - const summaries = pulls 2220 2220 - .map((pull, index) => ({ 2221 2221 - ...pull, 2222 2222 - number: numbers.get(pull.uri) ?? index + 1, 2223 2223 - state: normalizePullStatus(records[index].state), 2224 2224 - })); 2225 2225 - 2226 2226 - return sortStatefulRecordsByNewestRecord(summaries); 2227 2227 - }; 2228 2228 - 2229 2229 - const listPullsPageFromAppview = async ( 2230 2230 - repo: RepoContext, 2231 2231 - options: StatefulPageOptions<'open' | 'closed' | 'merged'>, 2232 2232 - ): Promise<PaginatedResult<PullSummary>> => { 2233 2233 - if (options.query?.trim()) { 2234 2234 - // Appview search can scope to repo/author/nsid. State is still derived 2235 2235 - // from separate status records, so filter state after each search hit. 2236 2236 - return listSearchedStatefulRecordsPage<ShTangledRepoPull.Main, 'open' | 'closed' | 'merged'>( 2237 2237 - 'sh.tangled.repo.pull', 2238 2238 - repo, 2239 2239 - options, 2240 2240 - getLatestPullStatus, 2241 2241 - ); 2242 2242 - } 2243 2243 - 2244 2244 - // Temporary until Bobbin exposes newest-first/reverse repo pull pagination. 2245 2245 - // This loads all appview pull records, but sorts without per-item backlinks. 2246 2246 - return listAppviewStatefulRecordsPage<ShTangledRepoPull.Main, 'open' | 'closed' | 'merged'>( 2247 2247 - 'sh.tangled.repo.listPulls', 2248 2248 - repo.repoDid, 2249 2249 - options, 2250 2250 - normalizePullStatus, 2251 2251 - options.author ? { author: options.author } : {}, 2252 2252 - (pull) => Promise.resolve(getAppviewRecordSortTimestamp(pull)), 2253 2253 - ); 2254 2254 - }; 2255 2255 - 2256 2256 - const getPullFromAppview = async (repo: RepoContext, pullRef: string): Promise<PullDetail> => { 2257 2257 - const directUri = parseDirectRecordRef(pullRef, PULL_COLLECTION); 2258 2258 - if (directUri) { 2259 2259 - const pullRecord = await getPullRecord(directUri); 2260 2260 - if (pullRecord.value.target.repo !== repo.repoDid) { 2261 2261 - throw new Error(`Pull request not found`); 2262 2262 - } 2263 2263 - 2264 2264 - const pull: PullSummary = { 2265 2265 - ...pullRecord, 2266 2266 - number: 0, 2267 2267 - state: await getLatestPullStatus(pullRecord.uri), 2268 2268 - }; 2269 2269 - 2270 2270 - return { 2271 2271 - pull, 2272 2272 - comments: await listPullCommentsFromAppview(pull.uri), 2273 2273 - }; 2274 2274 - } 2275 2275 - 2276 2276 - const pulls = await listPullsFromAppview(repo); 2277 2277 - const pull = findNumberedRecord(pulls, pullRef); 2278 2278 - if (!pull) { 2279 2279 - throw new Error(`Pull request not found`); 2280 2280 - } 2281 2281 - 2282 2282 - return { 2283 2283 - pull, 2284 2284 - comments: await listPullCommentsFromAppview(pull.uri), 2285 2285 - }; 2286 2286 - }; 2287 2287 - 2288 2288 - export const listIssues = async (repo: RepoContext): Promise<IssueSummary[]> => 2289 2289 - appviewFallback( 2290 2290 - () => listIssuesFromAppview(repo), 2291 2291 - () => listIssuesFromBacklinks(repo), 2292 2292 - ); 2293 2293 - 2294 2294 - export const listIssuesPage = async ( 2295 2295 - repo: RepoContext, 2296 2296 - options: StatefulPageOptions<'open' | 'closed'>, 2297 2297 - ): Promise<PaginatedResult<IssueSummary>> => 2298 2298 - appviewFallback( 2299 2299 - () => listIssuesPageFromAppview(repo, options), 2300 2300 - () => listIssuesPageFromBacklinks(repo, options), 2301 2301 - ); 2302 2302 - 2303 2303 - export const getRepoIssueCount = async (repo: RepoContext): Promise<number> => 2304 2304 - appviewFallback( 2305 2305 - () => getAppviewRecordCount('sh.tangled.repo.countIssues', repo.repoDid), 2306 2306 - () => getIssueCountFromBacklinks(repo), 2307 2307 - ); 2308 2308 - 2309 2309 - export const getIssue = async (repo: RepoContext, issueRef: string): Promise<IssueDetail> => 2310 2310 - appviewFallback( 2311 2311 - () => getIssueFromAppview(repo, issueRef), 2312 2312 - () => getIssueFromBacklinks(repo, issueRef), 2313 2313 - ); 2314 2314 - 2315 2315 - export const listPulls = async (repo: RepoContext): Promise<PullSummary[]> => 2316 2316 - appviewFallback( 2317 2317 - () => listPullsFromAppview(repo), 2318 2318 - () => listPullsFromBacklinks(repo), 2319 2319 - ); 2320 2320 - 2321 2321 - export const listPullsPage = async ( 2322 2322 - repo: RepoContext, 2323 2323 - options: StatefulPageOptions<'open' | 'closed' | 'merged'>, 2324 2324 - ): Promise<PaginatedResult<PullSummary>> => 2325 2325 - appviewFallback( 2326 2326 - () => listPullsPageFromAppview(repo, options), 2327 2327 - () => listPullsPageFromBacklinks(repo, options), 2328 2328 - ); 2329 2329 - 2330 2330 - export const getRepoPullCount = async (repo: RepoContext): Promise<number> => 2331 2331 - appviewFallback( 2332 2332 - () => getAppviewRecordCount('sh.tangled.repo.countPulls', repo.repoDid), 2333 2333 - () => getPullCountFromBacklinks(repo), 2334 2334 - ); 2335 2335 - 2336 2336 - export const getPull = async (repo: RepoContext, pullRef: string): Promise<PullDetail> => 2337 2337 - appviewFallback( 2338 2338 - () => getPullFromAppview(repo, pullRef), 2339 2339 - () => getPullFromBacklinks(repo, pullRef), 2340 2340 - ); 2341 2341 - 2342 2342 - export const fetchPullRoundPatch = async ( 2343 2343 - pull: PullSummary, 2344 2344 - roundIndex: number, 2345 2345 - ): Promise<string> => { 2346 2346 - const round = pull.value.rounds[roundIndex]; 2347 2347 - if (!round) { 2348 2348 - throw new Error(`Round ${roundIndex + 1} not found`); 2349 2349 - } 2350 2350 - 2351 2351 - const cid = extractBlobCid(round.patchBlob); 2352 2352 - if (!cid) { 2353 2353 - throw new Error(`Missing patch blob CID`); 2354 2354 - } 2355 2355 - 2356 2356 - const author = pull.author.pds ? pull.author : await resolveActor(pull.author.did); 2357 2357 - const rpc = getRpc(author.pds); 2358 2358 - const bytes = await ok( 2359 2359 - rpc.get('com.atproto.sync.getBlob', { 2360 2360 - params: { 2361 2361 - did: author.did, 2362 2362 - cid, 2363 2363 - }, 2364 2364 - as: 'bytes', 2365 2365 - }), 2366 2366 - ); 2367 2367 - 2368 2368 - return strFromU8(gunzipSync(bytes)); 2369 2369 - }; 2370 2370 - 2371 2371 - export const createIssue = async ( 2372 2372 - agent: OAuthUserAgent, 2373 2373 - repo: RepoContext, 2374 2374 - input: CreateIssueInput, 2375 2375 - ): Promise<RecordCreationResult> => { 2376 2376 - const rpc = createAuthRpc(agent); 2377 2377 - const record: ShTangledRepoIssue.Main = { 2378 2378 - $type: 'sh.tangled.repo.issue', 2379 2379 - repo: repo.repoDid, 2380 2380 - title: input.title.trim(), 2381 2381 - body: optionalString(input.body), 2382 2382 - createdAt: new Date().toISOString(), 2383 2383 - mentions: extractDids(input.body), 2384 2384 - references: extractAtUris(input.body), 2385 2385 - }; 2386 2386 - 2387 2387 - const result = await ok( 2388 2388 - rpc.post('com.atproto.repo.createRecord', { 2389 2389 - input: { 2390 2390 - repo: agent.sub, 2391 2391 - collection: ISSUE_COLLECTION, 2392 2392 - record, 2393 2393 - }, 2394 2394 - }), 2395 2395 - ); 2396 2396 - 2397 2397 - return { 2398 2398 - uri: result.uri, 2399 2399 - rkey: parseAtUri(result.uri).rkey, 2400 2400 - }; 2401 2401 - }; 2402 2402 - 2403 2403 - export const createIssueComment = async ( 2404 2404 - agent: OAuthUserAgent, 2405 2405 - issueUri: ResourceUri, 2406 2406 - body: string, 2407 2407 - replyTo?: ResourceUri, 2408 2408 - ): Promise<RecordCreationResult> => { 2409 2409 - const rpc = createAuthRpc(agent); 2410 2410 - const record: ShTangledRepoIssueComment.Main = { 2411 2411 - $type: 'sh.tangled.repo.issue.comment', 2412 2412 - issue: issueUri, 2413 2413 - body: body.trim(), 2414 2414 - createdAt: new Date().toISOString(), 2415 2415 - mentions: extractDids(body), 2416 2416 - references: extractAtUris(body), 2417 2417 - ...(replyTo ? { replyTo } : {}), 2418 2418 - }; 2419 2419 - 2420 2420 - const result = await ok( 2421 2421 - rpc.post('com.atproto.repo.createRecord', { 2422 2422 - input: { 2423 2423 - repo: agent.sub, 2424 2424 - collection: ISSUE_COMMENT_COLLECTION, 2425 2425 - record, 2426 2426 - }, 2427 2427 - }), 2428 2428 - ); 2429 2429 - 2430 2430 - return { 2431 2431 - uri: result.uri, 2432 2432 - rkey: parseAtUri(result.uri).rkey, 2433 2433 - }; 2434 2434 - }; 2435 2435 - 2436 2436 - export const setIssueState = async ( 2437 2437 - agent: OAuthUserAgent, 2438 2438 - issueUri: ResourceUri, 2439 2439 - state: 'open' | 'closed', 2440 2440 - ): Promise<RecordCreationResult> => { 2441 2441 - const rpc = createAuthRpc(agent); 2442 2442 - const record: ShTangledRepoIssueState.Main = { 2443 2443 - $type: 'sh.tangled.repo.issue.state', 2444 2444 - issue: issueUri, 2445 2445 - state: 2446 2446 - state === 'closed' 2447 2447 - ? 'sh.tangled.repo.issue.state.closed' 2448 2448 - : 'sh.tangled.repo.issue.state.open', 2449 2449 - }; 2450 2450 - 2451 2451 - const result = await ok( 2452 2452 - rpc.post('com.atproto.repo.createRecord', { 2453 2453 - input: { 2454 2454 - repo: agent.sub, 2455 2455 - collection: ISSUE_STATE_COLLECTION, 2456 2456 - record, 2457 2457 - }, 2458 2458 - }), 2459 2459 - ); 2460 2460 - 2461 2461 - return { 2462 2462 - uri: result.uri, 2463 2463 - rkey: parseAtUri(result.uri).rkey, 2464 2464 - }; 2465 2465 - }; 2466 2466 - 2467 2467 - export const createPull = async ( 2468 2468 - agent: OAuthUserAgent, 2469 2469 - repo: RepoContext, 2470 2470 - input: CreatePullInput, 2471 2471 - ): Promise<RecordCreationResult> => { 2472 2472 - const rpc = createAuthRpc(agent); 2473 2473 - const patchBytes = new Uint8Array(gzipSync(strToU8(input.patch))); 2474 2474 - const patchBlob = new Blob([patchBytes.buffer], { 2475 2475 - type: 'application/gzip', 2476 2476 - }); 2477 2477 - 2478 2478 - const uploaded = await ok( 2479 2479 - rpc.post('com.atproto.repo.uploadBlob', { 2480 2480 - input: patchBlob, 2481 2481 - }), 2482 2482 - ); 2483 2483 - 2484 2484 - const record: ShTangledRepoPull.Main = { 2485 2485 - $type: 'sh.tangled.repo.pull', 2486 2486 - title: input.title.trim(), 2487 2487 - body: optionalString(input.body), 2488 2488 - target: { 2489 2489 - repo: repo.repoDid, 2490 2490 - branch: input.targetBranch, 2491 2491 - }, 2492 2492 - source: { 2493 2493 - branch: input.sourceBranch, 2494 2494 - }, 2495 2495 - rounds: [ 2496 2496 - { 2497 2497 - createdAt: new Date().toISOString(), 2498 2498 - patchBlob: uploaded.blob, 2499 2499 - }, 2500 2500 - ], 2501 2501 - createdAt: new Date().toISOString(), 2502 2502 - mentions: extractDids(input.body), 2503 2503 - references: extractAtUris(input.body), 2504 2504 - }; 2505 2505 - 2506 2506 - const result = await ok( 2507 2507 - rpc.post('com.atproto.repo.createRecord', { 2508 2508 - input: { 2509 2509 - repo: agent.sub, 2510 2510 - collection: PULL_COLLECTION, 2511 2511 - record, 2512 2512 - }, 2513 2513 - }), 2514 2514 - ); 2515 2515 - 2516 2516 - return { 2517 2517 - uri: result.uri, 2518 2518 - rkey: parseAtUri(result.uri).rkey, 2519 2519 - }; 2520 2520 - }; 2521 2521 - 2522 2522 - export const createPullComment = async ( 2523 2523 - agent: OAuthUserAgent, 2524 2524 - pullUri: ResourceUri, 2525 2525 - body: string, 2526 2526 - ): Promise<RecordCreationResult> => { 2527 2527 - const rpc = createAuthRpc(agent); 2528 2528 - const record: ShTangledRepoPullComment.Main = { 2529 2529 - $type: 'sh.tangled.repo.pull.comment', 2530 2530 - pull: pullUri, 2531 2531 - body: body.trim(), 2532 2532 - createdAt: new Date().toISOString(), 2533 2533 - mentions: extractDids(body), 2534 2534 - references: extractAtUris(body), 2535 2535 - }; 2536 2536 - 2537 2537 - const result = await ok( 2538 2538 - rpc.post('com.atproto.repo.createRecord', { 2539 2539 - input: { 2540 2540 - repo: agent.sub, 2541 2541 - collection: PULL_COMMENT_COLLECTION, 2542 2542 - record, 2543 2543 - }, 2544 2544 - }), 2545 2545 - ); 2546 2546 - 2547 2547 - return { 2548 2548 - uri: result.uri, 2549 2549 - rkey: parseAtUri(result.uri).rkey, 2550 2550 - }; 2551 2551 - }; 2552 2552 - 2553 2553 - export const setPullStatus = async ( 2554 2554 - agent: OAuthUserAgent, 2555 2555 - pullUri: ResourceUri, 2556 2556 - status: 'open' | 'closed' | 'merged', 2557 2557 - ): Promise<RecordCreationResult> => { 2558 2558 - const rpc = createAuthRpc(agent); 2559 2559 - const record: ShTangledRepoPullStatus.Main = { 2560 2560 - $type: 'sh.tangled.repo.pull.status', 2561 2561 - pull: pullUri, 2562 2562 - status: 2563 2563 - status === 'merged' 2564 2564 - ? 'sh.tangled.repo.pull.status.merged' 2565 2565 - : status === 'closed' 2566 2566 - ? 'sh.tangled.repo.pull.status.closed' 2567 2567 - : 'sh.tangled.repo.pull.status.open', 2568 2568 - }; 2569 2569 - 2570 2570 - const result = await ok( 2571 2571 - rpc.post('com.atproto.repo.createRecord', { 2572 2572 - input: { 2573 2573 - repo: agent.sub, 2574 2574 - collection: PULL_STATUS_COLLECTION, 2575 2575 - record, 2576 2576 - }, 2577 2577 - }), 2578 2578 - ); 2579 2579 - 2580 2580 - return { 2581 2581 - uri: result.uri, 2582 2582 - rkey: parseAtUri(result.uri).rkey, 2583 2583 - }; 2584 2584 - }; 2585 2585 - 2586 2586 - export const decodeBlobText = (blob: BlobResponse): string => { 2587 2587 - if (!blob.content) { 2588 2588 - return ''; 2589 2589 - } 2590 2590 - 2591 2591 - if (blob.encoding === 'base64') { 2592 2592 - const buffer = Uint8Array.from(atob(blob.content), (char) => char.charCodeAt(0)); 2593 2593 - return new TextDecoder().decode(buffer); 2594 2594 - } 2595 2595 - 2596 2596 - return blob.content; 2597 2597 - }; 2598 2598 - 2599 2599 - export const buildBlobDataUrl = (blob: BlobResponse): string | null => { 2600 2600 - if (!blob.content || !blob.mimeType) { 2601 2601 - return null; 2602 2602 - } 2603 2603 - 2604 2604 - if (blob.encoding === 'base64') { 2605 2605 - return `data:${blob.mimeType};base64,${blob.content}`; 2606 2606 - } 2607 2607 - 2608 2608 - return `data:${blob.mimeType};charset=utf-8,${encodeURIComponent(blob.content)}`; 2609 2609 - }; 2610 2610 - 2611 2611 - const getActorProfileFromAppview = async (actor: ResolvedActor): Promise<ShTangledActorProfile.Main | null> => { 2612 2612 - const profile = await appviewJson<AppviewRecordView<ShTangledActorProfile.Main>>( 2613 2613 - 'sh.tangled.actor.getProfile', 2614 2614 - { 2615 2615 - actor: `at://${actor.did}/${ACTOR_PROFILE_COLLECTION}/self`, 2616 2616 - }, 2617 2617 - ); 2618 2618 - return profile.value; 2619 2619 - }; 2620 2620 - 2621 2621 - export const resolveAvatarUrl = async (identifier: string): Promise<string | null> => { 2622 2622 - const actor = await resolveActor(identifier); 2623 2623 - let tangledProfile: ShTangledActorProfile.Main | null; 2624 2624 - try { 2625 2625 - tangledProfile = await getActorProfileFromAppview(actor); 2626 2626 - } catch (cause) { 2627 2627 - if (!(cause instanceof AppviewUnavailableError)) { 2628 2628 - throw cause; 2629 2629 - } 2630 2630 - 2631 2631 - tangledProfile = await getOptionalRecord<ShTangledActorProfile.Main>( 2632 2632 - actor, 2633 2633 - ACTOR_PROFILE_COLLECTION, 2634 2634 - 'self', 2635 2635 - ); 2636 2636 - } 2637 2637 - const tangledCid = extractBlobCid(tangledProfile?.avatar); 2638 2638 - if (tangledCid) { 2639 2639 - return buildPdsBlobUrl(actor.pds, actor.did, tangledCid); 2640 2640 - } 2641 2641 - 2642 2642 - const bskyProfile = await getOptionalRecord<ProfileWithAvatar>( 2643 2643 - actor, 2644 2644 - APP_BSKY_PROFILE_COLLECTION, 2645 2645 - 'self', 2646 2646 - ); 2647 2647 - const bskyCid = extractBlobCid(bskyProfile?.avatar); 2648 2648 - if (bskyCid) { 2649 2649 - return buildPdsBlobUrl(actor.pds, actor.did, bskyCid); 2650 2650 - } 2651 2651 - 2652 2652 - return null; 2653 2653 - }; 2654 2654 - 2655 2655 - export const parseAtUri = (uri: string): { did: Did; collection: Nsid; rkey: string } => { 2656 2656 - if (!uri.startsWith('at://')) { 2657 2657 - throw new Error(`Invalid at-uri: ${uri}`); 2658 2658 - } 2659 2659 - 2660 2660 - const parts = uri.slice(5).split('/'); 2661 2661 - const [did, collection, ...rkey] = parts; 2662 2662 - return { 2663 2663 - did: asDid(did), 2664 2664 - collection: asNsid(collection), 2665 2665 - rkey: rkey.join('/'), 2666 2666 - }; 2667 2667 - }; 2668 2668 - 2669 2669 - const parseDirectRecordRef = (ref: string, collection: Nsid): ResourceUri | null => { 2670 2670 - let normalized = ref.trim(); 2671 2671 - try { 2672 2672 - normalized = decodeURIComponent(normalized); 2673 2673 - } catch { 2674 2674 - // Keep the original route param when it is not percent-encoded. 2675 2675 - } 2676 2676 - 2677 2677 - if (!normalized.startsWith('at://')) { 2678 2678 - return null; 2679 2679 - } 2680 2680 - 2681 2681 - try { 2682 2682 - return parseAtUri(normalized).collection === collection ? (normalized as ResourceUri) : null; 2683 2683 - } catch { 2684 2684 - return null; 2685 2685 - } 2686 2686 - }; 2687 2687 - 2688 2688 - export const extractBlobCid = (blob: unknown): string | null => { 2689 2689 - if (!blob || typeof blob !== 'object') { 2690 2690 - return null; 2691 2691 - } 2692 2692 - 2693 2693 - const value = blob as Record<string, unknown>; 2694 2694 - const ref = value.ref; 2695 2695 - 2696 2696 - if (typeof ref === 'string') { 2697 2697 - return ref; 2698 2698 - } 2699 2699 - 2700 2700 - if (ref && typeof ref === 'object') { 2701 2701 - const maybeLink = (ref as Record<string, unknown>).$link; 2702 2702 - if (typeof maybeLink === 'string') { 2703 2703 - return maybeLink; 2704 2704 - } 2705 2705 - } 2706 2706 - 2707 2707 - const maybeCid = value.cid; 2708 2708 - return typeof maybeCid === 'string' ? maybeCid : null; 2709 2709 - }; 2710 2710 - 2711 2711 - const findNumberedRecord = <T extends { number: number; rkey: string; uri: string }>( 2712 2712 - records: T[], 2713 2713 - ref: string, 2714 2714 - ): T | undefined => { 2715 2715 - const trimmed = ref.trim(); 2716 2716 - if (/^\d+$/.test(trimmed)) { 2717 2717 - const number = Number(trimmed); 2718 2718 - return records.find((record) => record.number === number); 2719 2719 - } 2720 2720 - 2721 2721 - return records.find( 2722 2722 - (record) => 2723 2723 - record.rkey === trimmed || 2724 2724 - record.uri === trimmed || 2725 2725 - parseAtUri(record.uri).rkey === trimmed, 2726 2726 - ); 2727 2727 - }; 2728 2728 - 2729 2729 - const optionalString = (value: string): string | undefined => { 2730 2730 - const trimmed = value.trim(); 2731 2731 - return trimmed.length > 0 ? trimmed : undefined; 2732 2732 - }; 2733 2733 - 2734 2734 - const uniq = <T extends string>(values: T[]): T[] | undefined => { 2735 2735 - if (values.length === 0) { 2736 2736 - return undefined; 2737 2737 - } 2738 2738 - 2739 2739 - return [...new Set(values)]; 2740 2740 - }; 2741 2741 - 2742 2742 - const extractDids = (input: string): Did[] | undefined => 2743 2743 - uniq( 2744 2744 - Array.from( 2745 2745 - input.matchAll(/\bdid:[a-z0-9]+:[A-Za-z0-9._:%-]+\b/gi), 2746 2746 - (match) => match[0] as Did, 2747 2747 - ), 2748 2748 - ); 2749 2749 - 2750 2750 - const extractAtUris = (input: string): ResourceUri[] | undefined => 2751 2751 - uniq( 2752 2752 - Array.from( 2753 2753 - input.matchAll(/\bat:\/\/[^\s<>()]+/gi), 2754 2754 - (match) => match[0] as ResourceUri, 2755 2755 - ), 2756 2756 - ); 2757 2757 - 2758 2758 - const sortByCreatedAt = <T extends { value: { createdAt?: string } }>(left: T, right: T): number => 2759 2759 - new Date(left.value.createdAt ?? 0).getTime() - new Date(right.value.createdAt ?? 0).getTime(); 2760 2760 - 2761 2761 - const asActorIdentifier = (value: string): ActorIdentifier => value as ActorIdentifier; 2762 2762 - 2763 2763 - const asDid = (value: string): Did => { 2764 2764 - if (!value.startsWith('did:')) { 2765 2765 - throw new Error(`Invalid DID: ${value}`); 2766 2766 - } 2767 2767 - 2768 2768 - return value as Did; 2769 2769 - }; 2770 2770 - 2771 2771 - const asNsid = (value: string): Nsid => { 2772 2772 - if (value.split('.').length < 3) { 2773 2773 - throw new Error(`Invalid NSID: ${value}`); 2774 2774 - } 2775 2775 - 2776 2776 - return value as Nsid; 2777 2777 - }; 2778 2778 - 2779 2779 - const buildPdsBlobUrl = (pds: string, did: Did, cid: string): string => { 2780 2780 - const url = new URL('/xrpc/com.atproto.sync.getBlob', normalizeServiceUrl(pds)); 2781 2781 - url.searchParams.set('did', did); 2782 2782 - url.searchParams.set('cid', cid); 2783 2783 - return url.toString(); 2784 2784 - };

+93

src/lib/api/hydration.ts

Reviewed

··· 1 1 + import { ok } from '@atcute/client'; 2 2 + import type { Did, Nsid, ResourceUri } from '@atcute/lexicons/syntax'; 3 3 + 4 4 + import { 5 5 + appviewBulkRecords, 6 6 + appviewFallback, 7 7 + type AppviewRecordView, 8 8 + } from './appview'; 9 9 + import { getRpc } from './client'; 10 10 + import { 11 11 + type BacklinkRecordRef, 12 12 + type HydratedRecord, 13 13 + parseAtUri, 14 14 + } from './records'; 15 15 + import { resolveActor, resolveActorForDisplay } from './identity'; 16 16 + 17 17 + export const appviewRecordToHydrated = async <T>(record: AppviewRecordView<T>): Promise<HydratedRecord<T>> => { 18 18 + const parsed = parseAtUri(record.uri); 19 19 + const author = await resolveActorForDisplay(parsed.did); 20 20 + 21 21 + return { 22 22 + author, 23 23 + collection: parsed.collection, 24 24 + rkey: parsed.rkey, 25 25 + uri: record.uri, 26 26 + cid: record.cid ?? undefined, 27 27 + value: record.value, 28 28 + }; 29 29 + }; 30 30 + 31 31 + export const hydrateRecord = async <T>( 32 32 + ref: BacklinkRecordRef | { did: Did; collection: Nsid; rkey: string }, 33 33 + ): Promise<HydratedRecord<T>> => { 34 34 + const actor = await resolveActor(ref.did); 35 35 + const record = await ok( 36 36 + getRpc(actor.pds).get('com.atproto.repo.getRecord', { 37 37 + params: { 38 38 + repo: ref.did, 39 39 + collection: ref.collection, 40 40 + rkey: ref.rkey, 41 41 + }, 42 42 + }), 43 43 + ); 44 44 + 45 45 + return { 46 46 + author: actor, 47 47 + collection: ref.collection, 48 48 + rkey: ref.rkey, 49 49 + uri: record.uri, 50 50 + cid: record.cid, 51 51 + value: record.value as T, 52 52 + }; 53 53 + }; 54 54 + 55 55 + export const fetchRecordValue = async <T>( 56 56 + ref: BacklinkRecordRef | { did: Did; collection: Nsid; rkey: string }, 57 57 + ): Promise<T> => { 58 58 + const actor = await resolveActor(ref.did); 59 59 + const record = await ok( 60 60 + getRpc(actor.pds).get('com.atproto.repo.getRecord', { 61 61 + params: { 62 62 + repo: ref.did, 63 63 + collection: ref.collection, 64 64 + rkey: ref.rkey, 65 65 + }, 66 66 + }), 67 67 + ); 68 68 + 69 69 + return record.value as T; 70 70 + }; 71 71 + 72 72 + export const hydrateBacklinks = async <T>(refs: BacklinkRecordRef[]): Promise<Array<HydratedRecord<T>>> => 73 73 + Promise.all(refs.map((ref) => hydrateRecord<T>(ref))); 74 74 + 75 75 + const backlinkRefToUri = (ref: BacklinkRecordRef): ResourceUri => 76 76 + `at://${ref.did}/${ref.collection}/${ref.rkey}` as ResourceUri; 77 77 + 78 78 + export const hydrateBacklinksFromAppview = async <T>( 79 79 + refs: BacklinkRecordRef[], 80 80 + nsid: string, 81 81 + paramName: string, 82 82 + ): Promise<Array<HydratedRecord<T>>> => 83 83 + appviewFallback( 84 84 + async () => { 85 85 + const records = await appviewBulkRecords<T>( 86 86 + nsid, 87 87 + paramName, 88 88 + refs.map(backlinkRefToUri), 89 89 + ); 90 90 + return Promise.all(records.map((record) => appviewRecordToHydrated(record))); 91 91 + }, 92 92 + () => hydrateBacklinks<T>(refs), 93 93 + );

+164 -7

src/lib/api/identity.ts

Reviewed

··· 1 1 - export { 2 2 - clearApiCaches, 3 3 - createAuthRpc, 4 4 - identityResolver, 5 5 - resolveActor, 6 6 - resolveAvatarUrl, 7 7 - } from './core'; 1 1 + import { ok } from '@atcute/client'; 2 2 + import { 3 3 + type ActorResolver, 4 4 + type ResolveActorOptions, 5 5 + type ResolvedActor, 6 6 + } from '@atcute/identity-resolver'; 7 7 + import type { 8 8 + ActorIdentifier, 9 9 + Did, 10 10 + Handle, 11 11 + } from '@atcute/lexicons/syntax'; 12 12 + import { ShTangledActorProfile } from '@atcute/tangled'; 13 13 + 14 14 + import { 15 15 + APP_BSKY_PROFILE_COLLECTION, 16 16 + ACTOR_PROFILE_COLLECTION, 17 17 + SLINGSHOT_SERVICE, 18 18 + } from './constants'; 19 19 + import { appviewJson, AppviewUnavailableError, type AppviewRecordView } from './appview'; 20 20 + import { clearAppviewStatefulCursorCache } from './appview-cache'; 21 21 + import { 22 22 + createAuthRpc as createClientAuthRpc, 23 23 + getRpc, 24 24 + normalizeServiceUrl, 25 25 + } from './client'; 26 26 + import { 27 27 + extractBlobCid, 28 28 + getOptionalRecord, 29 29 + } from './records'; 30 30 + 31 31 + interface MiniDocResponse { 32 32 + did: Did; 33 33 + handle: Handle; 34 34 + pds: string; 35 35 + } 36 36 + 37 37 + interface ProfileWithAvatar { 38 38 + avatar?: unknown; 39 39 + } 40 40 + 41 41 + const actorCache = new Map<string, Promise<ResolvedActor>>(); 42 42 + 43 43 + class AppviewFirstActorResolver implements ActorResolver { 44 44 + async resolve(actor: ActorIdentifier, options?: ResolveActorOptions): Promise<ResolvedActor> { 45 45 + try { 46 46 + return normalizeResolvedActor( 47 47 + await appviewJson<MiniDocResponse>( 48 48 + 'com.bad-example.identity.resolveMiniDoc', 49 49 + { identifier: actor }, 50 50 + options?.signal, 51 51 + ), 52 52 + ); 53 53 + } catch (cause) { 54 54 + if (!(cause instanceof AppviewUnavailableError)) { 55 55 + throw cause; 56 56 + } 57 57 + 58 58 + const resolved = await ok( 59 59 + getRpc(SLINGSHOT_SERVICE).get('blue.microcosm.identity.resolveMiniDoc', { 60 60 + params: { 61 61 + identifier: actor, 62 62 + }, 63 63 + signal: options?.signal, 64 64 + }), 65 65 + ); 66 66 + 67 67 + return normalizeResolvedActor(resolved); 68 68 + } 69 69 + } 70 70 + } 71 71 + 72 72 + export const identityResolver = new AppviewFirstActorResolver(); 73 73 + 74 74 + export const clearApiCaches = () => { 75 75 + actorCache.clear(); 76 76 + clearAppviewStatefulCursorCache(); 77 77 + }; 78 78 + 79 79 + export const createAuthRpc = createClientAuthRpc; 80 80 + 81 81 + export const resolveActor = async (identifier: string): Promise<ResolvedActor> => { 82 82 + const key = identifier.toLowerCase(); 83 83 + const cached = actorCache.get(key); 84 84 + if (cached) { 85 85 + return cached; 86 86 + } 87 87 + 88 88 + const promise = identityResolver.resolve(asActorIdentifier(identifier)); 89 89 + actorCache.set(key, promise); 90 90 + return promise; 91 91 + }; 92 92 + 93 93 + export const resolveActorForDisplay = async (did: Did): Promise<ResolvedActor> => { 94 94 + try { 95 95 + return await resolveActor(did); 96 96 + } catch { 97 97 + return unresolvedActorFromDid(did); 98 98 + } 99 99 + }; 100 100 + 101 101 + const normalizeResolvedActor = (resolved: MiniDocResponse): ResolvedActor => ({ 102 102 + did: resolved.did, 103 103 + handle: resolved.handle, 104 104 + pds: normalizeServiceUrl(resolved.pds), 105 105 + }); 106 106 + 107 107 + const unresolvedActorFromDid = (did: Did): ResolvedActor => ({ 108 108 + did, 109 109 + handle: did as unknown as Handle, 110 110 + pds: '', 111 111 + }); 112 112 + 113 113 + const getActorProfileFromAppview = async (actor: ResolvedActor): Promise<ShTangledActorProfile.Main | null> => { 114 114 + const profile = await appviewJson<AppviewRecordView<ShTangledActorProfile.Main>>( 115 115 + 'sh.tangled.actor.getProfile', 116 116 + { 117 117 + actor: `at://${actor.did}/${ACTOR_PROFILE_COLLECTION}/self`, 118 118 + }, 119 119 + ); 120 120 + return profile.value; 121 121 + }; 122 122 + 123 123 + export const resolveAvatarUrl = async (identifier: string): Promise<string | null> => { 124 124 + const actor = await resolveActor(identifier); 125 125 + let tangledProfile: ShTangledActorProfile.Main | null; 126 126 + try { 127 127 + tangledProfile = await getActorProfileFromAppview(actor); 128 128 + } catch (cause) { 129 129 + if (!(cause instanceof AppviewUnavailableError)) { 130 130 + throw cause; 131 131 + } 132 132 + 133 133 + tangledProfile = await getOptionalRecord<ShTangledActorProfile.Main>( 134 134 + actor, 135 135 + ACTOR_PROFILE_COLLECTION, 136 136 + 'self', 137 137 + ); 138 138 + } 139 139 + const tangledCid = extractBlobCid(tangledProfile?.avatar); 140 140 + if (tangledCid) { 141 141 + return buildPdsBlobUrl(actor.pds, actor.did, tangledCid); 142 142 + } 143 143 + 144 144 + const bskyProfile = await getOptionalRecord<ProfileWithAvatar>( 145 145 + actor, 146 146 + APP_BSKY_PROFILE_COLLECTION, 147 147 + 'self', 148 148 + ); 149 149 + const bskyCid = extractBlobCid(bskyProfile?.avatar); 150 150 + if (bskyCid) { 151 151 + return buildPdsBlobUrl(actor.pds, actor.did, bskyCid); 152 152 + } 153 153 + 154 154 + return null; 155 155 + }; 156 156 + 157 157 + const asActorIdentifier = (value: string): ActorIdentifier => value as ActorIdentifier; 158 158 + 159 159 + const buildPdsBlobUrl = (pds: string, did: Did, cid: string): string => { 160 160 + const url = new URL('/xrpc/com.atproto.sync.getBlob', normalizeServiceUrl(pds)); 161 161 + url.searchParams.set('did', did); 162 162 + url.searchParams.set('cid', cid); 163 163 + return url.toString(); 164 164 + };

+385 -16

src/lib/api/issues.ts

Reviewed

··· 1 1 - export { 2 2 - createIssue, 3 3 - createIssueComment, 4 4 - getIssue, 5 5 - getIssueRecord, 6 6 - getRepoIssueCount, 7 7 - listIssues, 8 8 - listIssuesPage, 9 9 - setIssueState, 10 10 - } from './core'; 1 1 + import { ok } from '@atcute/client'; 2 2 + import type { ResourceUri } from '@atcute/lexicons/syntax'; 3 3 + import type { OAuthUserAgent } from '@atcute/oauth-browser-client'; 4 4 + import { 5 5 + ShTangledRepoIssue, 6 6 + ShTangledRepoIssueComment, 7 7 + ShTangledRepoIssueState, 8 8 + } from '@atcute/tangled'; 9 9 + 10 10 + import { 11 11 + appviewFallback, 12 12 + appviewJson, 13 13 + getAppviewRecordCount, 14 14 + listAllAppviewRecords, 15 15 + type AppviewRecordView, 16 16 + type AppviewStatefulRecordView, 17 17 + } from './appview'; 18 18 + import { 19 19 + getBacklinks, 20 20 + getLatestBacklinkTimestamp, 21 21 + getUniqueBacklinkRefs, 22 22 + latestBacklinkRefByRkey, 23 23 + listBacklinkedRecordsPage, 24 24 + } from './backlinks'; 25 25 + import { 26 26 + ISSUE_COLLECTION, 27 27 + ISSUE_COMMENT_COLLECTION, 28 28 + ISSUE_STATE_COLLECTION, 29 29 + } from './constants'; 30 30 + import { 31 31 + appviewRecordToHydrated, 32 32 + fetchRecordValue, 33 33 + hydrateBacklinks, 34 34 + hydrateBacklinksFromAppview, 35 35 + } from './hydration'; 36 36 + import { createAuthRpc } from './identity'; 37 37 + import { 38 38 + extractAtUris, 39 39 + extractDids, 40 40 + findNumberedRecord, 41 41 + type HydratedRecord, 42 42 + maxTimestamp, 43 43 + optionalString, 44 44 + type PaginatedResult, 45 45 + parseAtUri, 46 46 + parseDirectRecordRef, 47 47 + sortByCreatedAt, 48 48 + timestampFromDate, 49 49 + timestampFromTid, 50 50 + toNumberMap, 51 51 + type RecordCreationResult, 52 52 + type BacklinkRecordRef, 53 53 + } from './records'; 54 54 + import type { RepoContext } from './repos'; 55 55 + import { 56 56 + getAppviewRecordSortTimestamp, 57 57 + listAppviewStatefulRecordsPage, 58 58 + listSearchedStatefulRecordsPage, 59 59 + sortStatefulRecordsByNewestRecord, 60 60 + sortStatefulRecordsByUpdatedAt, 61 61 + type StatefulPageOptions, 62 62 + } from './stateful'; 63 63 + 64 64 + export interface IssueSummary extends HydratedRecord<ShTangledRepoIssue.Main> { 65 65 + number: number; 66 66 + state: 'open' | 'closed'; 67 67 + } 68 68 + 69 69 + export interface IssueComment extends HydratedRecord<ShTangledRepoIssueComment.Main> {} 70 70 + 71 71 + export interface IssueDetail { 72 72 + issue: IssueSummary; 73 73 + comments: IssueComment[]; 74 74 + } 75 75 + 76 76 + export interface CreateIssueInput { 77 77 + title: string; 78 78 + body: string; 79 79 + } 80 80 + 81 81 + const normalizeIssueState = (value?: string): 'open' | 'closed' => 82 82 + value === 'closed' || value?.endsWith('.closed') ? 'closed' : 'open'; 83 83 + 84 84 + export const getIssueRecord = async (issueUri: ResourceUri): Promise<HydratedRecord<ShTangledRepoIssue.Main>> => { 85 85 + const record = await appviewJson<AppviewRecordView<ShTangledRepoIssue.Main>>( 86 86 + 'sh.tangled.repo.getIssue', 87 87 + { issue: issueUri }, 88 88 + ); 89 89 + return appviewRecordToHydrated(record); 90 90 + }; 91 91 + 92 92 + const hydrateIssueBacklinks = (refs: BacklinkRecordRef[]): Promise<Array<HydratedRecord<ShTangledRepoIssue.Main>>> => 93 93 + hydrateBacklinksFromAppview<ShTangledRepoIssue.Main>( 94 94 + refs, 95 95 + 'sh.tangled.repo.getIssues', 96 96 + 'issues', 97 97 + ); 98 98 + 99 99 + const getLatestIssueState = async (issueUri: ResourceUri): Promise<'open' | 'closed'> => { 100 100 + const refs = await getBacklinks(issueUri, 'sh.tangled.repo.issue.state:issue'); 101 101 + if (refs.length === 0) { 102 102 + return 'open'; 103 103 + } 104 104 + 105 105 + const state = await fetchRecordValue<ShTangledRepoIssueState.Main>(latestBacklinkRefByRkey(refs)!); 106 106 + return normalizeIssueState(state.state); 107 107 + }; 108 108 + 109 109 + const getIssueUpdatedAt = async ( 110 110 + issue: HydratedRecord<ShTangledRepoIssue.Main>, 111 111 + stateUpdatedAt?: string, 112 112 + ): Promise<number> => 113 113 + maxTimestamp( 114 114 + timestampFromDate(issue.value.createdAt), 115 115 + timestampFromTid(issue.rkey), 116 116 + timestampFromDate(stateUpdatedAt), 117 117 + await getLatestBacklinkTimestamp(issue.uri, [ 118 118 + `${ISSUE_COMMENT_COLLECTION}:issue`, 119 119 + `${ISSUE_STATE_COLLECTION}:issue`, 120 120 + ]), 121 121 + ); 122 122 + 123 123 + const listIssuesFromBacklinks = async (repo: RepoContext): Promise<IssueSummary[]> => { 124 124 + const refs = await getUniqueBacklinkRefs(repo.repoDid, [ 125 125 + 'sh.tangled.repo.issue:repoDid', 126 126 + 'sh.tangled.repo.issue:repo', 127 127 + ]); 128 128 + const issues = await hydrateIssueBacklinks(refs); 129 129 + const numbers = toNumberMap(issues); 130 130 + const states = await Promise.all(issues.map((issue) => getLatestIssueState(issue.uri))); 131 131 + 132 132 + const summaries = issues 133 133 + .map((issue, index) => ({ 134 134 + ...issue, 135 135 + number: numbers.get(issue.uri) ?? index + 1, 136 136 + state: states[index], 137 137 + })); 138 138 + 139 139 + return sortStatefulRecordsByUpdatedAt(summaries, (issue) => getIssueUpdatedAt(issue)); 140 140 + }; 141 141 + 142 142 + const listIssuesPageFromBacklinks = async ( 143 143 + repo: RepoContext, 144 144 + options: StatefulPageOptions<'open' | 'closed'>, 145 145 + ): Promise<PaginatedResult<IssueSummary>> => 146 146 + listBacklinkedRecordsPage<ShTangledRepoIssue.Main, 'open' | 'closed'>( 147 147 + repo.repoDid, 148 148 + ['sh.tangled.repo.issue:repoDid', 'sh.tangled.repo.issue:repo'], 149 149 + options, 150 150 + getLatestIssueState, 151 151 + (issue) => getIssueUpdatedAt(issue), 152 152 + hydrateIssueBacklinks, 153 153 + ); 154 154 + 155 155 + const getIssueCountFromBacklinks = async (repo: RepoContext): Promise<number> => 156 156 + (await getUniqueBacklinkRefs(repo.repoDid, [ 157 157 + 'sh.tangled.repo.issue:repoDid', 158 158 + 'sh.tangled.repo.issue:repo', 159 159 + ])).length; 160 160 + 161 161 + const getIssueFromBacklinks = async (repo: RepoContext, issueRef: string): Promise<IssueDetail> => { 162 162 + const issues = await listIssuesFromBacklinks(repo); 163 163 + const issue = findNumberedRecord(issues, issueRef); 164 164 + if (!issue) { 165 165 + throw new Error(`Issue not found`); 166 166 + } 167 167 + 168 168 + const commentRefs = await getBacklinks(issue.uri, 'sh.tangled.repo.issue.comment:issue'); 169 169 + const comments = await hydrateBacklinks<ShTangledRepoIssueComment.Main>(commentRefs); 170 170 + comments.sort(sortByCreatedAt); 171 171 + 172 172 + return { 173 173 + issue, 174 174 + comments, 175 175 + }; 176 176 + }; 177 177 + 178 178 + const listIssueCommentsFromAppview = async (issueUri: ResourceUri): Promise<IssueComment[]> => { 179 179 + const records = await listAllAppviewRecords<ShTangledRepoIssueComment.Main>( 180 180 + 'sh.tangled.repo.issue.listComments', 181 181 + issueUri, 182 182 + ); 183 183 + const comments = await Promise.all(records.map((record) => appviewRecordToHydrated(record))); 184 184 + comments.sort(sortByCreatedAt); 185 185 + return comments; 186 186 + }; 187 187 + 188 188 + const listIssuesFromAppview = async (repo: RepoContext): Promise<IssueSummary[]> => { 189 189 + const records = await listAllAppviewRecords<ShTangledRepoIssue.Main>( 190 190 + 'sh.tangled.repo.listIssues', 191 191 + repo.repoDid, 192 192 + ) as Array<AppviewStatefulRecordView<ShTangledRepoIssue.Main>>; 193 193 + const issues = await Promise.all(records.map((record) => appviewRecordToHydrated(record))); 194 194 + const numbers = toNumberMap(issues); 195 195 + 196 196 + const summaries = issues 197 197 + .map((issue, index) => ({ 198 198 + ...issue, 199 199 + number: numbers.get(issue.uri) ?? index + 1, 200 200 + state: normalizeIssueState(records[index].state), 201 201 + })); 202 202 + 203 203 + return sortStatefulRecordsByNewestRecord(summaries); 204 204 + }; 11 205 12 12 - export type { 13 13 - CreateIssueInput, 14 14 - IssueComment, 15 15 - IssueDetail, 16 16 - IssueSummary, 17 17 - } from './core'; 206 206 + const listIssuesPageFromAppview = async ( 207 207 + repo: RepoContext, 208 208 + options: StatefulPageOptions<'open' | 'closed'>, 209 209 + ): Promise<PaginatedResult<IssueSummary>> => { 210 210 + if (options.query?.trim()) { 211 211 + // Appview search can scope to repo/author/nsid. State is still derived 212 212 + // from separate state records, so filter state after each search hit. 213 213 + return listSearchedStatefulRecordsPage<ShTangledRepoIssue.Main, 'open' | 'closed'>( 214 214 + 'sh.tangled.repo.issue', 215 215 + repo, 216 216 + options, 217 217 + getLatestIssueState, 218 218 + ); 219 219 + } 220 220 + 221 221 + // Temporary until Bobbin exposes newest-first/reverse repo issue pagination. 222 222 + // This loads all appview issue records, but sorts without per-item backlinks. 223 223 + return listAppviewStatefulRecordsPage<ShTangledRepoIssue.Main, 'open' | 'closed'>( 224 224 + 'sh.tangled.repo.listIssues', 225 225 + repo.repoDid, 226 226 + options, 227 227 + normalizeIssueState, 228 228 + options.author ? { author: options.author } : {}, 229 229 + (issue) => Promise.resolve(getAppviewRecordSortTimestamp(issue)), 230 230 + ); 231 231 + }; 232 232 + 233 233 + const getIssueFromAppview = async (repo: RepoContext, issueRef: string): Promise<IssueDetail> => { 234 234 + const directUri = parseDirectRecordRef(issueRef, ISSUE_COLLECTION); 235 235 + if (directUri) { 236 236 + const issueRecord = await getIssueRecord(directUri); 237 237 + if (issueRecord.value.repo !== repo.repoDid) { 238 238 + throw new Error(`Issue not found`); 239 239 + } 240 240 + 241 241 + const issue: IssueSummary = { 242 242 + ...issueRecord, 243 243 + number: 0, 244 244 + state: await getLatestIssueState(issueRecord.uri), 245 245 + }; 246 246 + 247 247 + return { 248 248 + issue, 249 249 + comments: await listIssueCommentsFromAppview(issue.uri), 250 250 + }; 251 251 + } 252 252 + 253 253 + const issues = await listIssuesFromAppview(repo); 254 254 + const issue = findNumberedRecord(issues, issueRef); 255 255 + if (!issue) { 256 256 + throw new Error(`Issue not found`); 257 257 + } 258 258 + 259 259 + return { 260 260 + issue, 261 261 + comments: await listIssueCommentsFromAppview(issue.uri), 262 262 + }; 263 263 + }; 264 264 + 265 265 + export const listIssues = async (repo: RepoContext): Promise<IssueSummary[]> => 266 266 + appviewFallback( 267 267 + () => listIssuesFromAppview(repo), 268 268 + () => listIssuesFromBacklinks(repo), 269 269 + ); 270 270 + 271 271 + export const listIssuesPage = async ( 272 272 + repo: RepoContext, 273 273 + options: StatefulPageOptions<'open' | 'closed'>, 274 274 + ): Promise<PaginatedResult<IssueSummary>> => 275 275 + appviewFallback( 276 276 + () => listIssuesPageFromAppview(repo, options), 277 277 + () => listIssuesPageFromBacklinks(repo, options), 278 278 + ); 279 279 + 280 280 + export const getRepoIssueCount = async (repo: RepoContext): Promise<number> => 281 281 + appviewFallback( 282 282 + () => getAppviewRecordCount('sh.tangled.repo.countIssues', repo.repoDid), 283 283 + () => getIssueCountFromBacklinks(repo), 284 284 + ); 285 285 + 286 286 + export const getIssue = async (repo: RepoContext, issueRef: string): Promise<IssueDetail> => 287 287 + appviewFallback( 288 288 + () => getIssueFromAppview(repo, issueRef), 289 289 + () => getIssueFromBacklinks(repo, issueRef), 290 290 + ); 291 291 + 292 292 + export const createIssue = async ( 293 293 + agent: OAuthUserAgent, 294 294 + repo: RepoContext, 295 295 + input: CreateIssueInput, 296 296 + ): Promise<RecordCreationResult> => { 297 297 + const rpc = createAuthRpc(agent); 298 298 + const record: ShTangledRepoIssue.Main = { 299 299 + $type: 'sh.tangled.repo.issue', 300 300 + repo: repo.repoDid, 301 301 + title: input.title.trim(), 302 302 + body: optionalString(input.body), 303 303 + createdAt: new Date().toISOString(), 304 304 + mentions: extractDids(input.body), 305 305 + references: extractAtUris(input.body), 306 306 + }; 307 307 + 308 308 + const result = await ok( 309 309 + rpc.post('com.atproto.repo.createRecord', { 310 310 + input: { 311 311 + repo: agent.sub, 312 312 + collection: ISSUE_COLLECTION, 313 313 + record, 314 314 + }, 315 315 + }), 316 316 + ); 317 317 + 318 318 + return { 319 319 + uri: result.uri, 320 320 + rkey: parseAtUri(result.uri).rkey, 321 321 + }; 322 322 + }; 323 323 + 324 324 + export const createIssueComment = async ( 325 325 + agent: OAuthUserAgent, 326 326 + issueUri: ResourceUri, 327 327 + body: string, 328 328 + replyTo?: ResourceUri, 329 329 + ): Promise<RecordCreationResult> => { 330 330 + const rpc = createAuthRpc(agent); 331 331 + const record: ShTangledRepoIssueComment.Main = { 332 332 + $type: 'sh.tangled.repo.issue.comment', 333 333 + issue: issueUri, 334 334 + body: body.trim(), 335 335 + createdAt: new Date().toISOString(), 336 336 + mentions: extractDids(body), 337 337 + references: extractAtUris(body), 338 338 + ...(replyTo ? { replyTo } : {}), 339 339 + }; 340 340 + 341 341 + const result = await ok( 342 342 + rpc.post('com.atproto.repo.createRecord', { 343 343 + input: { 344 344 + repo: agent.sub, 345 345 + collection: ISSUE_COMMENT_COLLECTION, 346 346 + record, 347 347 + }, 348 348 + }), 349 349 + ); 350 350 + 351 351 + return { 352 352 + uri: result.uri, 353 353 + rkey: parseAtUri(result.uri).rkey, 354 354 + }; 355 355 + }; 356 356 + 357 357 + export const setIssueState = async ( 358 358 + agent: OAuthUserAgent, 359 359 + issueUri: ResourceUri, 360 360 + state: 'open' | 'closed', 361 361 + ): Promise<RecordCreationResult> => { 362 362 + const rpc = createAuthRpc(agent); 363 363 + const record: ShTangledRepoIssueState.Main = { 364 364 + $type: 'sh.tangled.repo.issue.state', 365 365 + issue: issueUri, 366 366 + state: 367 367 + state === 'closed' 368 368 + ? 'sh.tangled.repo.issue.state.closed' 369 369 + : 'sh.tangled.repo.issue.state.open', 370 370 + }; 371 371 + 372 372 + const result = await ok( 373 373 + rpc.post('com.atproto.repo.createRecord', { 374 374 + input: { 375 375 + repo: agent.sub, 376 376 + collection: ISSUE_STATE_COLLECTION, 377 377 + record, 378 378 + }, 379 379 + }), 380 380 + ); 381 381 + 382 382 + return { 383 383 + uri: result.uri, 384 384 + rkey: parseAtUri(result.uri).rkey, 385 385 + }; 386 386 + };

+448 -17

src/lib/api/pulls.ts

Reviewed

··· 1 1 - export { 2 2 - createPull, 3 3 - createPullComment, 4 4 - fetchPullRoundPatch, 5 5 - getPull, 6 6 - getPullRecord, 7 7 - getRepoPullCount, 8 8 - listPulls, 9 9 - listPullsPage, 10 10 - setPullStatus, 11 11 - } from './core'; 1 1 + import { ok } from '@atcute/client'; 2 2 + import type { ResourceUri } from '@atcute/lexicons/syntax'; 3 3 + import type { OAuthUserAgent } from '@atcute/oauth-browser-client'; 4 4 + import { 5 5 + ShTangledRepoPull, 6 6 + ShTangledRepoPullComment, 7 7 + ShTangledRepoPullStatus, 8 8 + } from '@atcute/tangled'; 9 9 + import { gunzipSync, gzipSync, strFromU8, strToU8 } from 'fflate'; 10 10 + 11 11 + import { 12 12 + appviewFallback, 13 13 + appviewJson, 14 14 + getAppviewRecordCount, 15 15 + listAllAppviewRecords, 16 16 + type AppviewRecordView, 17 17 + type AppviewStatefulRecordView, 18 18 + } from './appview'; 19 19 + import { 20 20 + getBacklinks, 21 21 + getBacklinksPage, 22 22 + getLatestBacklinkTimestamp, 23 23 + latestBacklinkRefByRkey, 24 24 + listBacklinkedRecordsPage, 25 25 + } from './backlinks'; 26 26 + import { 27 27 + PULL_COLLECTION, 28 28 + PULL_COMMENT_COLLECTION, 29 29 + PULL_STATUS_COLLECTION, 30 30 + } from './constants'; 31 31 + import { getRpc } from './client'; 32 32 + import { 33 33 + appviewRecordToHydrated, 34 34 + fetchRecordValue, 35 35 + hydrateBacklinks, 36 36 + hydrateBacklinksFromAppview, 37 37 + } from './hydration'; 38 38 + import { createAuthRpc, resolveActor } from './identity'; 39 39 + import { 40 40 + extractAtUris, 41 41 + extractBlobCid, 42 42 + extractDids, 43 43 + findNumberedRecord, 44 44 + type HydratedRecord, 45 45 + maxTimestamp, 46 46 + optionalString, 47 47 + type PaginatedResult, 48 48 + parseAtUri, 49 49 + parseDirectRecordRef, 50 50 + sortByCreatedAt, 51 51 + timestampFromDate, 52 52 + timestampFromTid, 53 53 + toNumberMap, 54 54 + type RecordCreationResult, 55 55 + type BacklinkRecordRef, 56 56 + } from './records'; 57 57 + import type { RepoContext } from './repos'; 58 58 + import { 59 59 + getAppviewRecordSortTimestamp, 60 60 + listAppviewStatefulRecordsPage, 61 61 + listSearchedStatefulRecordsPage, 62 62 + sortStatefulRecordsByNewestRecord, 63 63 + sortStatefulRecordsByUpdatedAt, 64 64 + type StatefulPageOptions, 65 65 + } from './stateful'; 66 66 + 67 67 + export interface PullSummary extends HydratedRecord<ShTangledRepoPull.Main> { 68 68 + number: number; 69 69 + state: 'open' | 'closed' | 'merged'; 70 70 + } 71 71 + 72 72 + export interface PullComment extends HydratedRecord<ShTangledRepoPullComment.Main> {} 73 73 + 74 74 + export interface PullDetail { 75 75 + pull: PullSummary; 76 76 + comments: PullComment[]; 77 77 + } 78 78 + 79 79 + export interface CreatePullInput { 80 80 + title: string; 81 81 + body: string; 82 82 + targetBranch: string; 83 83 + sourceBranch: string; 84 84 + patch: string; 85 85 + } 86 86 + 87 87 + const normalizePullStatus = (value?: string): 'open' | 'closed' | 'merged' => { 88 88 + if (value === 'merged' || value?.endsWith('.merged')) { 89 89 + return 'merged'; 90 90 + } 91 91 + 92 92 + if (value === 'closed' || value?.endsWith('.closed')) { 93 93 + return 'closed'; 94 94 + } 95 95 + 96 96 + return 'open'; 97 97 + }; 98 98 + 99 99 + export const getPullRecord = async (pullUri: ResourceUri): Promise<HydratedRecord<ShTangledRepoPull.Main>> => { 100 100 + const record = await appviewJson<AppviewRecordView<ShTangledRepoPull.Main>>( 101 101 + 'sh.tangled.repo.getPull', 102 102 + { pull: pullUri }, 103 103 + ); 104 104 + return appviewRecordToHydrated(record); 105 105 + }; 106 106 + 107 107 + const hydratePullBacklinks = (refs: BacklinkRecordRef[]): Promise<Array<HydratedRecord<ShTangledRepoPull.Main>>> => 108 108 + hydrateBacklinksFromAppview<ShTangledRepoPull.Main>( 109 109 + refs, 110 110 + 'sh.tangled.repo.getPulls', 111 111 + 'pulls', 112 112 + ); 113 113 + 114 114 + const getLatestPullStatus = async (pullUri: ResourceUri): Promise<'open' | 'closed' | 'merged'> => { 115 115 + const refs = await getBacklinks(pullUri, 'sh.tangled.repo.pull.status:pull'); 116 116 + if (refs.length === 0) { 117 117 + return 'open'; 118 118 + } 119 119 + 120 120 + const status = await fetchRecordValue<ShTangledRepoPullStatus.Main>(latestBacklinkRefByRkey(refs)!); 121 121 + return normalizePullStatus(status.status); 122 122 + }; 123 123 + 124 124 + const getPullUpdatedAt = async ( 125 125 + pull: HydratedRecord<ShTangledRepoPull.Main>, 126 126 + stateUpdatedAt?: string, 127 127 + ): Promise<number> => 128 128 + maxTimestamp( 129 129 + timestampFromDate(pull.value.createdAt), 130 130 + timestampFromTid(pull.rkey), 131 131 + ...pull.value.rounds.map((round) => timestampFromDate(round.createdAt)), 132 132 + timestampFromDate(stateUpdatedAt), 133 133 + await getLatestBacklinkTimestamp(pull.uri, [ 134 134 + `${PULL_COMMENT_COLLECTION}:pull`, 135 135 + `${PULL_STATUS_COLLECTION}:pull`, 136 136 + ]), 137 137 + ); 138 138 + 139 139 + const listPullsFromBacklinks = async (repo: RepoContext): Promise<PullSummary[]> => { 140 140 + const refs = await getBacklinks(repo.repoDid, 'sh.tangled.repo.pull:target.repo'); 141 141 + const pulls = await hydratePullBacklinks(refs); 142 142 + const numbers = toNumberMap(pulls); 143 143 + const states = await Promise.all(pulls.map((pull) => getLatestPullStatus(pull.uri))); 144 144 + 145 145 + const summaries = pulls 146 146 + .map((pull, index) => ({ 147 147 + ...pull, 148 148 + number: numbers.get(pull.uri) ?? index + 1, 149 149 + state: states[index], 150 150 + })); 151 151 + 152 152 + return sortStatefulRecordsByUpdatedAt(summaries, (pull) => getPullUpdatedAt(pull)); 153 153 + }; 154 154 + 155 155 + const listPullsPageFromBacklinks = async ( 156 156 + repo: RepoContext, 157 157 + options: StatefulPageOptions<'open' | 'closed' | 'merged'>, 158 158 + ): Promise<PaginatedResult<PullSummary>> => 159 159 + listBacklinkedRecordsPage<ShTangledRepoPull.Main, 'open' | 'closed' | 'merged'>( 160 160 + repo.repoDid, 161 161 + 'sh.tangled.repo.pull:target.repo', 162 162 + options, 163 163 + getLatestPullStatus, 164 164 + (pull) => getPullUpdatedAt(pull), 165 165 + hydratePullBacklinks, 166 166 + ); 167 167 + 168 168 + const getPullCountFromBacklinks = async (repo: RepoContext): Promise<number> => 169 169 + (await getBacklinksPage(repo.repoDid, 'sh.tangled.repo.pull:target.repo', 1)).total ?? 170 170 + (await getBacklinks(repo.repoDid, 'sh.tangled.repo.pull:target.repo')).length; 171 171 + 172 172 + const getPullFromBacklinks = async (repo: RepoContext, pullRef: string): Promise<PullDetail> => { 173 173 + const pulls = await listPullsFromBacklinks(repo); 174 174 + const pull = findNumberedRecord(pulls, pullRef); 175 175 + if (!pull) { 176 176 + throw new Error(`Pull request not found`); 177 177 + } 178 178 + 179 179 + const commentRefs = await getBacklinks(pull.uri, 'sh.tangled.repo.pull.comment:pull'); 180 180 + const comments = await hydrateBacklinks<ShTangledRepoPullComment.Main>(commentRefs); 181 181 + comments.sort(sortByCreatedAt); 182 182 + 183 183 + return { 184 184 + pull, 185 185 + comments, 186 186 + }; 187 187 + }; 188 188 + 189 189 + const listPullCommentsFromAppview = async (pullUri: ResourceUri): Promise<PullComment[]> => { 190 190 + const records = await listAllAppviewRecords<ShTangledRepoPullComment.Main>( 191 191 + 'sh.tangled.repo.pull.listComments', 192 192 + pullUri, 193 193 + ); 194 194 + const comments = await Promise.all(records.map((record) => appviewRecordToHydrated(record))); 195 195 + comments.sort(sortByCreatedAt); 196 196 + return comments; 197 197 + }; 198 198 + 199 199 + const listPullsFromAppview = async (repo: RepoContext): Promise<PullSummary[]> => { 200 200 + const records = await listAllAppviewRecords<ShTangledRepoPull.Main>( 201 201 + 'sh.tangled.repo.listPulls', 202 202 + repo.repoDid, 203 203 + ) as Array<AppviewStatefulRecordView<ShTangledRepoPull.Main>>; 204 204 + const pulls = await Promise.all(records.map((record) => appviewRecordToHydrated(record))); 205 205 + const numbers = toNumberMap(pulls); 206 206 + 207 207 + const summaries = pulls 208 208 + .map((pull, index) => ({ 209 209 + ...pull, 210 210 + number: numbers.get(pull.uri) ?? index + 1, 211 211 + state: normalizePullStatus(records[index].state), 212 212 + })); 213 213 + 214 214 + return sortStatefulRecordsByNewestRecord(summaries); 215 215 + }; 216 216 + 217 217 + const listPullsPageFromAppview = async ( 218 218 + repo: RepoContext, 219 219 + options: StatefulPageOptions<'open' | 'closed' | 'merged'>, 220 220 + ): Promise<PaginatedResult<PullSummary>> => { 221 221 + if (options.query?.trim()) { 222 222 + // Appview search can scope to repo/author/nsid. State is still derived 223 223 + // from separate status records, so filter state after each search hit. 224 224 + return listSearchedStatefulRecordsPage<ShTangledRepoPull.Main, 'open' | 'closed' | 'merged'>( 225 225 + 'sh.tangled.repo.pull', 226 226 + repo, 227 227 + options, 228 228 + getLatestPullStatus, 229 229 + ); 230 230 + } 231 231 + 232 232 + // Temporary until Bobbin exposes newest-first/reverse repo pull pagination. 233 233 + // This loads all appview pull records, but sorts without per-item backlinks. 234 234 + return listAppviewStatefulRecordsPage<ShTangledRepoPull.Main, 'open' | 'closed' | 'merged'>( 235 235 + 'sh.tangled.repo.listPulls', 236 236 + repo.repoDid, 237 237 + options, 238 238 + normalizePullStatus, 239 239 + options.author ? { author: options.author } : {}, 240 240 + (pull) => Promise.resolve(getAppviewRecordSortTimestamp(pull)), 241 241 + ); 242 242 + }; 12 243 13 13 - export type { 14 14 - CreatePullInput, 15 15 - PullComment, 16 16 - PullDetail, 17 17 - PullSummary, 18 18 - } from './core'; 244 244 + const getPullFromAppview = async (repo: RepoContext, pullRef: string): Promise<PullDetail> => { 245 245 + const directUri = parseDirectRecordRef(pullRef, PULL_COLLECTION); 246 246 + if (directUri) { 247 247 + const pullRecord = await getPullRecord(directUri); 248 248 + if (pullRecord.value.target.repo !== repo.repoDid) { 249 249 + throw new Error(`Pull request not found`); 250 250 + } 251 251 + 252 252 + const pull: PullSummary = { 253 253 + ...pullRecord, 254 254 + number: 0, 255 255 + state: await getLatestPullStatus(pullRecord.uri), 256 256 + }; 257 257 + 258 258 + return { 259 259 + pull, 260 260 + comments: await listPullCommentsFromAppview(pull.uri), 261 261 + }; 262 262 + } 263 263 + 264 264 + const pulls = await listPullsFromAppview(repo); 265 265 + const pull = findNumberedRecord(pulls, pullRef); 266 266 + if (!pull) { 267 267 + throw new Error(`Pull request not found`); 268 268 + } 269 269 + 270 270 + return { 271 271 + pull, 272 272 + comments: await listPullCommentsFromAppview(pull.uri), 273 273 + }; 274 274 + }; 275 275 + 276 276 + export const listPulls = async (repo: RepoContext): Promise<PullSummary[]> => 277 277 + appviewFallback( 278 278 + () => listPullsFromAppview(repo), 279 279 + () => listPullsFromBacklinks(repo), 280 280 + ); 281 281 + 282 282 + export const listPullsPage = async ( 283 283 + repo: RepoContext, 284 284 + options: StatefulPageOptions<'open' | 'closed' | 'merged'>, 285 285 + ): Promise<PaginatedResult<PullSummary>> => 286 286 + appviewFallback( 287 287 + () => listPullsPageFromAppview(repo, options), 288 288 + () => listPullsPageFromBacklinks(repo, options), 289 289 + ); 290 290 + 291 291 + export const getRepoPullCount = async (repo: RepoContext): Promise<number> => 292 292 + appviewFallback( 293 293 + () => getAppviewRecordCount('sh.tangled.repo.countPulls', repo.repoDid), 294 294 + () => getPullCountFromBacklinks(repo), 295 295 + ); 296 296 + 297 297 + export const getPull = async (repo: RepoContext, pullRef: string): Promise<PullDetail> => 298 298 + appviewFallback( 299 299 + () => getPullFromAppview(repo, pullRef), 300 300 + () => getPullFromBacklinks(repo, pullRef), 301 301 + ); 302 302 + 303 303 + export const fetchPullRoundPatch = async ( 304 304 + pull: PullSummary, 305 305 + roundIndex: number, 306 306 + ): Promise<string> => { 307 307 + const round = pull.value.rounds[roundIndex]; 308 308 + if (!round) { 309 309 + throw new Error(`Round ${roundIndex + 1} not found`); 310 310 + } 311 311 + 312 312 + const cid = extractBlobCid(round.patchBlob); 313 313 + if (!cid) { 314 314 + throw new Error(`Missing patch blob CID`); 315 315 + } 316 316 + 317 317 + const author = pull.author.pds ? pull.author : await resolveActor(pull.author.did); 318 318 + const rpc = getRpc(author.pds); 319 319 + const bytes = await ok( 320 320 + rpc.get('com.atproto.sync.getBlob', { 321 321 + params: { 322 322 + did: author.did, 323 323 + cid, 324 324 + }, 325 325 + as: 'bytes', 326 326 + }), 327 327 + ); 328 328 + 329 329 + return strFromU8(gunzipSync(bytes)); 330 330 + }; 331 331 + 332 332 + export const createPull = async ( 333 333 + agent: OAuthUserAgent, 334 334 + repo: RepoContext, 335 335 + input: CreatePullInput, 336 336 + ): Promise<RecordCreationResult> => { 337 337 + const rpc = createAuthRpc(agent); 338 338 + const patchBytes = new Uint8Array(gzipSync(strToU8(input.patch))); 339 339 + const patchBlob = new Blob([patchBytes.buffer], { 340 340 + type: 'application/gzip', 341 341 + }); 342 342 + 343 343 + const uploaded = await ok( 344 344 + rpc.post('com.atproto.repo.uploadBlob', { 345 345 + input: patchBlob, 346 346 + }), 347 347 + ); 348 348 + 349 349 + const record: ShTangledRepoPull.Main = { 350 350 + $type: 'sh.tangled.repo.pull', 351 351 + title: input.title.trim(), 352 352 + body: optionalString(input.body), 353 353 + target: { 354 354 + repo: repo.repoDid, 355 355 + branch: input.targetBranch, 356 356 + }, 357 357 + source: { 358 358 + branch: input.sourceBranch, 359 359 + }, 360 360 + rounds: [ 361 361 + { 362 362 + createdAt: new Date().toISOString(), 363 363 + patchBlob: uploaded.blob, 364 364 + }, 365 365 + ], 366 366 + createdAt: new Date().toISOString(), 367 367 + mentions: extractDids(input.body), 368 368 + references: extractAtUris(input.body), 369 369 + }; 370 370 + 371 371 + const result = await ok( 372 372 + rpc.post('com.atproto.repo.createRecord', { 373 373 + input: { 374 374 + repo: agent.sub, 375 375 + collection: PULL_COLLECTION, 376 376 + record, 377 377 + }, 378 378 + }), 379 379 + ); 380 380 + 381 381 + return { 382 382 + uri: result.uri, 383 383 + rkey: parseAtUri(result.uri).rkey, 384 384 + }; 385 385 + }; 386 386 + 387 387 + export const createPullComment = async ( 388 388 + agent: OAuthUserAgent, 389 389 + pullUri: ResourceUri, 390 390 + body: string, 391 391 + ): Promise<RecordCreationResult> => { 392 392 + const rpc = createAuthRpc(agent); 393 393 + const record: ShTangledRepoPullComment.Main = { 394 394 + $type: 'sh.tangled.repo.pull.comment', 395 395 + pull: pullUri, 396 396 + body: body.trim(), 397 397 + createdAt: new Date().toISOString(), 398 398 + mentions: extractDids(body), 399 399 + references: extractAtUris(body), 400 400 + }; 401 401 + 402 402 + const result = await ok( 403 403 + rpc.post('com.atproto.repo.createRecord', { 404 404 + input: { 405 405 + repo: agent.sub, 406 406 + collection: PULL_COMMENT_COLLECTION, 407 407 + record, 408 408 + }, 409 409 + }), 410 410 + ); 411 411 + 412 412 + return { 413 413 + uri: result.uri, 414 414 + rkey: parseAtUri(result.uri).rkey, 415 415 + }; 416 416 + }; 417 417 + 418 418 + export const setPullStatus = async ( 419 419 + agent: OAuthUserAgent, 420 420 + pullUri: ResourceUri, 421 421 + status: 'open' | 'closed' | 'merged', 422 422 + ): Promise<RecordCreationResult> => { 423 423 + const rpc = createAuthRpc(agent); 424 424 + const record: ShTangledRepoPullStatus.Main = { 425 425 + $type: 'sh.tangled.repo.pull.status', 426 426 + pull: pullUri, 427 427 + status: 428 428 + status === 'merged' 429 429 + ? 'sh.tangled.repo.pull.status.merged' 430 430 + : status === 'closed' 431 431 + ? 'sh.tangled.repo.pull.status.closed' 432 432 + : 'sh.tangled.repo.pull.status.open', 433 433 + }; 434 434 + 435 435 + const result = await ok( 436 436 + rpc.post('com.atproto.repo.createRecord', { 437 437 + input: { 438 438 + repo: agent.sub, 439 439 + collection: PULL_STATUS_COLLECTION, 440 440 + record, 441 441 + }, 442 442 + }), 443 443 + ); 444 444 + 445 445 + return { 446 446 + uri: result.uri, 447 447 + rkey: parseAtUri(result.uri).rkey, 448 448 + }; 449 449 + };

+229 -9

src/lib/api/records.ts

Reviewed

··· 1 1 - export { 2 2 - extractBlobCid, 3 3 - parseAtUri, 4 4 - } from './core'; 1 1 + import { ClientResponseError, ok } from '@atcute/client'; 2 2 + import type { ResolvedActor } from '@atcute/identity-resolver'; 3 3 + import type { Did, Nsid, ResourceUri } from '@atcute/lexicons/syntax'; 4 4 + 5 5 + import { getRpc } from './client'; 6 6 + 7 7 + export interface HydratedRecord<T> { 8 8 + author: ResolvedActor; 9 9 + collection: Nsid; 10 10 + rkey: string; 11 11 + uri: ResourceUri; 12 12 + cid?: string; 13 13 + value: T; 14 14 + } 15 15 + 16 16 + export interface PaginatedResult<T> { 17 17 + items: T[]; 18 18 + totalCount?: number; 19 19 + hasNext: boolean; 20 20 + } 21 21 + 22 22 + export interface RecordCreationResult { 23 23 + uri: ResourceUri; 24 24 + rkey: string; 25 25 + } 26 26 + 27 27 + export interface BacklinkRecordRef { 28 28 + did: Did; 29 29 + collection: Nsid; 30 30 + rkey: string; 31 31 + } 32 32 + 33 33 + const SORTABLE_BASE32_ALPHABET = '234567abcdefghijklmnopqrstuvwxyz'; 34 34 + const TID_PATTERN = /^[234567abcdefghij][234567abcdefghijklmnopqrstuvwxyz]{12}$/; 35 35 + 36 36 + export const timestampFromDate = (value?: string): number => { 37 37 + if (!value) { 38 38 + return 0; 39 39 + } 40 40 + 41 41 + const timestamp = new Date(value).getTime(); 42 42 + return Number.isFinite(timestamp) ? timestamp : 0; 43 43 + }; 44 44 + 45 45 + export const timestampFromTid = (rkey?: string): number => { 46 46 + if (!rkey || !TID_PATTERN.test(rkey)) { 47 47 + return 0; 48 48 + } 49 49 + 50 50 + let micros = 0; 51 51 + for (const char of rkey.slice(0, 11)) { 52 52 + const value = SORTABLE_BASE32_ALPHABET.indexOf(char); 53 53 + if (value < 0) { 54 54 + return 0; 55 55 + } 56 56 + micros = micros * 32 + value; 57 57 + } 58 58 + 59 59 + return Math.floor(micros / 1000); 60 60 + }; 61 61 + 62 62 + export const maxTimestamp = (...values: number[]): number => 63 63 + values.reduce((latest, value) => Math.max(latest, value), 0); 64 64 + 65 65 + export const parseAtUri = (uri: string): { did: Did; collection: Nsid; rkey: string } => { 66 66 + if (!uri.startsWith('at://')) { 67 67 + throw new Error(`Invalid at-uri: ${uri}`); 68 68 + } 69 69 + 70 70 + const parts = uri.slice(5).split('/'); 71 71 + const [did, collection, ...rkey] = parts; 72 72 + return { 73 73 + did: asDid(did), 74 74 + collection: asNsid(collection), 75 75 + rkey: rkey.join('/'), 76 76 + }; 77 77 + }; 78 78 + 79 79 + export const parseDirectRecordRef = (ref: string, collection: Nsid): ResourceUri | null => { 80 80 + let normalized = ref.trim(); 81 81 + try { 82 82 + normalized = decodeURIComponent(normalized); 83 83 + } catch { 84 84 + // Keep the original route param when it is not percent-encoded. 85 85 + } 86 86 + 87 87 + if (!normalized.startsWith('at://')) { 88 88 + return null; 89 89 + } 90 90 + 91 91 + try { 92 92 + return parseAtUri(normalized).collection === collection ? (normalized as ResourceUri) : null; 93 93 + } catch { 94 94 + return null; 95 95 + } 96 96 + }; 97 97 + 98 98 + export const extractBlobCid = (blob: unknown): string | null => { 99 99 + if (!blob || typeof blob !== 'object') { 100 100 + return null; 101 101 + } 102 102 + 103 103 + const value = blob as Record<string, unknown>; 104 104 + const ref = value.ref; 105 105 + 106 106 + if (typeof ref === 'string') { 107 107 + return ref; 108 108 + } 5 109 6 6 - export type { 7 7 - HydratedRecord, 8 8 - PaginatedResult, 9 9 - RecordCreationResult, 10 10 - } from './core'; 110 110 + if (ref && typeof ref === 'object') { 111 111 + const maybeLink = (ref as Record<string, unknown>).$link; 112 112 + if (typeof maybeLink === 'string') { 113 113 + return maybeLink; 114 114 + } 115 115 + } 116 116 + 117 117 + const maybeCid = value.cid; 118 118 + return typeof maybeCid === 'string' ? maybeCid : null; 119 119 + }; 120 120 + 121 121 + export const findNumberedRecord = <T extends { number: number; rkey: string; uri: string }>( 122 122 + records: T[], 123 123 + ref: string, 124 124 + ): T | undefined => { 125 125 + const trimmed = ref.trim(); 126 126 + if (/^\d+$/.test(trimmed)) { 127 127 + const number = Number(trimmed); 128 128 + return records.find((record) => record.number === number); 129 129 + } 130 130 + 131 131 + return records.find( 132 132 + (record) => 133 133 + record.rkey === trimmed || 134 134 + record.uri === trimmed || 135 135 + parseAtUri(record.uri).rkey === trimmed, 136 136 + ); 137 137 + }; 138 138 + 139 139 + export const optionalString = (value: string): string | undefined => { 140 140 + const trimmed = value.trim(); 141 141 + return trimmed.length > 0 ? trimmed : undefined; 142 142 + }; 143 143 + 144 144 + const uniq = <T extends string>(values: T[]): T[] | undefined => { 145 145 + if (values.length === 0) { 146 146 + return undefined; 147 147 + } 148 148 + 149 149 + return [...new Set(values)]; 150 150 + }; 151 151 + 152 152 + export const extractDids = (input: string): Did[] | undefined => 153 153 + uniq( 154 154 + Array.from( 155 155 + input.matchAll(/\bdid:[a-z0-9]+:[A-Za-z0-9._:%-]+\b/gi), 156 156 + (match) => match[0] as Did, 157 157 + ), 158 158 + ); 159 159 + 160 160 + export const extractAtUris = (input: string): ResourceUri[] | undefined => 161 161 + uniq( 162 162 + Array.from( 163 163 + input.matchAll(/\bat:\/\/[^\s<>()]+/gi), 164 164 + (match) => match[0] as ResourceUri, 165 165 + ), 166 166 + ); 167 167 + 168 168 + export const sortByCreatedAt = <T extends { value: { createdAt?: string } }>(left: T, right: T): number => 169 169 + new Date(left.value.createdAt ?? 0).getTime() - new Date(right.value.createdAt ?? 0).getTime(); 170 170 + 171 171 + export const toNumberMap = <T extends { uri: string; rkey: string; value: { createdAt?: string } }>( 172 172 + items: T[], 173 173 + ): Map<string, number> => { 174 174 + const ordered = [...items].sort((left, right) => { 175 175 + const leftTime = timestampFromDate(left.value.createdAt); 176 176 + const rightTime = timestampFromDate(right.value.createdAt); 177 177 + if (leftTime !== rightTime) { 178 178 + return leftTime - rightTime; 179 179 + } 180 180 + 181 181 + return left.rkey.localeCompare(right.rkey); 182 182 + }); 183 183 + 184 184 + return new Map(ordered.map((item, index) => [item.uri, index + 1])); 185 185 + }; 186 186 + 187 187 + export const getOptionalRecord = async <T>( 188 188 + actor: ResolvedActor, 189 189 + collection: Nsid, 190 190 + rkey: string, 191 191 + ): Promise<T | null> => { 192 192 + try { 193 193 + const record = await ok( 194 194 + getRpc(actor.pds).get('com.atproto.repo.getRecord', { 195 195 + params: { 196 196 + repo: actor.did, 197 197 + collection, 198 198 + rkey, 199 199 + }, 200 200 + }), 201 201 + ); 202 202 + 203 203 + return record.value as T; 204 204 + } catch (cause) { 205 205 + if ( 206 206 + cause instanceof ClientResponseError && 207 207 + (cause.status === 400 || cause.status === 404) 208 208 + ) { 209 209 + return null; 210 210 + } 211 211 + 212 212 + throw cause; 213 213 + } 214 214 + }; 215 215 + 216 216 + export const asDid = (value: string): Did => { 217 217 + if (!value.startsWith('did:')) { 218 218 + throw new Error(`Invalid DID: ${value}`); 219 219 + } 220 220 + 221 221 + return value as Did; 222 222 + }; 223 223 + 224 224 + export const asNsid = (value: string): Nsid => { 225 225 + if (value.split('.').length < 3) { 226 226 + throw new Error(`Invalid NSID: ${value}`); 227 227 + } 228 228 + 229 229 + return value as Nsid; 230 230 + };

+512 -31

src/lib/api/repos.ts

Reviewed

··· 1 1 - export { 2 2 - buildBlobDataUrl, 3 3 - compareBranches, 4 4 - decodeBlobText, 5 5 - getRepo, 6 6 - getRepoBlob, 7 7 - getRepoBranches, 8 8 - getRepoDefaultBranch, 9 9 - getRepoByDid, 10 10 - getRepoLanguages, 11 11 - getRepoLog, 12 12 - getRepoTags, 13 13 - getRepoTree, 14 14 - listRepoRecords, 15 15 - } from './core'; 1 1 + import { ok } from '@atcute/client'; 2 2 + import type { ResolvedActor } from '@atcute/identity-resolver'; 3 3 + import type { Did, Nsid, ResourceUri } from '@atcute/lexicons/syntax'; 4 4 + import { ShTangledRepo } from '@atcute/tangled'; 5 5 + 6 6 + import { 7 7 + appviewFallback, 8 8 + appviewJson, 9 9 + appviewOptionalKnotRequest, 10 10 + getRepoViaAppview, 11 11 + listAllAppviewRecords, 12 12 + type AppviewRecordView, 13 13 + } from './appview'; 14 14 + import { getRpc, normalizeServiceUrl } from './client'; 15 15 + import { REPO_COLLECTION } from './constants'; 16 16 + import { resolveActor } from './identity'; 17 17 + import { 18 18 + maxTimestamp, 19 19 + parseAtUri, 20 20 + timestampFromDate, 21 21 + } from './records'; 22 22 + 23 23 + export interface RepoContext { 24 24 + owner: ResolvedActor; 25 25 + record: RepoRecord; 26 26 + repoDid: Did; 27 27 + slug: string; 28 28 + rkey: string; 29 29 + knot: string; 30 30 + } 31 31 + 32 32 + export interface RepoRecord { 33 33 + uri: ResourceUri; 34 34 + cid: string; 35 35 + rkey: string; 36 36 + value: ShTangledRepo.Main; 37 37 + } 38 38 + 39 39 + export interface TreeResponse { 40 40 + ref: string; 41 41 + parent?: string; 42 42 + dotdot?: string; 43 43 + lastCommit?: CommitHeadline; 44 44 + readme?: { 45 45 + contents: string; 46 46 + filename: string; 47 47 + }; 48 48 + files: TreeEntry[]; 49 49 + } 50 50 + 51 51 + export interface TreeEntry { 52 52 + name: string; 53 53 + mode: string; 54 54 + size: number; 55 55 + last_commit?: CommitHeadline; 56 56 + } 57 57 + 58 58 + export interface CommitHeadline { 59 59 + hash: string; 60 60 + message: string; 61 61 + when: string; 62 62 + author?: { 63 63 + email: string; 64 64 + name: string; 65 65 + when: string; 66 66 + }; 67 67 + } 68 68 + 69 69 + export interface BranchResponse { 70 70 + branches: BranchEntry[]; 71 71 + } 72 72 + 73 73 + export interface DefaultBranchResponse { 74 74 + name?: string; 75 75 + branch?: string; 76 76 + reference?: { 77 77 + name?: string; 78 78 + }; 79 79 + hash?: string; 80 80 + when?: string; 81 81 + } 82 82 + 83 83 + export interface BranchEntry { 84 84 + reference: { 85 85 + name: string; 86 86 + hash: string; 87 87 + }; 88 88 + commit?: { 89 89 + Message: string; 90 90 + Author?: { 91 91 + Name: string; 92 92 + Email: string; 93 93 + When: string; 94 94 + }; 95 95 + Committer?: { 96 96 + Name: string; 97 97 + Email: string; 98 98 + When: string; 99 99 + }; 100 100 + }; 101 101 + is_default?: boolean; 102 102 + } 103 103 + 104 104 + export interface TagResponse { 105 105 + tags: Array<{ 106 106 + name: string; 107 107 + hash: string; 108 108 + message?: string; 109 109 + tag?: { 110 110 + Name: string; 111 111 + Message: string; 112 112 + Tagger?: { 113 113 + Name: string; 114 114 + Email: string; 115 115 + When: string; 116 116 + }; 117 117 + }; 118 118 + }>; 119 119 + } 120 120 + 121 121 + export interface LanguageResponse { 122 122 + ref: string; 123 123 + totalFiles?: number; 124 124 + totalSize?: number; 125 125 + languages: Array<{ 126 126 + name: string; 127 127 + percentage: number; 128 128 + size: number; 129 129 + color?: string; 130 130 + }>; 131 131 + } 132 132 + 133 133 + export interface LogResponse { 134 134 + ref: string; 135 135 + total: number; 136 136 + page: number; 137 137 + per_page: number; 138 138 + log: boolean; 139 139 + commits: Array<{ 140 140 + this: string; 141 141 + message: string; 142 142 + author?: { 143 143 + Name: string; 144 144 + Email: string; 145 145 + When: string; 146 146 + }; 147 147 + committer?: { 148 148 + Name: string; 149 149 + Email: string; 150 150 + When: string; 151 151 + }; 152 152 + pgp_signature?: string; 153 153 + parent?: string; 154 154 + parent_hashes?: number[][]; 155 155 + }>; 156 156 + } 157 157 + 158 158 + export interface BlobResponse { 159 159 + path: string; 160 160 + ref: string; 161 161 + content?: string; 162 162 + encoding?: 'base64' | 'utf-8'; 163 163 + fileTooLarge?: boolean; 164 164 + isBinary?: boolean; 165 165 + mimeType?: string; 166 166 + size?: number; 167 167 + lastCommit?: CommitHeadline; 168 168 + submodule?: { 169 169 + name: string; 170 170 + url: string; 171 171 + branch?: string; 172 172 + }; 173 173 + } 174 174 + 175 175 + export interface ComparePatch { 176 176 + Title: string; 177 177 + Body: string; 178 178 + Raw: string; 179 179 + SHA: string; 180 180 + Author?: string; 181 181 + Committer?: string; 182 182 + AuthorDate?: string; 183 183 + CommitterDate?: string; 184 184 + SubjectPrefix?: string; 185 185 + RawHeaders?: string; 186 186 + BodyAppendix?: string; 187 187 + } 188 188 + 189 189 + export interface CompareResponse { 190 190 + rev1: string; 191 191 + rev2: string; 192 192 + patch: string; 193 193 + format_patch: ComparePatch[]; 194 194 + } 195 195 + 196 196 + const fetchAllRepoRecords = async ( 197 197 + actor: ResolvedActor, 198 198 + collection: Nsid, 199 199 + ): Promise<Array<{ uri: ResourceUri; cid: string; value: unknown }>> => { 200 200 + const rpc = getRpc(actor.pds); 201 201 + const records: Array<{ uri: ResourceUri; cid: string; value: unknown }> = []; 202 202 + let cursor: string | undefined; 203 203 + 204 204 + do { 205 205 + const page = await ok( 206 206 + rpc.get('com.atproto.repo.listRecords', { 207 207 + params: { 208 208 + repo: actor.did, 209 209 + collection, 210 210 + limit: 100, 211 211 + cursor, 212 212 + reverse: true, 213 213 + }, 214 214 + }), 215 215 + ); 216 216 + 217 217 + records.push(...page.records); 218 218 + cursor = page.cursor; 219 219 + } while (cursor); 220 220 + 221 221 + return records; 222 222 + }; 223 223 + 224 224 + const listRepoRecordsFromAppview = async (owner: string | ResolvedActor): Promise<RepoRecord[]> => { 225 225 + const actor = typeof owner === 'string' ? await resolveActor(owner) : owner; 226 226 + const records = await listAllAppviewRecords<ShTangledRepo.Main>('sh.tangled.repo.listRepos', actor.did); 227 227 + 228 228 + return records.map((record) => ({ 229 229 + uri: record.uri, 230 230 + cid: record.cid ?? '', 231 231 + rkey: parseAtUri(record.uri).rkey, 232 232 + value: record.value, 233 233 + })); 234 234 + }; 235 235 + 236 236 + const listRepoRecordsFromPds = async (owner: string | ResolvedActor): Promise<RepoRecord[]> => { 237 237 + const actor = typeof owner === 'string' ? await resolveActor(owner) : owner; 238 238 + const records = await fetchAllRepoRecords(actor, REPO_COLLECTION); 239 239 + 240 240 + return records.map((record) => ({ 241 241 + uri: record.uri, 242 242 + cid: record.cid, 243 243 + rkey: parseAtUri(record.uri).rkey, 244 244 + value: record.value as ShTangledRepo.Main, 245 245 + })); 246 246 + }; 247 247 + 248 248 + export const listRepoRecords = async (owner: string | ResolvedActor): Promise<RepoRecord[]> => 249 249 + appviewFallback( 250 250 + () => listRepoRecordsFromAppview(owner), 251 251 + () => listRepoRecordsFromPds(owner), 252 252 + ); 253 253 + 254 254 + export const getRepo = async (ownerIdentifier: string, repoSlug: string): Promise<RepoContext> => { 255 255 + const owner = await resolveActor(ownerIdentifier); 256 256 + const all = await listRepoRecords(owner); 257 257 + const wanted = repoSlug.trim().toLowerCase(); 258 258 + const match = all.find((record) => { 259 259 + const name = record.value.name?.trim().toLowerCase(); 260 260 + return name === wanted || record.rkey.toLowerCase() === wanted; 261 261 + }); 262 262 + 263 263 + if (!match) { 264 264 + throw new Error(`Repository not found: ${ownerIdentifier}/${repoSlug}`); 265 265 + } 266 266 + 267 267 + if (!match.value.repoDid) { 268 268 + throw new Error(`Repository is missing repoDid metadata`); 269 269 + } 270 270 + 271 271 + const slug = match.value.name?.trim() || match.rkey; 272 272 + 273 273 + return { 274 274 + owner, 275 275 + record: match, 276 276 + repoDid: match.value.repoDid, 277 277 + slug, 278 278 + rkey: match.rkey, 279 279 + knot: normalizeServiceUrl(match.value.knot), 280 280 + }; 281 281 + }; 282 282 + 283 283 + export const getRepoByDid = async (repoDid: Did): Promise<RepoContext> => { 284 284 + const record = await appviewJson<AppviewRecordView<ShTangledRepo.Main>>( 285 285 + 'sh.tangled.repo.getRepoByRepoDid', 286 286 + { repoDid }, 287 287 + ); 288 288 + const parsed = parseAtUri(record.uri); 289 289 + const owner = await resolveActor(parsed.did); 290 290 + const slug = record.value.name?.trim() || parsed.rkey; 291 291 + 292 292 + if (!record.value.repoDid) { 293 293 + throw new Error(`Repository is missing repoDid metadata`); 294 294 + } 295 295 + 296 296 + return { 297 297 + owner, 298 298 + record: { 299 299 + uri: record.uri, 300 300 + cid: record.cid ?? '', 301 301 + rkey: parsed.rkey, 302 302 + value: record.value, 303 303 + }, 304 304 + repoDid: record.value.repoDid, 305 305 + slug, 306 306 + rkey: parsed.rkey, 307 307 + knot: normalizeServiceUrl(record.value.knot), 308 308 + }; 309 309 + }; 310 310 + 311 311 + const getRepoTreeFromKnot = async ( 312 312 + repo: RepoContext, 313 313 + ref: string, 314 314 + path = '', 315 315 + ): Promise<TreeResponse> => 316 316 + (await ok( 317 317 + getRpc(repo.knot).get('sh.tangled.repo.tree', { 318 318 + params: { 319 319 + repo: repo.repoDid, 320 320 + ref, 321 321 + path, 322 322 + }, 323 323 + }), 324 324 + )) as TreeResponse; 325 325 + 326 326 + const getRepoBranchesFromKnot = async (repo: RepoContext): Promise<BranchResponse> => 327 327 + (await ok( 328 328 + getRpc(repo.knot).get('sh.tangled.repo.branches', { 329 329 + params: { 330 330 + repo: repo.repoDid, 331 331 + }, 332 332 + as: 'json', 333 333 + }), 334 334 + )) as BranchResponse; 335 335 + 336 336 + const branchUpdatedTimestamp = (branch: BranchEntry): number => 337 337 + maxTimestamp( 338 338 + timestampFromDate(branch.commit?.Committer?.When), 339 339 + timestampFromDate(branch.commit?.Author?.When), 340 340 + ); 341 341 + 342 342 + const sortBranchResponseByUpdatedAt = (response: BranchResponse): BranchResponse => ({ 343 343 + ...response, 344 344 + branches: [...response.branches].sort((left, right) => { 345 345 + const updatedDiff = branchUpdatedTimestamp(right) - branchUpdatedTimestamp(left); 346 346 + if (updatedDiff !== 0) { 347 347 + return updatedDiff; 348 348 + } 349 349 + 350 350 + if (left.is_default !== right.is_default) { 351 351 + return left.is_default ? -1 : 1; 352 352 + } 353 353 + 354 354 + return left.reference.name.localeCompare(right.reference.name); 355 355 + }), 356 356 + }); 357 357 + 358 358 + const getRepoDefaultBranchFromKnot = async (repo: RepoContext): Promise<DefaultBranchResponse> => 359 359 + (await ok( 360 360 + getRpc(repo.knot).get('sh.tangled.repo.getDefaultBranch', { 361 361 + params: { 362 362 + repo: repo.repoDid, 363 363 + }, 364 364 + }), 365 365 + )) as DefaultBranchResponse; 366 366 + 367 367 + const getRepoTagsFromKnot = async (repo: RepoContext): Promise<TagResponse> => 368 368 + (await ok( 369 369 + getRpc(repo.knot).get('sh.tangled.repo.tags', { 370 370 + params: { 371 371 + repo: repo.repoDid, 372 372 + }, 373 373 + as: 'json', 374 374 + }), 375 375 + )) as TagResponse; 376 376 + 377 377 + const getRepoLanguagesFromKnot = async (repo: RepoContext, ref: string): Promise<LanguageResponse> => 378 378 + (await ok( 379 379 + getRpc(repo.knot).get('sh.tangled.repo.languages', { 380 380 + params: { 381 381 + repo: repo.repoDid, 382 382 + ref, 383 383 + }, 384 384 + }), 385 385 + )) as LanguageResponse; 386 386 + 387 387 + const getRepoLogFromKnot = async (repo: RepoContext, ref: string): Promise<LogResponse> => 388 388 + (await ok( 389 389 + getRpc(repo.knot).get('sh.tangled.repo.log', { 390 390 + params: { 391 391 + repo: repo.repoDid, 392 392 + ref, 393 393 + limit: 8, 394 394 + }, 395 395 + as: 'json', 396 396 + }), 397 397 + )) as LogResponse; 398 398 + 399 399 + const getRepoBlobFromKnot = async ( 400 400 + repo: RepoContext, 401 401 + ref: string, 402 402 + path: string, 403 403 + ): Promise<BlobResponse> => 404 404 + (await ok( 405 405 + getRpc(repo.knot).get('sh.tangled.repo.blob', { 406 406 + params: { 407 407 + repo: repo.repoDid, 408 408 + ref, 409 409 + path, 410 410 + }, 411 411 + }), 412 412 + )) as BlobResponse; 413 413 + 414 414 + const compareBranchesFromKnot = async ( 415 415 + repo: RepoContext, 416 416 + rev1: string, 417 417 + rev2: string, 418 418 + ): Promise<CompareResponse> => 419 419 + (await ok( 420 420 + getRpc(repo.knot).get('sh.tangled.repo.compare', { 421 421 + params: { 422 422 + repo: repo.repoDid, 423 423 + rev1, 424 424 + rev2, 425 425 + }, 426 426 + as: 'json', 427 427 + }), 428 428 + )) as CompareResponse; 429 429 + 430 430 + export const getRepoTree = async ( 431 431 + repo: RepoContext, 432 432 + ref: string, 433 433 + path = '', 434 434 + ): Promise<TreeResponse> => 435 435 + appviewOptionalKnotRequest( 436 436 + () => getRepoViaAppview<TreeResponse>('sh.tangled.repo.tree', repo, { ref, path }), 437 437 + () => getRepoTreeFromKnot(repo, ref, path), 438 438 + ); 439 439 + 440 440 + export const getRepoBranches = async (repo: RepoContext): Promise<BranchResponse> => 441 441 + appviewOptionalKnotRequest( 442 442 + () => getRepoViaAppview<BranchResponse>('sh.tangled.repo.branches', repo), 443 443 + () => getRepoBranchesFromKnot(repo), 444 444 + ).then(sortBranchResponseByUpdatedAt); 445 445 + 446 446 + export const getRepoDefaultBranch = async (repo: RepoContext): Promise<DefaultBranchResponse> => 447 447 + appviewOptionalKnotRequest( 448 448 + () => getRepoViaAppview<DefaultBranchResponse>('sh.tangled.repo.getDefaultBranch', repo), 449 449 + () => getRepoDefaultBranchFromKnot(repo), 450 450 + ); 451 451 + 452 452 + export const getRepoTags = async (repo: RepoContext): Promise<TagResponse> => 453 453 + appviewOptionalKnotRequest( 454 454 + () => getRepoViaAppview<TagResponse>('sh.tangled.repo.tags', repo), 455 455 + () => getRepoTagsFromKnot(repo), 456 456 + ); 457 457 + 458 458 + export const getRepoLanguages = async (repo: RepoContext, ref: string): Promise<LanguageResponse> => 459 459 + appviewOptionalKnotRequest( 460 460 + () => getRepoViaAppview<LanguageResponse>('sh.tangled.repo.languages', repo, { ref }), 461 461 + () => getRepoLanguagesFromKnot(repo, ref), 462 462 + ); 463 463 + 464 464 + export const getRepoLog = async (repo: RepoContext, ref: string): Promise<LogResponse> => 465 465 + appviewOptionalKnotRequest( 466 466 + () => getRepoViaAppview<LogResponse>('sh.tangled.repo.log', repo, { ref, limit: 8 }), 467 467 + () => getRepoLogFromKnot(repo, ref), 468 468 + ); 469 469 + 470 470 + export const getRepoBlob = async ( 471 471 + repo: RepoContext, 472 472 + ref: string, 473 473 + path: string, 474 474 + ): Promise<BlobResponse> => 475 475 + appviewOptionalKnotRequest( 476 476 + () => getRepoViaAppview<BlobResponse>('sh.tangled.repo.blob', repo, { ref, path }), 477 477 + () => getRepoBlobFromKnot(repo, ref, path), 478 478 + ); 479 479 + 480 480 + export const compareBranches = async ( 481 481 + repo: RepoContext, 482 482 + rev1: string, 483 483 + rev2: string, 484 484 + ): Promise<CompareResponse> => 485 485 + appviewOptionalKnotRequest( 486 486 + () => getRepoViaAppview<CompareResponse>('sh.tangled.repo.compare', repo, { rev1, rev2 }), 487 487 + () => compareBranchesFromKnot(repo, rev1, rev2), 488 488 + ); 489 489 + 490 490 + export const decodeBlobText = (blob: BlobResponse): string => { 491 491 + if (!blob.content) { 492 492 + return ''; 493 493 + } 494 494 + 495 495 + if (blob.encoding === 'base64') { 496 496 + const buffer = Uint8Array.from(atob(blob.content), (char) => char.charCodeAt(0)); 497 497 + return new TextDecoder().decode(buffer); 498 498 + } 499 499 + 500 500 + return blob.content; 501 501 + }; 502 502 + 503 503 + export const buildBlobDataUrl = (blob: BlobResponse): string | null => { 504 504 + if (!blob.content || !blob.mimeType) { 505 505 + return null; 506 506 + } 507 507 + 508 508 + if (blob.encoding === 'base64') { 509 509 + return `data:${blob.mimeType};base64,${blob.content}`; 510 510 + } 16 511 17 17 - export type { 18 18 - BlobResponse, 19 19 - BranchEntry, 20 20 - BranchResponse, 21 21 - CommitHeadline, 22 22 - ComparePatch, 23 23 - CompareResponse, 24 24 - DefaultBranchResponse, 25 25 - LanguageResponse, 26 26 - LogResponse, 27 27 - RepoContext, 28 28 - RepoRecord, 29 29 - TagResponse, 30 30 - TreeEntry, 31 31 - TreeResponse, 32 32 - } from './core'; 512 512 + return `data:${blob.mimeType};charset=utf-8,${encodeURIComponent(blob.content)}`; 513 513 + };

+91 -10

src/lib/api/search.ts

Reviewed

··· 1 1 - export { 2 2 - searchRecords, 3 3 - } from './core'; 1 1 + import type { Did } from '@atcute/lexicons/syntax'; 2 2 + import { 3 3 + ShTangledActorProfile, 4 4 + ShTangledLabelDefinition, 5 5 + ShTangledRepo, 6 6 + ShTangledRepoIssue, 7 7 + ShTangledRepoIssueComment, 8 8 + ShTangledRepoPull, 9 9 + ShTangledRepoPullComment, 10 10 + ShTangledString, 11 11 + } from '@atcute/tangled'; 12 12 + 13 13 + import { 14 14 + appviewJson, 15 15 + type AppviewSearchResponse, 16 16 + } from './appview'; 17 17 + import { appviewRecordToHydrated } from './hydration'; 18 18 + import type { HydratedRecord } from './records'; 19 19 + 20 20 + export type SearchCollection = 21 21 + | 'sh.tangled.actor.profile' 22 22 + | 'sh.tangled.repo' 23 23 + | 'sh.tangled.repo.issue' 24 24 + | 'sh.tangled.repo.issue.comment' 25 25 + | 'sh.tangled.repo.pull' 26 26 + | 'sh.tangled.repo.pull.comment' 27 27 + | 'sh.tangled.string' 28 28 + | 'sh.tangled.label.definition'; 29 29 + 30 30 + export type SearchRecordValue = 31 31 + | ShTangledActorProfile.Main 32 32 + | ShTangledRepo.Main 33 33 + | ShTangledRepoIssue.Main 34 34 + | ShTangledRepoIssueComment.Main 35 35 + | ShTangledRepoPull.Main 36 36 + | ShTangledRepoPullComment.Main 37 37 + | ShTangledString.Main 38 38 + | ShTangledLabelDefinition.Main; 39 39 + 40 40 + export interface SearchHit extends HydratedRecord<SearchRecordValue> { 41 41 + nsid: SearchCollection; 42 42 + score: number; 43 43 + } 44 44 + 45 45 + export interface SearchResponse { 46 46 + hits: SearchHit[]; 47 47 + cursor?: string; 48 48 + } 49 49 + 50 50 + export interface SearchRecordsOptions { 51 51 + q: string; 52 52 + nsid?: SearchCollection; 53 53 + author?: Did; 54 54 + repo?: Did; 55 55 + since?: string; 56 56 + until?: string; 57 57 + cursor?: string; 58 58 + limit?: number; 59 59 + } 60 60 + 61 61 + export const searchRecords = async (options: SearchRecordsOptions): Promise<SearchResponse> => { 62 62 + const q = options.q.trim(); 63 63 + if (!q) { 64 64 + return { hits: [] }; 65 65 + } 4 66 5 5 - export type { 6 6 - SearchCollection, 7 7 - SearchHit, 8 8 - SearchRecordValue, 9 9 - SearchRecordsOptions, 10 10 - SearchResponse, 11 11 - } from './core'; 67 67 + const response = await appviewJson<AppviewSearchResponse<SearchRecordValue>>( 68 68 + 'sh.tangled.search.query', 69 69 + { 70 70 + q, 71 71 + nsid: options.nsid, 72 72 + author: options.author, 73 73 + repo: options.repo, 74 74 + since: options.since, 75 75 + until: options.until, 76 76 + cursor: options.cursor, 77 77 + limit: options.limit, 78 78 + }, 79 79 + ); 80 80 + const hits = await Promise.all( 81 81 + response.hits.map(async (hit) => ({ 82 82 + ...(await appviewRecordToHydrated(hit)), 83 83 + nsid: hit.nsid as SearchCollection, 84 84 + score: hit.score, 85 85 + })), 86 86 + ); 87 87 + 88 88 + return { 89 89 + hits, 90 90 + cursor: response.cursor ?? undefined, 91 91 + }; 92 92 + };

+141 -9

src/lib/api/stars.ts

Reviewed

··· 1 1 - export { 2 2 - createRepoStar, 3 3 - deleteRepoStar, 4 4 - getRepoStarCount, 5 5 - getRepoStarSummary, 6 6 - } from './core'; 1 1 + import { ok } from '@atcute/client'; 2 2 + import type { Did } from '@atcute/lexicons/syntax'; 3 3 + import type { OAuthUserAgent } from '@atcute/oauth-browser-client'; 4 4 + import { ShTangledFeedStar } from '@atcute/tangled'; 5 5 + 6 6 + import { 7 7 + appviewFallback, 8 8 + getDistinctAppviewRecordCount, 9 9 + listAllAppviewRecords, 10 10 + type AppviewRecordView, 11 11 + } from './appview'; 12 12 + import { 13 13 + findBacklinkRefByDid, 14 14 + getBacklinkDids, 15 15 + } from './backlinks'; 16 16 + import { STAR_COLLECTION } from './constants'; 17 17 + import { createAuthRpc } from './identity'; 18 18 + import { 19 19 + parseAtUri, 20 20 + type RecordCreationResult, 21 21 + } from './records'; 22 22 + import type { RepoContext } from './repos'; 23 23 + 24 24 + export interface RepoStarSummary { 25 25 + count: number; 26 26 + isStarred: boolean; 27 27 + currentUserStarRkey?: string; 28 28 + } 29 29 + 30 30 + const STAR_BACKLINK_SOURCES = [ 31 31 + 'sh.tangled.feed.star:subject.did', 32 32 + 'sh.tangled.feed.star:subjectDid', 33 33 + ]; 34 34 + 35 35 + const getRepoStarSummaryFromBacklinks = async (repo: RepoContext, viewerDid?: Did | null): Promise<RepoStarSummary> => { 36 36 + const starrers = new Set<Did>(); 37 37 + const backlinkDidGroups = await Promise.all(STAR_BACKLINK_SOURCES.map((source) => getBacklinkDids(repo.repoDid, source))); 38 38 + 39 39 + for (const did of backlinkDidGroups.flat()) { 40 40 + starrers.add(did); 41 41 + } 42 42 + 43 43 + const currentUserStar = 44 44 + viewerDid && starrers.has(viewerDid) 45 45 + ? await findBacklinkRefByDid(repo.repoDid, STAR_BACKLINK_SOURCES, viewerDid) 46 46 + : undefined; 47 47 + 48 48 + return { 49 49 + count: starrers.size, 50 50 + isStarred: !!currentUserStar, 51 51 + currentUserStarRkey: currentUserStar?.rkey, 52 52 + }; 53 53 + }; 54 54 + 55 55 + const getRepoStarCountFromBacklinks = async (repo: RepoContext): Promise<number> => { 56 56 + const summary = await getRepoStarSummaryFromBacklinks(repo); 57 57 + return summary.count; 58 58 + }; 7 59 8 8 - export type { 9 9 - RepoStarSummary, 10 10 - } from './core'; 60 60 + const appviewStarSubjectDid = (star: ShTangledFeedStar.Main): Did | null => { 61 61 + const subject = star.subject as { did?: unknown; subjectDid?: unknown }; 62 62 + const did = subject.did ?? subject.subjectDid; 63 63 + return typeof did === 'string' && did.startsWith('did:') ? (did as Did) : null; 64 64 + }; 65 65 + 66 66 + const getRepoStarCountFromAppview = async (repo: RepoContext): Promise<number> => 67 67 + getDistinctAppviewRecordCount('sh.tangled.feed.countStars', repo.repoDid); 68 68 + 69 69 + const findCurrentUserStarFromAppview = async ( 70 70 + repo: RepoContext, 71 71 + viewerDid: Did, 72 72 + ): Promise<AppviewRecordView<ShTangledFeedStar.Main> | undefined> => { 73 73 + const stars = await listAllAppviewRecords<ShTangledFeedStar.Main>('sh.tangled.feed.listStarsBy', viewerDid); 74 74 + return stars.find((star) => appviewStarSubjectDid(star.value) === repo.repoDid); 75 75 + }; 76 76 + 77 77 + const getRepoStarSummaryFromAppview = async ( 78 78 + repo: RepoContext, 79 79 + viewerDid?: Did | null, 80 80 + ): Promise<RepoStarSummary> => { 81 81 + const [count, currentUserStar] = await Promise.all([ 82 82 + getRepoStarCountFromAppview(repo), 83 83 + viewerDid ? findCurrentUserStarFromAppview(repo, viewerDid) : undefined, 84 84 + ]); 85 85 + 86 86 + return { 87 87 + count, 88 88 + isStarred: !!currentUserStar, 89 89 + currentUserStarRkey: currentUserStar ? parseAtUri(currentUserStar.uri).rkey : undefined, 90 90 + }; 91 91 + }; 92 92 + 93 93 + export const getRepoStarSummary = async (repo: RepoContext, viewerDid?: Did | null): Promise<RepoStarSummary> => 94 94 + appviewFallback( 95 95 + () => getRepoStarSummaryFromAppview(repo, viewerDid), 96 96 + () => getRepoStarSummaryFromBacklinks(repo, viewerDid), 97 97 + ); 98 98 + 99 99 + export const getRepoStarCount = async (repo: RepoContext): Promise<number> => 100 100 + appviewFallback( 101 101 + () => getRepoStarCountFromAppview(repo), 102 102 + () => getRepoStarCountFromBacklinks(repo), 103 103 + ); 104 104 + 105 105 + export const createRepoStar = async (agent: OAuthUserAgent, repo: RepoContext): Promise<RecordCreationResult> => { 106 106 + const rpc = createAuthRpc(agent); 107 107 + const record: ShTangledFeedStar.Main = { 108 108 + $type: 'sh.tangled.feed.star', 109 109 + subject: { 110 110 + $type: 'sh.tangled.feed.star#repo', 111 111 + did: repo.repoDid, 112 112 + }, 113 113 + createdAt: new Date().toISOString(), 114 114 + }; 115 115 + const result = await ok( 116 116 + rpc.post('com.atproto.repo.createRecord', { 117 117 + input: { 118 118 + repo: agent.sub, 119 119 + collection: STAR_COLLECTION, 120 120 + record, 121 121 + }, 122 122 + }), 123 123 + ); 124 124 + 125 125 + return { 126 126 + uri: result.uri, 127 127 + rkey: parseAtUri(result.uri).rkey, 128 128 + }; 129 129 + }; 130 130 + 131 131 + export const deleteRepoStar = async (agent: OAuthUserAgent, rkey: string): Promise<void> => { 132 132 + const rpc = createAuthRpc(agent); 133 133 + await ok( 134 134 + rpc.post('com.atproto.repo.deleteRecord', { 135 135 + input: { 136 136 + repo: agent.sub, 137 137 + collection: STAR_COLLECTION, 138 138 + rkey, 139 139 + }, 140 140 + }), 141 141 + ); 142 142 + };

+357

src/lib/api/stateful.ts

Reviewed

··· 1 1 + import type { Did, ResourceUri } from '@atcute/lexicons/syntax'; 2 2 + 3 3 + import { 4 4 + appviewJson, 5 5 + listAllAppviewRecords, 6 6 + type AppviewParamValue, 7 7 + type AppviewSearchResponse, 8 8 + type AppviewStatefulListResponse, 9 9 + type AppviewStatefulRecordView, 10 10 + } from './appview'; 11 11 + import { 12 12 + getNearestAppviewCursorCheckpoint, 13 13 + rememberAppviewCursorCheckpoint, 14 14 + } from './appview-cache'; 15 15 + import { appviewRecordToHydrated } from './hydration'; 16 16 + import { 17 17 + type HydratedRecord, 18 18 + type PaginatedResult, 19 19 + maxTimestamp, 20 20 + timestampFromDate, 21 21 + timestampFromTid, 22 22 + toNumberMap, 23 23 + } from './records'; 24 24 + import { getTangledAppviewService } from '../settings'; 25 25 + import { normalizeServiceUrl } from './client'; 26 26 + 27 27 + export type StatefulHydratedRecord<T, State extends string> = HydratedRecord<T> & { 28 28 + number: number; 29 29 + state: State; 30 30 + }; 31 31 + 32 32 + export type StatefulPageOptions<State extends string> = { 33 33 + offset: number; 34 34 + limit: number; 35 35 + state: State; 36 36 + author?: Did; 37 37 + query?: string; 38 38 + }; 39 39 + 40 40 + const APPVIEW_PAGE_BATCH_LIMIT = 100; 41 41 + const SEARCH_PAGE_BATCH_LIMIT = 100; 42 42 + 43 43 + export const getAppviewRecordSortTimestamp = <T extends { createdAt?: string }>( 44 44 + record: HydratedRecord<T>, 45 45 + ): number => 46 46 + maxTimestamp( 47 47 + timestampFromDate(record.value.createdAt), 48 48 + timestampFromTid(record.rkey), 49 49 + ); 50 50 + 51 51 + export const sortStatefulRecordsByNewestRecord = <T extends { createdAt?: string }, State extends string>( 52 52 + items: Array<StatefulHydratedRecord<T, State>>, 53 53 + ): Array<StatefulHydratedRecord<T, State>> => 54 54 + [...items].sort((left, right) => { 55 55 + const timestampDiff = getAppviewRecordSortTimestamp(right) - getAppviewRecordSortTimestamp(left); 56 56 + if (timestampDiff !== 0) { 57 57 + return timestampDiff; 58 58 + } 59 59 + 60 60 + if (left.number !== right.number) { 61 61 + return right.number - left.number; 62 62 + } 63 63 + 64 64 + return right.rkey.localeCompare(left.rkey); 65 65 + }); 66 66 + 67 67 + export const sortStatefulRecordsByUpdatedAt = async <T, State extends string>( 68 68 + items: Array<StatefulHydratedRecord<T, State>>, 69 69 + getUpdatedAt: (item: StatefulHydratedRecord<T, State>) => Promise<number>, 70 70 + ): Promise<Array<StatefulHydratedRecord<T, State>>> => { 71 71 + const decorated = await Promise.all( 72 72 + items.map(async (item) => ({ 73 73 + item, 74 74 + updatedAt: await getUpdatedAt(item), 75 75 + })), 76 76 + ); 77 77 + 78 78 + decorated.sort((left, right) => { 79 79 + const updatedDiff = right.updatedAt - left.updatedAt; 80 80 + if (updatedDiff !== 0) { 81 81 + return updatedDiff; 82 82 + } 83 83 + 84 84 + if (left.item.number !== right.item.number) { 85 85 + return right.item.number - left.item.number; 86 86 + } 87 87 + 88 88 + return right.item.rkey.localeCompare(left.item.rkey); 89 89 + }); 90 90 + 91 91 + return decorated.map(({ item }) => item); 92 92 + }; 93 93 + 94 94 + export const statefulRecordMatchesQuery = (value: unknown, query?: string): boolean => { 95 95 + const normalized = query?.trim().toLowerCase(); 96 96 + if (!normalized) { 97 97 + return true; 98 98 + } 99 99 + 100 100 + const record = value as { title?: unknown; body?: unknown }; 101 101 + return [record.title, record.body] 102 102 + .filter((part): part is string => typeof part === 'string') 103 103 + .some((part) => part.toLowerCase().includes(normalized)); 104 104 + }; 105 105 + 106 106 + export const paginateStatefulRecords = <T, State extends string>( 107 107 + items: Array<StatefulHydratedRecord<T, State>>, 108 108 + options: StatefulPageOptions<State>, 109 109 + ): PaginatedResult<StatefulHydratedRecord<T, State>> => { 110 110 + const offset = Math.max(options.offset, 0); 111 111 + const limit = Math.max(options.limit, 1); 112 112 + const matching = items.filter((item) => 113 113 + item.state === options.state && 114 114 + (!options.author || item.author.did === options.author) && 115 115 + statefulRecordMatchesQuery(item.value, options.query), 116 116 + ); 117 117 + 118 118 + return { 119 119 + items: matching.slice(offset, offset + limit), 120 120 + totalCount: matching.length, 121 121 + hasNext: offset + limit < matching.length, 122 122 + }; 123 123 + }; 124 124 + 125 125 + const appviewCursorCacheKey = ( 126 126 + nsid: string, 127 127 + subject: string, 128 128 + state: string, 129 129 + extraParams: Record<string, AppviewParamValue> = {}, 130 130 + ): string => { 131 131 + const extras = Object.entries(extraParams) 132 132 + .filter(([, value]) => value !== undefined && value !== null) 133 133 + .sort(([left], [right]) => left.localeCompare(right)) 134 134 + .map(([key, value]) => `${key}=${String(value)}`) 135 135 + .join('&'); 136 136 + 137 137 + return [ 138 138 + normalizeServiceUrl(getTangledAppviewService()), 139 139 + nsid, 140 140 + subject, 141 141 + state, 142 142 + extras, 143 143 + ].join('|'); 144 144 + }; 145 145 + 146 146 + export const listAppviewStatefulRecordsPage = async <T extends { createdAt?: string }, State extends string>( 147 147 + nsid: string, 148 148 + subject: string, 149 149 + options: StatefulPageOptions<State>, 150 150 + normalizeState: (value?: string) => State, 151 151 + extraParams: Record<string, AppviewParamValue> = {}, 152 152 + getUpdatedAt?: ( 153 153 + record: StatefulHydratedRecord<T, State>, 154 154 + appviewRecord: AppviewStatefulRecordView<T>, 155 155 + ) => Promise<number>, 156 156 + ): Promise<PaginatedResult<StatefulHydratedRecord<T, State>>> => { 157 157 + if (getUpdatedAt) { 158 158 + const records = await listAllAppviewRecords<T>(nsid, subject, extraParams) as Array<AppviewStatefulRecordView<T>>; 159 159 + const hydrated = await Promise.all(records.map((record) => appviewRecordToHydrated(record))); 160 160 + const numbers = toNumberMap(hydrated); 161 161 + const decorated = await Promise.all( 162 162 + hydrated.map(async (record, index) => { 163 163 + const item: StatefulHydratedRecord<T, State> = { 164 164 + ...record, 165 165 + number: numbers.get(record.uri) ?? index + 1, 166 166 + state: normalizeState(records[index].state), 167 167 + }; 168 168 + 169 169 + return { 170 170 + item, 171 171 + updatedAt: await getUpdatedAt(item, records[index]), 172 172 + }; 173 173 + }), 174 174 + ); 175 175 + 176 176 + decorated.sort((left, right) => { 177 177 + const updatedDiff = right.updatedAt - left.updatedAt; 178 178 + if (updatedDiff !== 0) { 179 179 + return updatedDiff; 180 180 + } 181 181 + 182 182 + if (left.item.number !== right.item.number) { 183 183 + return right.item.number - left.item.number; 184 184 + } 185 185 + 186 186 + return right.item.rkey.localeCompare(left.item.rkey); 187 187 + }); 188 188 + 189 189 + return paginateStatefulRecords( 190 190 + decorated.map(({ item }) => item), 191 191 + options, 192 192 + ); 193 193 + } 194 194 + 195 195 + // Bobbin exposes cursor pagination, while the UI still uses offsets. Cache 196 196 + // page-boundary cursors so sequential pages can resume from the prior page. 197 197 + const offset = Math.max(options.offset, 0); 198 198 + const limit = Math.max(options.limit, 1); 199 199 + const requestedEnd = offset + limit; 200 200 + const cacheKey = appviewCursorCacheKey(nsid, subject, options.state, extraParams); 201 201 + const start = getNearestAppviewCursorCheckpoint(cacheKey, offset); 202 202 + const pendingItems: Array<{ 203 203 + record: AppviewStatefulRecordView<T>; 204 204 + number: number; 205 205 + state: State; 206 206 + }> = []; 207 207 + 208 208 + if (start.exhausted) { 209 209 + return { 210 210 + items: [], 211 211 + totalCount: start.matchingSeen, 212 212 + hasNext: false, 213 213 + }; 214 214 + } 215 215 + 216 216 + let cursor = start.cursor; 217 217 + let matchingSeen = start.matchingSeen; 218 218 + let scannedSeen = start.scannedSeen; 219 219 + 220 220 + while (true) { 221 221 + const pageLimit = Math.min( 222 222 + APPVIEW_PAGE_BATCH_LIMIT, 223 223 + Math.max(matchingSeen < requestedEnd ? requestedEnd - matchingSeen : 1, 1), 224 224 + ); 225 225 + const page = await appviewJson<AppviewStatefulListResponse<T>>(nsid, { 226 226 + subject, 227 227 + limit: pageLimit, 228 228 + cursor, 229 229 + ...extraParams, 230 230 + }); 231 231 + 232 232 + for (const record of page.items) { 233 233 + const state = normalizeState(record.state); 234 234 + const number = scannedSeen + 1; 235 235 + scannedSeen += 1; 236 236 + 237 237 + if (state !== options.state) { 238 238 + continue; 239 239 + } 240 240 + 241 241 + if (!statefulRecordMatchesQuery(record.value, options.query)) { 242 242 + continue; 243 243 + } 244 244 + 245 245 + if (matchingSeen >= offset && matchingSeen < requestedEnd) { 246 246 + pendingItems.push({ record, number, state }); 247 247 + } 248 248 + 249 249 + matchingSeen += 1; 250 250 + } 251 251 + 252 252 + cursor = page.cursor ?? undefined; 253 253 + const exhausted = !cursor; 254 254 + rememberAppviewCursorCheckpoint(cacheKey, { 255 255 + matchingSeen, 256 256 + scannedSeen, 257 257 + cursor, 258 258 + exhausted, 259 259 + }); 260 260 + 261 261 + if (matchingSeen > requestedEnd) { 262 262 + const visibleItems = pendingItems.slice(0, limit); 263 263 + const hydrated = await Promise.all( 264 264 + visibleItems.map(({ record }) => appviewRecordToHydrated(record)), 265 265 + ); 266 266 + 267 267 + return { 268 268 + items: hydrated.map((item, index) => ({ 269 269 + ...item, 270 270 + number: visibleItems[index].number, 271 271 + state: visibleItems[index].state, 272 272 + })), 273 273 + hasNext: true, 274 274 + }; 275 275 + } 276 276 + 277 277 + if (exhausted || page.items.length === 0) { 278 278 + const hydrated = await Promise.all( 279 279 + pendingItems.map(({ record }) => appviewRecordToHydrated(record)), 280 280 + ); 281 281 + 282 282 + return { 283 283 + items: hydrated.map((item, index) => ({ 284 284 + ...item, 285 285 + number: pendingItems[index].number, 286 286 + state: pendingItems[index].state, 287 287 + })), 288 288 + totalCount: matchingSeen, 289 289 + hasNext: false, 290 290 + }; 291 291 + } 292 292 + } 293 293 + }; 294 294 + 295 295 + export const listSearchedStatefulRecordsPage = async <T, State extends string>( 296 296 + nsid: string, 297 297 + repo: { repoDid: Did }, 298 298 + options: StatefulPageOptions<State>, 299 299 + getState: (uri: ResourceUri) => Promise<State>, 300 300 + ): Promise<PaginatedResult<StatefulHydratedRecord<T, State>>> => { 301 301 + const query = options.query?.trim(); 302 302 + if (!query) { 303 303 + return { items: [], totalCount: 0, hasNext: false }; 304 304 + } 305 305 + 306 306 + const offset = Math.max(options.offset, 0); 307 307 + const limit = Math.max(options.limit, 1); 308 308 + const requestedEnd = offset + limit; 309 309 + const items: Array<StatefulHydratedRecord<T, State>> = []; 310 310 + let cursor: string | undefined; 311 311 + let matchingSeen = 0; 312 312 + 313 313 + while (true) { 314 314 + const page = await appviewJson<AppviewSearchResponse<T>>('sh.tangled.search.query', { 315 315 + q: query, 316 316 + nsid, 317 317 + author: options.author, 318 318 + repo: repo.repoDid, 319 319 + cursor, 320 320 + limit: SEARCH_PAGE_BATCH_LIMIT, 321 321 + }); 322 322 + const hydrated = await Promise.all(page.hits.map((hit) => appviewRecordToHydrated(hit))); 323 323 + const states = await Promise.all(hydrated.map((record) => getState(record.uri))); 324 324 + 325 325 + for (const [index, record] of hydrated.entries()) { 326 326 + const state = states[index]; 327 327 + if (state !== options.state) { 328 328 + continue; 329 329 + } 330 330 + 331 331 + if (matchingSeen >= offset && matchingSeen < requestedEnd) { 332 332 + items.push({ 333 333 + ...record, 334 334 + number: 0, 335 335 + state, 336 336 + }); 337 337 + } 338 338 + 339 339 + matchingSeen += 1; 340 340 + if (matchingSeen > requestedEnd) { 341 341 + return { 342 342 + items: items.slice(0, limit), 343 343 + hasNext: true, 344 344 + }; 345 345 + } 346 346 + } 347 347 + 348 348 + cursor = page.cursor ?? undefined; 349 349 + if (!cursor || page.hits.length === 0) { 350 350 + return { 351 351 + items, 352 352 + totalCount: matchingSeen, 353 353 + hasNext: false, 354 354 + }; 355 355 + } 356 356 + } 357 357 + };

+1 -1

src/pages/repo/code.tsx

Reviewed

··· 3 3 import { A, useNavigate, useParams } from '@solidjs/router'; 4 4 import { createQuery, keepPreviousData, useQueryClient } from '@tanstack/solid-query'; 5 5 import { For, Match, Show, Switch, createEffect, createMemo, createSignal, type Component } from 'solid-js'; 6 6 - import { buildBlobDataUrl, decodeBlobText, getRepoBlob, getRepoBranches, getRepoDefaultBranch, getRepoLanguages, getRepoLog, getRepoTags, getRepoTree } from '../../lib/api'; 6 6 + import { buildBlobDataUrl, decodeBlobText, getRepoBlob, getRepoBranches, getRepoDefaultBranch, getRepoLanguages, getRepoLog, getRepoTags, getRepoTree } from '../../lib/api/repos'; 7 7 import { Avatar, ErrorState, PlaceholderAvatar, buttonStyles, cardStyles } from '../../components/common'; 8 8 import { CodeView, FileRow, MarkdownBlock, OverviewFileRow, ReadmeCard, RepoTreeSkeleton } from '../../components/repo'; 9 9 import { RepoFrame, useRepoQuery } from './shared';

+1 -1

src/pages/repo/issues-helpers.ts

Reviewed

··· 1 1 - import type { IssueComment } from '../../lib/api'; 1 1 + import type { IssueComment } from '../../lib/api/issues'; 2 2 import type { SearchParamValue } from '../../lib/repo-utils'; 3 3 4 4 export type IssueStateFilter = 'open' | 'closed';

+4 -1

src/pages/repo/issues.tsx

Reviewed

··· 4 4 import { createQuery, useQueryClient } from '@tanstack/solid-query'; 5 5 import type { ResourceUri } from '@atcute/lexicons/syntax'; 6 6 import { For, Match, Show, Switch, createEffect, createMemo, createSignal, type Component } from 'solid-js'; 7 7 - import { createIssue, createIssueComment, getIssue, listIssuesPage, parseAtUri, resolveActor, setIssueState, type RepoContext } from '../../lib/api'; 7 7 + import { createIssue, createIssueComment, getIssue, listIssuesPage, setIssueState } from '../../lib/api/issues'; 8 8 + import { resolveActor } from '../../lib/api/identity'; 9 9 + import { parseAtUri } from '../../lib/api/records'; 10 10 + import type { RepoContext } from '../../lib/api/repos'; 8 11 import { useAuth } from '../../lib/auth'; 9 12 import { Avatar, ErrorState, PaginationControls, StateBadge, ToggleButton, buttonStyles, cardStyles, inputStyles, textareaStyles } from '../../components/common'; 10 13 import { AtUriPanel, MarkdownBlock, RepoListSkeleton, RepoThreadSkeleton } from '../../components/repo';

+4 -1

src/pages/repo/pulls.tsx

Reviewed

··· 17 17 import { A, useNavigate, useParams, useSearchParams } from '@solidjs/router'; 18 18 import { createQuery, useQueryClient } from '@tanstack/solid-query'; 19 19 import { For, Match, Show, Switch, createEffect, createMemo, createSignal, type Component, type JSX } from 'solid-js'; 20 20 - import { compareBranches, createPull, createPullComment, fetchPullRoundPatch, getPull, getRepoBranches, listPullsPage, parseAtUri, resolveActor, setPullStatus, type RepoContext } from '../../lib/api'; 20 20 + import { resolveActor } from '../../lib/api/identity'; 21 21 + import { createPull, createPullComment, fetchPullRoundPatch, getPull, listPullsPage, setPullStatus } from '../../lib/api/pulls'; 22 22 + import { parseAtUri } from '../../lib/api/records'; 23 23 + import { compareBranches, getRepoBranches, type RepoContext } from '../../lib/api/repos'; 21 24 import { useAuth } from '../../lib/auth'; 22 25 import { Avatar, ErrorState, LoadingState, PaginationControls, StateBadge, ToggleButton, buttonStyles, cardStyles, textareaStyles } from '../../components/common'; 23 26 import { AtUriPanel, BranchPill, CommentCard, DiffView, MarkdownBlock, PullDiffSkeleton, PullDiffView, RepoListSkeleton, RepoThreadSkeleton } from '../../components/repo';

+4 -1

src/pages/repo/shared.tsx

Reviewed

··· 2 2 import { A, type RouteSectionProps, useParams } from '@solidjs/router'; 3 3 import { createQuery } from '@tanstack/solid-query'; 4 4 import { For, Match, Show, Switch, createContext, createEffect, createMemo, createSignal, onCleanup, useContext, type Component, type JSX } from 'solid-js'; 5 5 - import { createRepoStar, deleteRepoStar, getRepo, getRepoIssueCount, getRepoPullCount, getRepoStarSummary } from '../../lib/api'; 5 5 + import { getRepoIssueCount } from '../../lib/api/issues'; 6 6 + import { getRepoPullCount } from '../../lib/api/pulls'; 7 7 + import { getRepo } from '../../lib/api/repos'; 8 8 + import { createRepoStar, deleteRepoStar, getRepoStarSummary } from '../../lib/api/stars'; 6 9 import { useAuth } from '../../lib/auth'; 7 10 import { useLiveEvents } from '../../lib/live-events'; 8 11 import { Avatar, ErrorState, cardStyles } from '../../components/common';

+4 -4

src/routes.tsx

Reviewed

··· 13 13 RepoCodePage, 14 14 } from './pages/repo'; 15 15 import { RepoLayout } from './pages/repo/shared'; 16 16 - import { HomePage } from './views/home'; 17 17 - import { NotFoundPage } from './views/not-found'; 18 18 - import { OAuthCallbackPage } from './views/oauth-callback'; 19 19 - import { SearchPage } from './views/search'; 16 16 + import { HomePage } from './pages/home'; 17 17 + import { NotFoundPage } from './pages/not-found'; 18 18 + import { OAuthCallbackPage } from './pages/oauth-callback'; 19 19 + import { SearchPage } from './pages/search'; 20 20 21 21 export const AppRoutes: Component = () => ( 22 22 <Router root={RootShell}>

+2 -1

src/views/home.tsx src/pages/home.tsx

Reviewed

··· 4 4 import { For, Show, createMemo, createSignal, type Component } from 'solid-js'; 5 5 6 6 import { LoadingState, buttonStyles, cardStyles, inputStyles } from '../components/common'; 7 7 - import { listRepoRecords, resolveActor } from '../lib/api'; 7 7 + import { resolveActor } from '../lib/api/identity'; 8 8 + import { listRepoRecords } from '../lib/api/repos'; 8 9 import { useAuth } from '../lib/auth'; 9 10 import { formatRelativeTime, loadRecentRepos, parseRepoJump } from '../lib/repo-utils'; 10 11

src/views/not-found.tsx src/pages/not-found.tsx

Reviewed

src/views/oauth-callback.tsx src/pages/oauth-callback.tsx

Reviewed

+4 -4

src/views/search.tsx src/pages/search.tsx

Reviewed

··· 17 17 import { For, Match, Show, Switch, createEffect, createMemo, createSignal, type Component, type JSX } from 'solid-js'; 18 18 19 19 import { ErrorState, LoadingState, PaginationControls } from '../components/common'; 20 20 + import { getIssueRecord } from '../lib/api/issues'; 21 21 + import { getPullRecord } from '../lib/api/pulls'; 22 22 + import { getRepoByDid } from '../lib/api/repos'; 20 23 import { 21 21 - getIssueRecord, 22 22 - getPullRecord, 23 23 - getRepoByDid, 24 24 searchRecords, 25 25 type SearchCollection, 26 26 type SearchHit, 27 27 - } from '../lib/api'; 27 27 + } from '../lib/api/search'; 28 28 import { formatRelativeTime, getErrorMessage, issueHref, pullHref } from '../lib/repo-utils'; 29 29 30 30 type SearchKind =