-
-
-
+
+
+
+
+
+
+
+ {#if selectedClient}
+
+ {:else}
+
+
+ select or add an account to post
+
+
+ {/if}
+
+
+
+
+
+ {#each sortedTimeline as [postUri, data] (postUri)}
+ {@const parsedUri = expect(parseCanonicalResourceUri(postUri))}
+
+ {/each}
+
+
diff --git a/src/lib/at/client.ts b/src/lib/at/client.ts
--- a/src/lib/at/client.ts
+++ b/src/lib/at/client.ts
@@ -1,8 +1,20 @@
-import { err, map, ok, type Result } from '$lib/result';
-import { ComAtprotoIdentityResolveIdentity, ComAtprotoRepoGetRecord } from '@atcute/atproto';
+import { err, expect, map, ok, type Result } from '$lib/result';
+import {
+ ComAtprotoIdentityResolveHandle,
+ ComAtprotoRepoGetRecord,
+ ComAtprotoRepoListRecords
+} from '@atcute/atproto';
import { Client as AtcuteClient, CredentialManager } from '@atcute/client';
import { safeParse, type Handle, type InferOutput } from '@atcute/lexicons';
-import type { ActorIdentifier, AtprotoDid, Nsid, RecordKey } from '@atcute/lexicons/syntax';
+import {
+ isHandle,
+ parseCanonicalResourceUri,
+ type ActorIdentifier,
+ type AtprotoDid,
+ type CanonicalResourceUri,
+ type Nsid,
+ type RecordKey
+} from '@atcute/lexicons/syntax';
import type {
InferXRPCBodyOutput,
ObjectSchema,
@@ -11,39 +23,29 @@
XRPCQueryMetadata
} from '@atcute/lexicons/validations';
import * as v from '@atcute/lexicons/validations';
-import { LRUCache } from 'lru-cache';
-
-export const MiniDocQuery = v.query('com.bad-example.identity.resolveMiniDoc', {
- params: v.object({
- identifier: v.actorIdentifierString()
- }),
- output: {
- type: 'lex',
- schema: v.object({
- did: v.didString(),
- handle: v.handleString(),
- pds: v.genericUriString(),
- signing_key: v.string()
- })
- }
-});
-export type MiniDoc = InferOutput
;
+import { MiniDocQuery, type MiniDoc } from './slingshot';
+import { BacklinksQuery, type Backlinks, type BacklinksSource } from './constellation';
+import type { Records } from '@atcute/lexicons/ambient';
+import { PersistedLRU } from '$lib/cache';
const cacheTtl = 1000 * 60 * 60 * 24;
-const handleCache = new LRUCache({
+const handleCache = new PersistedLRU({
max: 1000,
- ttl: cacheTtl
+ ttl: cacheTtl,
+ prefix: 'handle'
});
-const didDocCache = new LRUCache({
+const didDocCache = new PersistedLRU({
max: 1000,
- ttl: cacheTtl
+ ttl: cacheTtl,
+ prefix: 'didDoc'
});
-const recordCache = new LRUCache<
+const recordCache = new PersistedLRU<
string,
InferOutput
>({
max: 5000,
- ttl: cacheTtl
+ ttl: cacheTtl,
+ prefix: 'record'
});
export class AtpClient {
@@ -52,6 +54,7 @@
private slingshotUrl: URL = new URL('https://slingshot.microcosm.blue');
private spacedustUrl: URL = new URL('https://spacedust.microcosm.blue');
+ private constellationUrl: URL = new URL('https://constellation.microcosm.blue');
async login(handle: Handle, password: string): Promise> {
const didDoc = await this.resolveDidDoc(handle);
@@ -101,15 +104,36 @@
return ok(parsed.value as Output);
}
+ async listRecords(
+ collection: Collection,
+ repo: ActorIdentifier,
+ cursor?: string,
+ limit?: number
+ ): Promise<
+ Result, string>
+ > {
+ if (!this.atcute) return err('not authenticated');
+ const res = await this.atcute.get('com.atproto.repo.listRecords', {
+ params: {
+ repo,
+ collection,
+ cursor,
+ limit
+ }
+ });
+ if (!res.ok) return err(`${res.data.error}: ${res.data.message ?? 'no details'}`);
+ return ok(res.data);
+ }
+
async resolveHandle(handle: Handle): Promise> {
const cached = handleCache.get(handle);
if (cached) return ok(cached);
const res = await fetchMicrocosm(
this.slingshotUrl,
- ComAtprotoIdentityResolveIdentity.mainSchema,
+ ComAtprotoIdentityResolveHandle.mainSchema,
{
- handle: handle
+ handle
}
);
@@ -136,24 +160,57 @@
return result;
}
+
+ async getBacklinksUri(
+ uri: CanonicalResourceUri,
+ source: BacklinksSource
+ ): Promise> {
+ const parsedResourceUri = expect(parseCanonicalResourceUri(uri));
+ return await this.getBacklinks(
+ parsedResourceUri.repo,
+ parsedResourceUri.collection,
+ parsedResourceUri.rkey,
+ source
+ );
+ }
+
+ async getBacklinks(
+ repo: ActorIdentifier,
+ collection: Nsid,
+ rkey: RecordKey,
+ source: BacklinksSource
+ ): Promise> {
+ let did = repo;
+ if (isHandle(did)) {
+ const resolvedDid = await this.resolveHandle(did);
+ if (!resolvedDid.ok) {
+ return err(`failed to resolve handle: ${resolvedDid.error}`);
+ }
+ did = resolvedDid.value;
+ }
+ return await fetchMicrocosm(this.constellationUrl, BacklinksQuery, {
+ subject: `at://${did}/${collection}/${rkey}`,
+ source,
+ limit: 100
+ });
+ }
}
const fetchMicrocosm = async <
Schema extends XRPCQueryMetadata,
+ Input extends Schema['params'] extends ObjectSchema ? InferOutput : undefined,
Output extends InferXRPCBodyOutput
>(
api: URL,
schema: Schema,
- params?: URLSearchParams | Record,
+ params: Input,
init?: RequestInit
): Promise> => {
if (!schema.output || schema.output.type === 'blob') return err('schema must be blob');
- if (params && !(params instanceof URLSearchParams)) params = new URLSearchParams(params);
- if (params?.size === 0) params = undefined;
try {
api.pathname = `/xrpc/${schema.nsid}`;
- api.search = params ? `?${params}` : '';
- // console.info(`fetching:`, api.href);
+ api.search = params ? `?${new URLSearchParams(params)}` : '';
+ console.info(`fetching:`, api.href);
const response = await fetch(api, init);
const body = await response.json();
if (response.status === 400) return err(`${body.error}: ${body.message}`);
diff --git a/src/lib/at/constellation.ts b/src/lib/at/constellation.ts
new file mode 100644
--- /dev/null
+++ b/src/lib/at/constellation.ts
@@ -0,0 +1,27 @@
+import type { Nsid } from '@atcute/lexicons';
+import * as v from '@atcute/lexicons/validations';
+
+export type BacklinksSource = `${Nsid}:${string}`;
+export const BacklinkSchema = v.object({
+ did: v.didString(),
+ collection: v.nsidString(),
+ rkey: v.recordKeyString()
+});
+export const BacklinksQuery = v.query('blue.microcosm.links.getBacklinks', {
+ params: v.object({
+ subject: v.resourceUriString(),
+ source: v.string(),
+ did: v.optional(v.array(v.didString())),
+ limit: v.optional(v.integer())
+ }),
+ output: {
+ type: 'lex',
+ schema: v.object({
+ total: v.integer(),
+ records: v.array(BacklinkSchema),
+ cursor: v.nullable(v.string())
+ })
+ }
+});
+export type Backlink = v.InferOutput;
+export type Backlinks = v.InferOutput;
diff --git a/src/lib/at/fetch.ts b/src/lib/at/fetch.ts
--- a/src/lib/at/fetch.ts
+++ b/src/lib/at/fetch.ts
@@ -0,0 +1,59 @@
+import type { ActorIdentifier, CanonicalResourceUri } from '@atcute/lexicons';
+import type { AtpClient } from './client';
+import { err, map, ok, type Result } from '$lib/result';
+import type { Backlinks } from './constellation';
+import { AppBskyFeedPost } from '@atcute/bluesky';
+
+export type PostWithBacklinks = {
+ post: AppBskyFeedPost.Main;
+ replies: Backlinks | string;
+};
+export type PostsWithReplyBacklinks = Map;
+
+export const fetchPostsWithReplyBacklinks = async (
+ client: AtpClient,
+ repo: ActorIdentifier,
+ cursor?: string,
+ limit?: number
+): Promise> => {
+ const recordsList = await client.listRecords('app.bsky.feed.post', repo, cursor, limit);
+ if (!recordsList.ok) return err(`can't retrieve posts: ${recordsList.error}`);
+ cursor = recordsList.value.cursor;
+ const records = recordsList.value.records;
+
+ const allBacklinks = await Promise.all(
+ records.map((r) =>
+ client
+ .getBacklinksUri(r.uri as CanonicalResourceUri, 'app.bsky.feed.post:reply.parent.uri')
+ .then((res) => ({
+ key: r.uri as CanonicalResourceUri,
+ value: {
+ post: r.value as AppBskyFeedPost.Main,
+ replies: res.ok ? res.value : res.error
+ }
+ }))
+ )
+ );
+
+ return ok({ posts: new Map(allBacklinks.map((b) => [b.key, b.value])), cursor });
+};
+
+export const fetchReplies = async (client: AtpClient, data: PostsWithReplyBacklinks) => {
+ const allReplies = await Promise.all(
+ Array.from(data.values()).map(async (d) => {
+ if (typeof d.replies === 'string') return [];
+ const replies = await Promise.all(
+ d.replies.records.map((r) =>
+ client
+ .getRecord(AppBskyFeedPost.mainSchema, r.did, r.rkey)
+ .then((res) =>
+ map(res, (d) => ({ uri: `at://${r.did}/app.bsky.feed.post/${r.rkey}`, record: d }))
+ )
+ )
+ );
+ return replies;
+ })
+ );
+
+ return allReplies.flat();
+};
diff --git a/src/lib/at/slingshot.ts b/src/lib/at/slingshot.ts
new file mode 100644
--- /dev/null
+++ b/src/lib/at/slingshot.ts
@@ -0,0 +1,17 @@
+import * as v from '@atcute/lexicons/validations';
+
+export const MiniDocQuery = v.query('com.bad-example.identity.resolveMiniDoc', {
+ params: v.object({
+ identifier: v.actorIdentifierString()
+ }),
+ output: {
+ type: 'lex',
+ schema: v.object({
+ did: v.didString(),
+ handle: v.handleString(),
+ pds: v.genericUriString(),
+ signing_key: v.string()
+ })
+ }
+});
+export type MiniDoc = v.InferOutput;