@clioplaylists/clio 0.1.0

package/dist/dataplane/server/indexing/processor.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordProcessor = void 0;
+const lexicon_1 = require("@atproto/lexicon");
+const lexicons_1 = require("../../../lexicons/lexicons");
+class RecordProcessor {
+    constructor(appDb, params) {
+        Object.defineProperty(this, "params", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: params
+        });
+        Object.defineProperty(this, "collection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.db = appDb.db;
+        this.collection = this.params.lexId;
+    }
+    matchesSchema(obj) {
+        try {
+            this.assertValidRecord(obj);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    assertValidRecord(obj) {
+        lexicons_1.lexicons.assertValidRecord(this.params.lexId, obj);
+    }
+    async insertRecord(uri, cid, obj, timestamp) {
+        this.assertValidRecord(obj);
+        await this.db
+            .insertInto('record')
+            .values({
+            uri: uri.toString(),
+            cid: cid.toString(),
+            did: uri.host,
+            json: (0, lexicon_1.stringifyLex)(obj),
+            indexed_at: timestamp,
+        })
+            .onConflict((oc) => oc.doNothing())
+            .execute();
+        await this.params.insertFn(this.db, uri, cid, obj, timestamp);
+    }
+    // Currently using a very simple strategy for updates: purge the existing index
+    // for the uri then replace it. The main upside is that this allows the indexer
+    // for each collection to avoid bespoke logic for in-place updates, which isn't
+    // straightforward in the general case. We still get nice control over notifications.
+    async updateRecord(uri, cid, obj, timestamp) {
+        this.assertValidRecord(obj);
+        await this.db
+            .updateTable('record')
+            .where('uri', '=', uri.toString())
+            .set({
+            cid: cid.toString(),
+            json: (0, lexicon_1.stringifyLex)(obj),
+            indexed_at: timestamp,
+        })
+            .execute();
+        const deleted = await this.params.deleteFn(this.db, uri);
+        if (!deleted) {
+            // If a record was updated but hadn't been indexed yet, treat it like a plain insert.
+            return this.insertRecord(uri, cid, obj, timestamp);
+        }
+        const inserted = await this.params.insertFn(this.db, uri, cid, obj, timestamp);
+        if (!inserted) {
+            throw new Error('Record update failed: removed from index but could not be replaced');
+        }
+    }
+    async deleteRecord(uri, cascading = false) {
+        await this.db
+            .deleteFrom('record')
+            .where('uri', '=', uri.toString())
+            .execute();
+        await this.params.deleteFn(this.db, uri);
+    }
+}
+exports.RecordProcessor = RecordProcessor;
+exports.default = RecordProcessor;

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pagination_1 = require("../db/pagination");
+exports.default = (db) => ({
+    async getBidirectionalBlock(req) {
+        const { actorDid, targetDid } = req;
+        const res = await db.db
+            .selectFrom('actor_block')
+            .where((qb) => qb
+            .where('actor_block.creator', '=', actorDid)
+            .where('actor_block.subjectDid', '=', targetDid))
+            .orWhere((qb) => qb
+            .where('actor_block.creator', '=', targetDid)
+            .where('actor_block.subjectDid', '=', actorDid))
+            .limit(1)
+            .selectAll()
+            .executeTakeFirst();
+        return {
+            blockUri: res?.uri,
+        };
+    },
+    async getBlocks(req) {
+        const { actorDid, cursor, limit } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('actor_block')
+            .where('actor_block.creator', '=', actorDid)
+            .selectAll();
+        const keyset = new pagination_1.TimeCidKeyset(ref('actor_block.sortAt'), ref('actor_block.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+        });
+        const blocks = await builder.execute();
+        return {
+            blockUris: blocks.map((b) => b.uri),
+            cursor: keyset.packFromResult(blocks),
+        };
+    },
+    async getBidirectionalBlockViaList(req) {
+        const { actorDid, targetDid } = req;
+        const res = await db.db
+            .selectFrom('list_block')
+            .innerJoin('list_item', 'list_item.listUri', 'list_block.subjectUri')
+            .where((qb) => qb
+            .where('list_block.creator', '=', actorDid)
+            .where('list_item.subjectDid', '=', targetDid))
+            .orWhere((qb) => qb
+            .where('list_block.creator', '=', targetDid)
+            .where('list_item.subjectDid', '=', actorDid))
+            .limit(1)
+            .selectAll('list_block')
+            .executeTakeFirst();
+        return {
+            listUri: res?.subjectUri,
+        };
+    },
+    async getBlocklistSubscription(req) {
+        const { actorDid, listUri } = req;
+        const res = await db.db
+            .selectFrom('list_block')
+            .where('creator', '=', actorDid)
+            .where('subjectUri', '=', listUri)
+            .selectAll()
+            .limit(1)
+            .executeTakeFirst();
+        return {
+            listblockUri: res?.uri,
+        };
+    },
+    async getBlocklistSubscriptions(req) {
+        const { actorDid, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('list')
+            .whereExists(db.db
+            .selectFrom('list_block')
+            .where('list_block.creator', '=', actorDid)
+            .whereRef('list_block.subjectUri', '=', ref('list.uri'))
+            .selectAll())
+            .selectAll('list');
+        const keyset = new pagination_1.TimeCidKeyset(ref('list.createdAt'), ref('list.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+        });
+        const lists = await builder.execute();
+        return {
+            listUris: lists.map((l) => l.uri),
+            cursor: keyset.packFromResult(lists),
+        };
+    },
+});

package/dist/dataplane/server/routes/feed-gens.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pagination_1 = require("../db/pagination");
+exports.default = (db) => ({
+    async getActorFeeds(req) {
+        const { actorDid, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('feed_generator')
+            .selectAll()
+            .where('feed_generator.creator', '=', actorDid);
+        const keyset = new pagination_1.TimeCidKeyset(ref('feed_generator.createdAt'), ref('feed_generator.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+        });
+        const feeds = await builder.execute();
+        return {
+            uris: feeds.map((f) => f.uri),
+            cursor: keyset.packFromResult(feeds),
+        };
+    },
+    async getSuggestedFeeds(req) {
+        const feeds = await db.db
+            .selectFrom('suggested_feed')
+            .orderBy('suggested_feed.order', 'asc')
+            .if(!!req.cursor, (q) => q.where('order', '>', parseInt(req.cursor, 10)))
+            .limit(req.limit || 50)
+            .selectAll()
+            .execute();
+        return {
+            uris: feeds.map((f) => f.uri),
+            cursor: feeds.at(-1)?.order.toString(),
+        };
+    },
+    async searchFeedGenerators(req) {
+        const { ref } = db.db.dynamic;
+        const limit = req.limit;
+        const query = req.query.trim();
+        let builder = db.db
+            .selectFrom('feed_generator')
+            .if(!!query, (q) => q.where('displayName', 'ilike', `%${query}%`))
+            .selectAll();
+        const keyset = new pagination_1.TimeCidKeyset(ref('feed_generator.createdAt'), ref('feed_generator.cid'));
+        builder = (0, pagination_1.paginate)(builder, { limit, keyset });
+        const feeds = await builder.execute();
+        return {
+            uris: feeds.map((f) => f.uri),
+            cursor: keyset.packFromResult(feeds),
+        };
+    },
+    async getFeedGeneratorStatus() {
+        throw new Error('unimplemented');
+    },
+});

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

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bsky_pb_1 = require("../../../proto/bsky_pb");
+const pagination_1 = require("../db/pagination");
+exports.default = (db) => ({
+    async getAuthorFeed(req) {
+        const { actorDid, limit, cursor, feedType } = req;
+        const { ref } = db.db.dynamic;
+        // defaults to posts, reposts, and replies
+        let builder = db.db
+            .selectFrom('feed_item')
+            .innerJoin('post', 'post.uri', 'feed_item.postUri')
+            .selectAll('feed_item')
+            .where('originatorDid', '=', actorDid);
+        if (feedType === bsky_pb_1.FeedType.POSTS_WITH_MEDIA) {
+            builder = builder
+                // only your own posts
+                .where('type', '=', 'post')
+                // only posts with media
+                .whereExists((qb) => qb
+                .selectFrom('post_embed_image')
+                .select('post_embed_image.postUri')
+                .whereRef('post_embed_image.postUri', '=', 'feed_item.postUri'));
+        }
+        else if (feedType === bsky_pb_1.FeedType.POSTS_WITH_VIDEO) {
+            builder = builder
+                // only your own posts
+                .where('type', '=', 'post')
+                // only posts with video
+                .whereExists((qb) => qb
+                .selectFrom('post_embed_video')
+                .select('post_embed_video.postUri')
+                .whereRef('post_embed_video.postUri', '=', 'feed_item.postUri'));
+        }
+        else if (feedType === bsky_pb_1.FeedType.POSTS_NO_REPLIES) {
+            builder = builder.where((qb) => qb.where('post.replyParent', 'is', null).orWhere('type', '=', 'repost'));
+        }
+        else if (feedType === bsky_pb_1.FeedType.POSTS_AND_AUTHOR_THREADS) {
+            builder = builder.where((qb) => qb
+                .where('type', '=', 'repost')
+                .orWhere('post.replyParent', 'is', null)
+                .orWhere('post.replyRoot', 'like', `at://${actorDid}/%`));
+        }
+        const keyset = new pagination_1.TimeCidKeyset(ref('feed_item.sortAt'), ref('feed_item.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+        });
+        const feedItems = await builder.execute();
+        return {
+            items: feedItems.map(feedItemFromRow),
+            cursor: keyset.packFromResult(feedItems),
+        };
+    },
+    async getTimeline(req) {
+        const { actorDid, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        const keyset = new pagination_1.TimeCidKeyset(ref('feed_item.sortAt'), ref('feed_item.cid'));
+        let followQb = db.db
+            .selectFrom('feed_item')
+            .innerJoin('follow', 'follow.subjectDid', 'feed_item.originatorDid')
+            .where('follow.creator', '=', actorDid)
+            .selectAll('feed_item');
+        followQb = (0, pagination_1.paginate)(followQb, {
+            limit,
+            cursor,
+            keyset,
+            tryIndex: true,
+        });
+        let selfQb = db.db
+            .selectFrom('feed_item')
+            .where('feed_item.originatorDid', '=', actorDid)
+            .selectAll('feed_item');
+        selfQb = (0, pagination_1.paginate)(selfQb, {
+            limit: Math.min(limit, 10),
+            cursor,
+            keyset,
+            tryIndex: true,
+        });
+        const [followRes, selfRes] = await Promise.all([
+            followQb.execute(),
+            selfQb.execute(),
+        ]);
+        const feedItems = [...followRes, ...selfRes]
+            .sort((a, b) => {
+            if (a.sortAt > b.sortAt)
+                return -1;
+            if (a.sortAt < b.sortAt)
+                return 1;
+            return a.cid > b.cid ? -1 : 1;
+        })
+            .slice(0, limit);
+        return {
+            items: feedItems.map(feedItemFromRow),
+            cursor: keyset.packFromResult(feedItems),
+        };
+    },
+    async getListFeed(req) {
+        const { listUri, cursor, limit } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('post')
+            .selectAll('post')
+            .innerJoin('list_item', 'list_item.subjectDid', 'post.creator')
+            .where('list_item.listUri', '=', listUri);
+        const keyset = new pagination_1.TimeCidKeyset(ref('post.sortAt'), ref('post.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+            tryIndex: true,
+        });
+        const feedItems = await builder.execute();
+        return {
+            items: feedItems.map((item) => ({ uri: item.uri, cid: item.cid })),
+            cursor: keyset.packFromResult(feedItems),
+        };
+    },
+});
+// @NOTE does not support additional fields in the protos specific to author feeds
+// and timelines. at the time of writing, hydration/view implementations do not rely on them.
+const feedItemFromRow = (row) => {
+    return {
+        uri: row.postUri,
+        repost: row.uri === row.postUri ? undefined : row.uri,
+    };
+};

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@atproto/common");
+const bsky_pb_1 = require("../../../proto/bsky_pb");
+const pagination_1 = require("../db/pagination");
+exports.default = (db) => ({
+    async getActorFollowsActors(req) {
+        const { actorDid, targetDids } = req;
+        if (targetDids.length < 1) {
+            return { uris: [] };
+        }
+        const res = await db.db
+            .selectFrom('follow')
+            .where('follow.creator', '=', actorDid)
+            .where('follow.subjectDid', 'in', targetDids)
+            .selectAll()
+            .execute();
+        const bySubject = (0, common_1.keyBy)(res, 'subjectDid');
+        const uris = targetDids.map((did) => bySubject.get(did)?.uri ?? '');
+        return {
+            uris,
+        };
+    },
+    async getFollowers(req) {
+        const { actorDid, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        let followersReq = db.db
+            .selectFrom('follow')
+            .where('follow.subjectDid', '=', actorDid)
+            .innerJoin('actor as creator', 'creator.did', 'follow.creator')
+            .selectAll('creator')
+            .select([
+            'follow.uri as uri',
+            'follow.cid as cid',
+            'follow.creator as creatorDid',
+            'follow.subjectDid as subjectDid',
+            'follow.sortAt as sortAt',
+        ]);
+        const keyset = new pagination_1.TimeCidKeyset(ref('follow.sortAt'), ref('follow.cid'));
+        followersReq = (0, pagination_1.paginate)(followersReq, {
+            limit,
+            cursor,
+            keyset,
+            tryIndex: true,
+        });
+        const followers = await followersReq.execute();
+        return {
+            followers: followers.map((f) => ({
+                uri: f.uri,
+                actorDid: f.creatorDid,
+                subjectDid: f.subjectDid,
+            })),
+            cursor: keyset.packFromResult(followers),
+        };
+    },
+    async getFollows(req) {
+        const { actorDid, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        let followsReq = db.db
+            .selectFrom('follow')
+            .where('follow.creator', '=', actorDid)
+            .innerJoin('actor as subject', 'subject.did', 'follow.subjectDid')
+            .selectAll('subject')
+            .select([
+            'follow.uri as uri',
+            'follow.cid as cid',
+            'follow.creator as creatorDid',
+            'follow.subjectDid as subjectDid',
+            'follow.sortAt as sortAt',
+        ]);
+        const keyset = new pagination_1.TimeCidKeyset(ref('follow.sortAt'), ref('follow.cid'));
+        followsReq = (0, pagination_1.paginate)(followsReq, {
+            limit,
+            cursor,
+            keyset,
+            tryIndex: true,
+        });
+        const follows = await followsReq.execute();
+        return {
+            follows: follows.map((f) => ({
+                uri: f.uri,
+                actorDid: f.creatorDid,
+                subjectDid: f.subjectDid,
+            })),
+            cursor: keyset.packFromResult(follows),
+        };
+    },
+    /**
+     * Return known followers of a given actor.
+     *
+     * Example:
+     *   - Alice follows Bob
+     *   - Bob follows Dan
+     *
+     *   If Alice (the viewer) looks at Dan's profile (the subject), she should see that Bob follows Dan
+     */
+    async getFollowsFollowing(req) {
+        const { actorDid: viewerDid, targetDids: subjectDids } = req;
+        /*
+         * 1. Get all the people the Alice is following
+         * 2. Get all the people the Dan is followed by
+         * 3. Find the intersection
+         */
+        const results = [];
+        for (const subjectDid of subjectDids) {
+            const followsReq = db.db
+                .selectFrom('follow')
+                .where('follow.creator', '=', viewerDid)
+                .where('follow.subjectDid', 'in', db.db
+                .selectFrom('follow')
+                .where('follow.subjectDid', '=', subjectDid)
+                .select(['creator']))
+                .select(['subjectDid']);
+            const rows = await followsReq.execute();
+            results.push(new bsky_pb_1.FollowsFollowing({
+                targetDid: subjectDid,
+                dids: rows.map((r) => r.subjectDid),
+            }));
+        }
+        return { results };
+    },
+});

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const identity_1 = require("@atproto/identity");
+const protobuf_1 = require("@bufbuild/protobuf");
+const connect_1 = require("@connectrpc/connect");
+exports.default = (_db, idResolver) => ({
+    async getIdentityByDid(req) {
+        const doc = await idResolver.did.resolve(req.did);
+        if (!doc) {
+            throw new connect_1.ConnectError('identity not found', connect_1.Code.NotFound);
+        }
+        return getResultFromDoc(doc);
+    },
+    async getIdentityByHandle(req) {
+        const did = await idResolver.handle.resolve(req.handle);
+        if (!did) {
+            throw new connect_1.ConnectError('identity not found', connect_1.Code.NotFound);
+        }
+        const doc = await idResolver.did.resolve(did);
+        if (!doc || did !== (0, identity_1.getDid)(doc)) {
+            throw new connect_1.ConnectError('identity not found', connect_1.Code.NotFound);
+        }
+        return getResultFromDoc(doc);
+    },
+});
+const getResultFromDoc = (doc) => {
+    const keys = {};
+    doc.verificationMethod?.forEach((method) => {
+        const id = method.id.split('#').at(1);
+        if (!id)
+            return;
+        keys[id] = {
+            Type: method.type,
+            PublicKeyMultibase: method.publicKeyMultibase || '',
+        };
+    });
+    const services = {};
+    doc.service?.forEach((service) => {
+        const id = service.id.split('#').at(1);
+        if (!id)
+            return;
+        if (typeof service.serviceEndpoint !== 'string')
+            return;
+        services[id] = {
+            Type: service.type,
+            URL: service.serviceEndpoint,
+        };
+    });
+    return {
+        did: (0, identity_1.getDid)(doc),
+        handle: (0, identity_1.getHandle)(doc),
+        keys: Buffer.from(JSON.stringify(keys)),
+        services: Buffer.from(JSON.stringify(services)),
+        updated: protobuf_1.Timestamp.fromDate(new Date()),
+    };
+};

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

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const clio_connect_1 = require("../../../rpc/clio_connect");
+const identity_1 = __importDefault(require("./identity"));
+const profile_1 = __importDefault(require("./profile"));
+const records_1 = __importDefault(require("./records"));
+const sync_1 = __importDefault(require("./sync"));
+exports.default = (db, idResolver) => (router) => router.service(clio_connect_1.ClioService, {
+    ...(0, identity_1.default)(db, idResolver),
+    ...(0, profile_1.default)(db),
+    ...(0, records_1.default)(db),
+    ...(0, sync_1.default)(db),
+    async healthCheck() {
+        return {};
+    },
+});

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@atproto/common");
+const util_1 = require("../db/util");
+exports.default = (db) => ({
+    async getInteractionCounts(req) {
+        const uris = req.refs.map((ref) => ref.uri);
+        if (uris.length === 0) {
+            return { likes: [], replies: [], reposts: [], quotes: [] };
+        }
+        const res = await db.db
+            .selectFrom('post_agg')
+            .where('uri', 'in', uris)
+            .selectAll()
+            .execute();
+        const byUri = (0, common_1.keyBy)(res, 'uri');
+        return {
+            likes: uris.map((uri) => byUri.get(uri)?.likeCount ?? 0),
+            replies: uris.map((uri) => byUri.get(uri)?.replyCount ?? 0),
+            reposts: uris.map((uri) => byUri.get(uri)?.repostCount ?? 0),
+            quotes: uris.map((uri) => byUri.get(uri)?.quoteCount ?? 0),
+        };
+    },
+    async getCountsForUsers(req) {
+        if (req.dids.length === 0) {
+            return {};
+        }
+        const { ref } = db.db.dynamic;
+        const res = await db.db
+            .selectFrom('profile_agg')
+            .where('did', 'in', req.dids)
+            .selectAll('profile_agg')
+            .select([
+            db.db
+                .selectFrom('feed_generator')
+                .whereRef('creator', '=', ref('profile_agg.did'))
+                .select(util_1.countAll.as('val'))
+                .as('feedGensCount'),
+            db.db
+                .selectFrom('list')
+                .whereRef('creator', '=', ref('profile_agg.did'))
+                .select(util_1.countAll.as('val'))
+                .as('listsCount'),
+            db.db
+                .selectFrom('starter_pack')
+                .whereRef('creator', '=', ref('profile_agg.did'))
+                .select(util_1.countAll.as('val'))
+                .as('starterPacksCount'),
+        ])
+            .execute();
+        const byDid = (0, common_1.keyBy)(res, 'did');
+        return {
+            followers: req.dids.map((uri) => byDid.get(uri)?.followersCount ?? 0),
+            following: req.dids.map((uri) => byDid.get(uri)?.followsCount ?? 0),
+            posts: req.dids.map((uri) => byDid.get(uri)?.postsCount ?? 0),
+            lists: req.dids.map((uri) => byDid.get(uri)?.listsCount ?? 0),
+            feeds: req.dids.map((uri) => byDid.get(uri)?.feedGensCount ?? 0),
+            starterPacks: req.dids.map((uri) => byDid.get(uri)?.starterPacksCount ?? 0),
+        };
+    },
+    async getStarterPackCounts(req) {
+        const weekAgo = new Date(Date.now() - 7 * common_1.DAY);
+        const uris = req.refs.map((ref) => ref.uri);
+        if (uris.length === 0) {
+            return { joinedAllTime: [], joinedWeek: [] };
+        }
+        const countsAllTime = await db.db
+            .selectFrom('profile')
+            .where('joinedViaStarterPackUri', 'in', uris)
+            .select(['joinedViaStarterPackUri as uri', util_1.countAll.as('count')])
+            .groupBy('joinedViaStarterPackUri')
+            .execute();
+        const countsWeek = await db.db
+            .selectFrom('profile')
+            .where('joinedViaStarterPackUri', 'in', uris)
+            .where('createdAt', '>', weekAgo.toISOString())
+            .select(['joinedViaStarterPackUri as uri', util_1.countAll.as('count')])
+            .groupBy('joinedViaStarterPackUri')
+            .execute();
+        const countsWeekByUri = countsWeek.reduce((cur, item) => {
+            if (!item.uri)
+                return cur;
+            return cur.set(item.uri, item.count);
+        }, new Map());
+        const countsAllTimeByUri = countsAllTime.reduce((cur, item) => {
+            if (!item.uri)
+                return cur;
+            return cur.set(item.uri, item.count);
+        }, new Map());
+        return {
+            joinedWeek: uris.map((uri) => countsWeekByUri.get(uri) ?? 0),
+            joinedAllTime: uris.map((uri) => countsAllTimeByUri.get(uri) ?? 0),
+        };
+    },
+    async getListCounts(req) {
+        const uris = req.refs.map((ref) => ref.uri);
+        if (uris.length === 0) {
+            return { listItems: [] };
+        }
+        const countsListItems = await db.db
+            .selectFrom('list_item')
+            .where('listUri', 'in', uris)
+            .select(['listUri as uri', util_1.countAll.as('count')])
+            .groupBy('listUri')
+            .execute();
+        const countsByUri = (0, common_1.keyBy)(countsListItems, 'uri');
+        return {
+            listItems: uris.map((uri) => countsByUri.get(uri)?.count ?? 0),
+        };
+    },
+});