@clioplaylists/clio 0.1.0

package/dist/dataplane/server/routes/profile.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@atproto/common");
+const util_1 = require("../../../util");
+const records_1 = require("./records");
+exports.default = (db) => ({
+    async getActors(req) {
+        const { dids } = req;
+        if (dids.length === 0) {
+            return { actors: [] };
+        }
+        const profileUris = dids.map((did) => `at://${did}/app.bsky.actor.profile/self`);
+        const chatDeclarationUris = dids.map((did) => `at://${did}/chat.bsky.actor.declaration/self`);
+        const [handlesRes, profiles, chatDeclarations] = await Promise.all([
+            db.db.selectFrom('actor').selectAll().execute(),
+            (0, records_1.getRecords)(db)({ uris: profileUris }),
+            (0, records_1.getRecords)(db)({ uris: chatDeclarationUris }),
+        ]);
+        const byDid = (0, common_1.keyBy)(handlesRes, 'did');
+        const actors = dids.map((did, i) => {
+            const row = byDid.get(did);
+            const chatDeclaration = (0, util_1.parseRecordBytes)(chatDeclarations.records[i].record);
+            return {
+                exists: !!row,
+                handle: row?.handle ?? undefined,
+                profile: profiles.records[i],
+                takenDown: !!row?.takedownRef,
+                takedownRef: row?.takedownRef || undefined,
+                tombstonedAt: undefined, // in current implementation, tombstoned actors are deleted
+                allowIncomingChatsFrom: typeof chatDeclaration?.['allowIncoming'] === 'string'
+                    ? chatDeclaration['allowIncoming']
+                    : undefined,
+                upstreamStatus: row?.upstreamStatus ?? '',
+                createdAt: profiles.records[i].createdAt, // @NOTE profile creation date not trusted in production
+            };
+        });
+        return { actors };
+    },
+    async getDidsByHandles(req) {
+        const { handles } = req;
+        if (handles.length === 0) {
+            return { dids: [] };
+        }
+        const res = await db.db
+            .selectFrom('actor')
+            .where('handle', 'in', handles)
+            .selectAll()
+            .execute();
+        const byHandle = (0, common_1.keyBy)(res, 'handle');
+        const dids = handles.map((handle) => byHandle.get(handle)?.did ?? '');
+        return { dids };
+    },
+    async updateActorUpstreamStatus(req) {
+        const { actorDid, upstreamStatus } = req;
+        await db.db
+            .updateTable('actor')
+            .set({ upstreamStatus })
+            .where('did', '=', actorDid)
+            .execute();
+    },
+});

package/dist/dataplane/server/routes/quotes.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pagination_1 = require("../db/pagination");
+exports.default = (db) => ({
+    async getQuotesBySubjectSorted(req) {
+        const { subject, cursor, limit } = req;
+        const { ref } = db.db.dynamic;
+        if (!subject?.uri)
+            return { uris: [] };
+        let builder = db.db
+            .selectFrom('quote')
+            .where('quote.subject', '=', subject.uri)
+            .select(['quote.uri', 'quote.cid', 'quote.sortAt']);
+        const keyset = new pagination_1.TimeCidKeyset(ref('quote.sortAt'), ref('quote.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+        });
+        const quotes = await builder.execute();
+        return {
+            uris: quotes.map((q) => q.uri),
+            cursor: keyset.packFromResult(quotes),
+        };
+    },
+});

package/dist/dataplane/server/routes/records.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRecords = void 0;
+const common_1 = require("@atproto/common");
+const syntax_1 = require("@atproto/syntax");
+const protobuf_1 = require("@bufbuild/protobuf");
+const ui8 = __importStar(require("uint8arrays"));
+const lexicons_1 = require("../../../lexicons/lexicons");
+const clio_pb_1 = require("../../../rpc/clio_pb");
+exports.default = (db) => ({
+    getProfileRecords: (0, exports.getRecords)(db, lexicons_1.ids.ComClioplaylistsAlphaActorProfile),
+});
+const getRecords = (db, collection) => async (req) => {
+    const validUris = collection
+        ? req.uris.filter((uri) => new syntax_1.AtUri(uri).collection === collection)
+        : req.uris;
+    const res = validUris.length
+        ? await db.db
+            .selectFrom('record')
+            .selectAll()
+            .where('uri', 'in', validUris)
+            .execute()
+        : [];
+    const byUri = (0, common_1.keyBy)(res, 'uri');
+    const records = req.uris.map((uri) => {
+        const row = byUri.get(uri);
+        const json = row ? row.json : JSON.stringify(null);
+        const createdAtRaw = new Date(JSON.parse(json)?.['createdAt']);
+        const createdAt = !isNaN(createdAtRaw.getTime())
+            ? protobuf_1.Timestamp.fromDate(createdAtRaw)
+            : undefined;
+        const indexedAt = row?.indexed_at
+            ? protobuf_1.Timestamp.fromDate(new Date(row?.indexed_at))
+            : undefined;
+        const recordBytes = ui8.fromString(json, 'utf8');
+        return new clio_pb_1.Record({
+            record: recordBytes,
+            cid: row?.cid,
+            createdAt,
+            indexedAt,
+            sortedAt: compositeTime(createdAt, indexedAt),
+            takenDown: !!row?.takedown_ref,
+            takedownRef: row?.takedown_ref ?? undefined,
+        });
+    });
+    return { records };
+};
+exports.getRecords = getRecords;
+const compositeTime = (ts1, ts2) => {
+    if (!ts1)
+        return ts2;
+    if (!ts2)
+        return ts1;
+    return ts1.toDate() < ts2.toDate() ? ts1 : ts2;
+};

package/dist/dataplane/server/routes/relationships.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const kysely_1 = require("kysely");
+const common_1 = require("@atproto/common");
+const util_1 = require("../db/util");
+exports.default = (db) => ({
+    async getRelationships(req) {
+        const { actorDid, targetDids } = req;
+        if (targetDids.length === 0) {
+            return { relationships: [] };
+        }
+        const { ref } = db.db.dynamic;
+        const res = await db.db
+            .selectFrom('actor')
+            .where('did', 'in', targetDids)
+            .select([
+            'actor.did',
+            db.db
+                .selectFrom('mute')
+                .where('mute.mutedByDid', '=', actorDid)
+                .whereRef('mute.subjectDid', '=', ref('actor.did'))
+                .select((0, kysely_1.sql) `${true}`.as('val'))
+                .as('muted'),
+            db.db
+                .selectFrom('list_item')
+                .innerJoin('list_mute', 'list_mute.listUri', 'list_item.listUri')
+                .where('list_mute.mutedByDid', '=', actorDid)
+                .whereRef('list_item.subjectDid', '=', ref('actor.did'))
+                .select('list_item.listUri')
+                .as('mutedByList'),
+            db.db
+                .selectFrom('actor_block')
+                .where('actor_block.creator', '=', actorDid)
+                .whereRef('actor_block.subjectDid', '=', ref('actor.did'))
+                .select('uri')
+                .as('blocking'),
+            db.db
+                .selectFrom('actor_block')
+                .where('actor_block.subjectDid', '=', actorDid)
+                .whereRef('actor_block.creator', '=', ref('actor.did'))
+                .select('uri')
+                .as('blockedBy'),
+            db.db
+                .selectFrom('list_item')
+                .innerJoin('list_block', 'list_block.subjectUri', 'list_item.listUri')
+                .where('list_block.creator', '=', actorDid)
+                .whereRef('list_item.subjectDid', '=', ref('actor.did'))
+                .select('list_item.listUri')
+                .as('blockingByList'),
+            db.db
+                .selectFrom('list_item')
+                .innerJoin('list_block', 'list_block.subjectUri', 'list_item.listUri')
+                .where('list_item.subjectDid', '=', actorDid)
+                .whereRef('list_block.creator', '=', ref('actor.did'))
+                .select('list_item.listUri')
+                .as('blockedByList'),
+            db.db
+                .selectFrom('follow')
+                .where('follow.creator', '=', actorDid)
+                .whereRef('follow.subjectDid', '=', ref('actor.did'))
+                .select('uri')
+                .as('following'),
+            db.db
+                .selectFrom('follow')
+                .where('follow.subjectDid', '=', actorDid)
+                .whereRef('follow.creator', '=', ref('actor.did'))
+                .select('uri')
+                .as('followedBy'),
+        ])
+            .execute();
+        const byDid = (0, common_1.keyBy)(res, 'did');
+        const relationships = targetDids.map((did) => {
+            const row = byDid.get(did);
+            return {
+                muted: row?.muted ?? false,
+                mutedByList: row?.mutedByList ?? '',
+                blockedBy: row?.blockedBy ?? '',
+                blocking: row?.blocking ?? '',
+                blockedByList: row?.blockedByList ?? '',
+                blockingByList: row?.blockingByList ?? '',
+                following: row?.following ?? '',
+                followedBy: row?.followedBy ?? '',
+            };
+        });
+        return { relationships };
+    },
+    async getBlockExistence(req) {
+        const { pairs } = req;
+        if (pairs.length === 0) {
+            return { exists: [], blocks: [] };
+        }
+        const { ref } = db.db.dynamic;
+        const sourceRef = ref('pair.source');
+        const targetRef = ref('pair.target');
+        const values = (0, util_1.valuesList)(pairs.map((p) => (0, kysely_1.sql) `${p.a}, ${p.b}`));
+        const res = await db.db
+            .selectFrom(values.as((0, kysely_1.sql) `pair (source, target)`))
+            .select([
+            (0, kysely_1.sql) `${sourceRef}`.as('source'),
+            (0, kysely_1.sql) `${targetRef}`.as('target'),
+            (eb) => eb
+                .selectFrom('actor_block')
+                .whereRef('actor_block.creator', '=', sourceRef)
+                .whereRef('actor_block.subjectDid', '=', targetRef)
+                .select('uri')
+                .as('blocking'),
+            (eb) => eb
+                .selectFrom('actor_block')
+                .whereRef('actor_block.creator', '=', targetRef)
+                .whereRef('actor_block.subjectDid', '=', sourceRef)
+                .select('uri')
+                .as('blockedBy'),
+            (eb) => eb
+                .selectFrom('list_item')
+                .innerJoin('list_block', 'list_block.subjectUri', 'list_item.listUri')
+                .whereRef('list_block.creator', '=', sourceRef)
+                .whereRef('list_item.subjectDid', '=', targetRef)
+                .select('list_item.listUri')
+                .as('blockingByList'),
+            (eb) => eb
+                .selectFrom('list_item')
+                .innerJoin('list_block', 'list_block.subjectUri', 'list_item.listUri')
+                .whereRef('list_block.creator', '=', targetRef)
+                .whereRef('list_item.subjectDid', '=', sourceRef)
+                .select('list_item.listUri')
+                .as('blockedByList'),
+        ])
+            .execute();
+        const getKey = (a, b) => [a, b].sort().join(',');
+        const lookup = res.reduce((acc, cur) => {
+            const key = getKey(cur.source, cur.target);
+            return acc.set(key, cur);
+        }, new Map());
+        return {
+            exists: pairs.map((pair) => {
+                const item = lookup.get(getKey(pair.a, pair.b));
+                if (!item)
+                    return false;
+                return !!(item.blocking ||
+                    item.blockedBy ||
+                    item.blockingByList ||
+                    item.blockedByList);
+            }),
+            blocks: pairs.map((pair) => {
+                const item = lookup.get(getKey(pair.a, pair.b));
+                if (!item)
+                    return {};
+                return {
+                    blockedBy: item.blockedBy || undefined,
+                    blocking: item.blocking || undefined,
+                    blockedByList: item.blockedByList || undefined,
+                    blockingByList: item.blockingByList || undefined,
+                };
+            }),
+        };
+    },
+});

package/dist/dataplane/server/routes/reposts.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@atproto/common");
+const pagination_1 = require("../db/pagination");
+exports.default = (db) => ({
+    async getRepostsBySubject(req) {
+        const { subject, cursor, limit } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('repost')
+            .where('repost.subject', '=', subject?.uri ?? '')
+            .selectAll('repost');
+        const keyset = new pagination_1.TimeCidKeyset(ref('repost.sortAt'), ref('repost.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+        });
+        const reposts = await builder.execute();
+        return {
+            uris: reposts.map((l) => l.uri),
+            cursor: keyset.packFromResult(reposts),
+        };
+    },
+    async getRepostsByActorAndSubjects(req) {
+        const { actorDid, refs } = req;
+        if (refs.length === 0) {
+            return { uris: [] };
+        }
+        const res = await db.db
+            .selectFrom('repost')
+            .where('creator', '=', actorDid)
+            .where('subject', 'in', refs.map(({ uri }) => uri))
+            .selectAll()
+            .execute();
+        const bySubject = (0, common_1.keyBy)(res, 'subject');
+        const uris = refs.map(({ uri }) => bySubject.get(uri)?.uri ?? '');
+        return { uris };
+    },
+    async getActorReposts(req) {
+        const { actorDid, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('repost')
+            .where('repost.creator', '=', actorDid)
+            .selectAll();
+        const keyset = new pagination_1.TimeCidKeyset(ref('repost.sortAt'), ref('repost.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+        });
+        const reposts = await builder.execute();
+        return {
+            uris: reposts.map((l) => l.uri),
+            cursor: keyset.packFromResult(reposts),
+        };
+    },
+});

package/dist/dataplane/server/routes/search.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pagination_1 = require("../db/pagination");
+exports.default = (db) => ({
+    // @TODO actor search endpoints still fall back to search service
+    async searchActors(req) {
+        const { term, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('actor')
+            .where('actor.handle', 'like', `%${cleanQuery(term)}%`)
+            .selectAll();
+        const keyset = new pagination_1.IndexedAtDidKeyset(ref('actor.indexedAt'), ref('actor.did'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+            tryIndex: true,
+        });
+        const res = await builder.execute();
+        return {
+            dids: res.map((row) => row.did),
+            cursor: keyset.packFromResult(res),
+        };
+    },
+    // @TODO post search endpoint still falls back to search service
+    async searchPosts(req) {
+        const { term, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('post')
+            .where('post.text', 'like', `%${term}%`)
+            .selectAll();
+        const keyset = new pagination_1.TimeCidKeyset(ref('post.sortAt'), ref('post.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+            tryIndex: true,
+        });
+        const res = await builder.execute();
+        return {
+            uris: res.map((row) => row.uri),
+            cursor: keyset.packFromResult(res),
+        };
+    },
+    async searchStarterPacks(req) {
+        const { term, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('starter_pack')
+            .where('starter_pack.name', 'ilike', `%${term}%`)
+            .selectAll();
+        const keyset = new pagination_1.TimeCidKeyset(ref('starter_pack.sortAt'), ref('starter_pack.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+            tryIndex: true,
+        });
+        const res = await builder.execute();
+        const cur = keyset.packFromResult(res);
+        return {
+            uris: res.map((row) => row.uri),
+            cursor: cur,
+        };
+    },
+});
+// Remove leading @ in case a handle is input that way
+const cleanQuery = (query) => query.trim().replace(/^@/g, '');

package/dist/dataplane/server/routes/starter-packs.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pagination_1 = require("../db/pagination");
+exports.default = (db) => ({
+    async getActorStarterPacks(req) {
+        const { actorDid, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('starter_pack')
+            .selectAll()
+            .where('creator', '=', actorDid);
+        const keyset = new pagination_1.TimeCidKeyset(ref('starter_pack.sortAt'), ref('starter_pack.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+        });
+        const starterPacks = await builder.execute();
+        return {
+            uris: starterPacks.map((sp) => sp.uri),
+            cursor: keyset.packFromResult(starterPacks),
+        };
+    },
+});

package/dist/dataplane/server/routes/suggestions.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const kysely_1 = require("kysely");
+exports.default = (db) => ({
+    async getFollowSuggestions(req) {
+        const { actorDid, relativeToDid, cursor, limit } = req;
+        if (relativeToDid) {
+            return getFollowSuggestionsRelativeTo(db, {
+                actorDid,
+                relativeToDid,
+                cursor: cursor || undefined,
+                limit: limit || undefined,
+            });
+        }
+        else {
+            return getFollowSuggestionsGlobal(db, {
+                actorDid,
+                cursor: cursor || undefined,
+                limit: limit || undefined,
+            });
+        }
+    },
+    async getSuggestedEntities() {
+        const entities = await db.db
+            .selectFrom('tagged_suggestion')
+            .selectAll()
+            .execute();
+        return {
+            entities,
+        };
+    },
+});
+const getFollowSuggestionsGlobal = async (db, input) => {
+    const alreadyIncluded = parseCursor(input.cursor);
+    const suggestions = await db.db
+        .selectFrom('suggested_follow')
+        .innerJoin('actor', 'actor.did', 'suggested_follow.did')
+        .if(alreadyIncluded.length > 0, (qb) => qb.where('suggested_follow.order', 'not in', alreadyIncluded))
+        .selectAll()
+        .orderBy('suggested_follow.order', 'asc')
+        .execute();
+    // always include first two
+    const firstTwo = suggestions.filter((row) => row.order === 1 || row.order === 2);
+    const rest = suggestions.filter((row) => row.order !== 1 && row.order !== 2);
+    const limited = firstTwo.concat(shuffle(rest)).slice(0, input.limit);
+    // if the result set ends up getting larger, consider using a seed included in the cursor for for the randomized shuffle
+    const cursor = limited.length > 0
+        ? limited
+            .map((row) => row.order.toString())
+            .concat(alreadyIncluded.map((id) => id.toString()))
+            .join(':')
+        : undefined;
+    return {
+        dids: limited.map((s) => s.did),
+        cursor,
+    };
+};
+const getFollowSuggestionsRelativeTo = async (db, input) => {
+    if (input.cursor)
+        return { dids: [] };
+    const limit = input.limit ? Math.min(10, input.limit) : 10;
+    const actorsViewerFollows = db.db
+        .selectFrom('follow')
+        .where('creator', '=', input.actorDid)
+        .select('subjectDid');
+    const mostLikedAccounts = await db.db
+        .selectFrom(db.db
+        .selectFrom('like')
+        .where('creator', '=', input.relativeToDid)
+        .select((0, kysely_1.sql) `split_part(subject, '/', 3)`.as('subjectDid'))
+        .orderBy('sortAt', 'desc')
+        .limit(1000) // limit to 1000
+        .as('likes'))
+        .select('likes.subjectDid as did')
+        .select((qb) => qb.fn.count('likes.subjectDid').as('count'))
+        .where('likes.subjectDid', 'not in', actorsViewerFollows)
+        .where('likes.subjectDid', 'not in', [input.actorDid, input.relativeToDid])
+        .groupBy('likes.subjectDid')
+        .orderBy('count', 'desc')
+        .limit(limit)
+        .execute();
+    const resultDids = mostLikedAccounts.map((a) => ({ did: a.did }));
+    if (resultDids.length < limit) {
+        // backfill with popular accounts followed by actor
+        const mostPopularAccountsActorFollows = await db.db
+            .selectFrom('follow')
+            .innerJoin('profile_agg', 'follow.subjectDid', 'profile_agg.did')
+            .select('follow.subjectDid as did')
+            .where('follow.creator', '=', input.actorDid)
+            .where('follow.subjectDid', '!=', input.relativeToDid)
+            .where('follow.subjectDid', 'not in', actorsViewerFollows)
+            .if(resultDids.length > 0, (qb) => qb.where('subjectDid', 'not in', resultDids.map((a) => a.did)))
+            .orderBy('profile_agg.followersCount', 'desc')
+            .limit(limit)
+            .execute();
+        resultDids.push(...mostPopularAccountsActorFollows);
+    }
+    if (resultDids.length < limit) {
+        // backfill with suggested_follow table
+        const additional = await db.db
+            .selectFrom('suggested_follow')
+            .where('did', 'not in', 
+        // exclude any we already have
+        resultDids
+            .map((a) => a.did)
+            .concat([input.actorDid, input.relativeToDid]))
+            // and aren't already followed by viewer
+            .where('did', 'not in', actorsViewerFollows)
+            .selectAll()
+            .execute();
+        resultDids.push(...additional);
+    }
+    return { dids: resultDids.map((x) => x.did) };
+};
+const parseCursor = (cursor) => {
+    if (!cursor) {
+        return [];
+    }
+    try {
+        return cursor
+            .split(':')
+            .map((id) => parseInt(id, 10))
+            .filter((id) => !isNaN(id));
+    }
+    catch {
+        return [];
+    }
+};
+const shuffle = (arr) => {
+    return arr
+        .map((value) => ({ value, sort: Math.random() }))
+        .sort((a, b) => a.sort - b.sort)
+        .map(({ value }) => value);
+};

package/dist/dataplane/server/routes/sync.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (db) => ({
+    async getLatestRev(req) {
+        const res = await db.db
+            .selectFrom('actor_sync')
+            .where('did', '=', req.actorDid)
+            .select('repoRev')
+            .executeTakeFirst();
+        return {
+            rev: res?.repoRev ?? undefined,
+        };
+    },
+});

package/dist/dataplane/server/routes/threads.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+exports.default = (db) => ({
+    async getThread(req) {
+        const { postUri, above, below } = req;
+        const [ancestors, descendents] = await Promise.all([
+            (0, util_1.getAncestorsAndSelfQb)(db.db, {
+                uri: postUri,
+                parentHeight: above,
+            })
+                .selectFrom('ancestor')
+                .selectAll()
+                .execute(),
+            (0, util_1.getDescendentsQb)(db.db, {
+                uri: postUri,
+                depth: below,
+            })
+                .selectFrom('descendent')
+                .innerJoin('post', 'post.uri', 'descendent.uri')
+                .orderBy('post.sortAt', 'desc')
+                .selectAll()
+                .execute(),
+        ]);
+        const uris = [
+            ...ancestors.map((p) => p.uri),
+            ...descendents.map((p) => p.uri),
+        ];
+        return { uris };
+    },
+});