@clioplaylists/clio 0.1.0

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

@@ -0,0 +1,73 @@
+"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 });
+const ui8 = __importStar(require("uint8arrays"));
+const common_1 = require("@atproto/common");
+exports.default = (db) => ({
+    async getLabels(req) {
+        const { subjects, issuers } = req;
+        if (subjects.length === 0 || issuers.length === 0) {
+            return { labels: [] };
+        }
+        const res = await db.db
+            .selectFrom('label')
+            .where('uri', 'in', subjects)
+            .where('src', 'in', issuers)
+            .selectAll()
+            .execute();
+        const labelsBySubject = new Map();
+        res.forEach((l) => {
+            const labels = labelsBySubject.get(l.uri) ?? [];
+            labels.push(l);
+            labelsBySubject.set(l.uri, labels);
+        });
+        // intentionally duplicate label results, appview frontend should be defensive to this
+        const labels = subjects.flatMap((sub) => {
+            const labelsForSub = labelsBySubject.get(sub) ?? [];
+            return labelsForSub.map((l) => {
+                const formatted = (0, common_1.noUndefinedVals)({
+                    ...l,
+                    cid: l.cid === '' ? undefined : l.cid,
+                    neg: l.neg === true ? true : undefined,
+                });
+                return ui8.fromString(JSON.stringify(formatted), 'utf8');
+            });
+        });
+        return { labels };
+    },
+    async getAllLabelers() {
+        throw new Error('not implemented');
+    },
+});

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

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const common_1 = require("@atproto/common");
+const pagination_1 = require("../db/pagination");
+exports.default = (db) => ({
+    async getLikesBySubjectSorted(req) {
+        const { subject, cursor, limit } = req;
+        const { ref } = db.db.dynamic;
+        if (!subject?.uri) {
+            return { uris: [] };
+        }
+        // @NOTE ignoring subject.cid
+        let builder = db.db
+            .selectFrom('like')
+            .where('like.subject', '=', subject?.uri)
+            .selectAll('like');
+        const keyset = new pagination_1.TimeCidKeyset(ref('like.sortAt'), ref('like.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+        });
+        const likes = await builder.execute();
+        return {
+            uris: likes.map((l) => l.uri),
+            cursor: keyset.packFromResult(likes),
+        };
+    },
+    // @NOTE deprecated in favor of getLikesBySubjectSorted
+    async getLikesBySubject(req, context) {
+        (0, node_assert_1.default)(this.getLikesBySubjectSorted);
+        return this.getLikesBySubjectSorted(req, context);
+    },
+    async getLikesByActorAndSubjects(req) {
+        const { actorDid, refs } = req;
+        if (refs.length === 0) {
+            return { uris: [] };
+        }
+        // @NOTE ignoring ref.cid
+        const res = await db.db
+            .selectFrom('like')
+            .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 getActorLikes(req) {
+        const { actorDid, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('like')
+            .where('like.creator', '=', actorDid)
+            .selectAll();
+        const keyset = new pagination_1.TimeCidKeyset(ref('like.sortAt'), ref('like.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+        });
+        const likes = await builder.execute();
+        return {
+            likes: likes.map((l) => ({
+                uri: l.uri,
+                subject: l.subject,
+            })),
+            cursor: keyset.packFromResult(likes),
+        };
+    },
+});

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@atproto/common");
+const pagination_1 = require("../db/pagination");
+const util_1 = require("../db/util");
+exports.default = (db) => ({
+    async getActorLists(req) {
+        const { actorDid, cursor, limit } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('list')
+            .where('creator', '=', actorDid)
+            .selectAll();
+        const keyset = new pagination_1.TimeCidKeyset(ref('list.sortAt'), ref('list.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+            tryIndex: true,
+        });
+        const lists = await builder.execute();
+        return {
+            listUris: lists.map((item) => item.uri),
+            cursor: keyset.packFromResult(lists),
+        };
+    },
+    async getListMembers(req) {
+        const { listUri, cursor, limit } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('list_item')
+            .where('listUri', '=', listUri)
+            .selectAll();
+        const keyset = new pagination_1.TimeCidKeyset(ref('list_item.sortAt'), ref('list_item.cid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+            tryIndex: true,
+        });
+        const listItems = await builder.execute();
+        return {
+            listitems: listItems.map((item) => ({
+                uri: item.uri,
+                did: item.subjectDid,
+            })),
+            cursor: keyset.packFromResult(listItems),
+        };
+    },
+    async getListMembership(req) {
+        const { actorDid, listUris } = req;
+        if (listUris.length === 0) {
+            return { listitemUris: [] };
+        }
+        const res = await db.db
+            .selectFrom('list_item')
+            .where('subjectDid', '=', actorDid)
+            .where('listUri', 'in', listUris)
+            .selectAll()
+            .execute();
+        const byListUri = (0, common_1.keyBy)(res, 'listUri');
+        const listitemUris = listUris.map((uri) => byListUri.get(uri)?.uri ?? '');
+        return {
+            listitemUris,
+        };
+    },
+    async getListCount(req) {
+        const res = await db.db
+            .selectFrom('list_item')
+            .select(util_1.countAll.as('count'))
+            .where('list_item.listUri', '=', req.listUri)
+            .executeTakeFirst();
+        return {
+            count: res?.count,
+        };
+    },
+});

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (db) => ({
+    async getActorTakedown(req) {
+        const { did } = req;
+        const res = await db.db
+            .selectFrom('actor')
+            .where('did', '=', did)
+            .select('takedownRef')
+            .executeTakeFirst();
+        return {
+            takenDown: !!res?.takedownRef,
+            takedownRef: res?.takedownRef || undefined,
+        };
+    },
+    async getBlobTakedown(req) {
+        const { did, cid } = req;
+        const res = await db.db
+            .selectFrom('blob_takedown')
+            .where('did', '=', did)
+            .where('cid', '=', cid)
+            .select('takedownRef')
+            .executeTakeFirst();
+        return {
+            takenDown: !!res,
+            takedownRef: res?.takedownRef || undefined,
+        };
+    },
+    async getRecordTakedown(req) {
+        const { recordUri } = req;
+        const res = await db.db
+            .selectFrom('record')
+            .where('uri', '=', recordUri)
+            .select('takedownRef')
+            .executeTakeFirst();
+        return {
+            takenDown: !!res?.takedownRef,
+            takedownRef: res?.takedownRef || undefined,
+        };
+    },
+    async takedownActor(req) {
+        const { did, ref } = req;
+        await db.db
+            .updateTable('actor')
+            .set({ takedownRef: ref || 'TAKEDOWN' })
+            .where('did', '=', did)
+            .execute();
+    },
+    async takedownBlob(req) {
+        const { did, cid, ref } = req;
+        await db.db
+            .insertInto('blob_takedown')
+            .values({
+            did,
+            cid,
+            takedownRef: ref || 'TAKEDOWN',
+        })
+            .execute();
+    },
+    async takedownRecord(req) {
+        const { recordUri, ref } = req;
+        await db.db
+            .updateTable('record')
+            .set({ takedownRef: ref || 'TAKEDOWN' })
+            .where('uri', '=', recordUri)
+            .execute();
+    },
+    async untakedownActor(req) {
+        const { did } = req;
+        await db.db
+            .updateTable('actor')
+            .set({ takedownRef: null })
+            .where('did', '=', did)
+            .execute();
+    },
+    async untakedownBlob(req) {
+        const { did, cid } = req;
+        await db.db
+            .deleteFrom('blob_takedown')
+            .where('did', '=', did)
+            .where('cid', '=', cid)
+            .executeTakeFirst();
+    },
+    async untakedownRecord(req) {
+        const { recordUri } = req;
+        await db.db
+            .updateTable('record')
+            .set({ takedownRef: null })
+            .where('uri', '=', recordUri)
+            .execute();
+    },
+});

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

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const common_1 = require("@atproto/common");
+const syntax_1 = require("@atproto/syntax");
+const lexicons_1 = require("../../../lexicon/lexicons");
+const pagination_1 = require("../db/pagination");
+exports.default = (db) => ({
+    async getActorMutesActor(req) {
+        const { actorDid, targetDid } = req;
+        const res = await db.db
+            .selectFrom('mute')
+            .selectAll()
+            .where('mutedByDid', '=', actorDid)
+            .where('subjectDid', '=', targetDid)
+            .executeTakeFirst();
+        return {
+            muted: !!res,
+        };
+    },
+    async getMutes(req) {
+        const { actorDid, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('mute')
+            .innerJoin('actor', 'actor.did', 'mute.subjectDid')
+            .where('mute.mutedByDid', '=', actorDid)
+            .selectAll('actor')
+            .select('mute.createdAt as createdAt');
+        const keyset = new pagination_1.CreatedAtDidKeyset(ref('mute.createdAt'), ref('mute.subjectDid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            limit,
+            cursor,
+            keyset,
+        });
+        const mutes = await builder.execute();
+        return {
+            dids: mutes.map((m) => m.did),
+            cursor: keyset.packFromResult(mutes),
+        };
+    },
+    async getActorMutesActorViaList(req) {
+        const { actorDid, targetDid } = req;
+        const res = await db.db
+            .selectFrom('list_mute')
+            .innerJoin('list_item', 'list_item.listUri', 'list_mute.listUri')
+            .where('list_mute.mutedByDid', '=', actorDid)
+            .where('list_item.subjectDid', '=', targetDid)
+            .select('list_mute.listUri')
+            .limit(1)
+            .executeTakeFirst();
+        return {
+            listUri: res?.listUri,
+        };
+    },
+    async getMutelistSubscription(req) {
+        const { actorDid, listUri } = req;
+        const res = await db.db
+            .selectFrom('list_mute')
+            .where('mutedByDid', '=', actorDid)
+            .where('listUri', '=', listUri)
+            .selectAll()
+            .limit(1)
+            .executeTakeFirst();
+        return {
+            subscribed: !!res,
+        };
+    },
+    async getMutelistSubscriptions(req) {
+        const { actorDid, limit, cursor } = req;
+        const { ref } = db.db.dynamic;
+        let builder = db.db
+            .selectFrom('list')
+            .whereExists(db.db
+            .selectFrom('list_mute')
+            .where('list_mute.mutedByDid', '=', actorDid)
+            .whereRef('list_mute.listUri', '=', 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),
+        };
+    },
+    async createActorMute(req) {
+        const { actorDid, subjectDid } = req;
+        (0, node_assert_1.default)(actorDid !== subjectDid, 'cannot mute yourself'); // @TODO pass message through in http error
+        await db.db
+            .insertInto('mute')
+            .values({
+            subjectDid,
+            mutedByDid: actorDid,
+            createdAt: new Date().toISOString(),
+        })
+            .onConflict((oc) => oc.doNothing())
+            .execute();
+    },
+    async deleteActorMute(req) {
+        const { actorDid, subjectDid } = req;
+        (0, node_assert_1.default)(actorDid !== subjectDid, 'cannot mute yourself');
+        await db.db
+            .deleteFrom('mute')
+            .where('subjectDid', '=', subjectDid)
+            .where('mutedByDid', '=', actorDid)
+            .execute();
+    },
+    async clearActorMutes(req) {
+        const { actorDid } = req;
+        await db.db.deleteFrom('mute').where('mutedByDid', '=', actorDid).execute();
+    },
+    async createActorMutelistSubscription(req) {
+        const { actorDid, subjectUri } = req;
+        (0, node_assert_1.default)(isListUri(subjectUri), 'must mute a list');
+        await db.db
+            .insertInto('list_mute')
+            .values({
+            listUri: subjectUri,
+            mutedByDid: actorDid,
+            createdAt: new Date().toISOString(),
+        })
+            .onConflict((oc) => oc.doNothing())
+            .execute();
+    },
+    async deleteActorMutelistSubscription(req) {
+        const { actorDid, subjectUri } = req;
+        (0, node_assert_1.default)(isListUri(subjectUri), 'must mute a list');
+        await db.db
+            .deleteFrom('list_mute')
+            .where('listUri', '=', subjectUri)
+            .where('mutedByDid', '=', actorDid)
+            .execute();
+    },
+    async clearActorMutelistSubscriptions(req) {
+        const { actorDid } = req;
+        await db.db
+            .deleteFrom('list_mute')
+            .where('mutedByDid', '=', actorDid)
+            .execute();
+    },
+    async getThreadMutesOnSubjects(req) {
+        const { actorDid, threadRoots } = req;
+        if (threadRoots.length === 0) {
+            return { muted: [] };
+        }
+        const res = await db.db
+            .selectFrom('thread_mute')
+            .selectAll()
+            .where('mutedByDid', '=', actorDid)
+            .where('rootUri', 'in', threadRoots)
+            .execute();
+        const byRootUri = (0, common_1.keyBy)(res, 'rootUri');
+        const muted = threadRoots.map((uri) => !!byRootUri.get(uri));
+        return { muted };
+    },
+});
+const isListUri = (uri) => new syntax_1.AtUri(uri).collection === lexicons_1.ids.AppBskyGraphList;

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const protobuf_1 = require("@bufbuild/protobuf");
+const kysely_1 = require("kysely");
+const pagination_1 = require("../db/pagination");
+const util_1 = require("../db/util");
+exports.default = (db) => ({
+    async getNotifications(req) {
+        const { actorDid, limit, cursor, priority } = req;
+        const { ref } = db.db.dynamic;
+        const priorityFollowQb = db.db
+            .selectFrom('follow')
+            .select((0, kysely_1.sql) `${true}`.as('val'))
+            .where('creator', '=', actorDid)
+            .whereRef('subjectDid', '=', ref('notif.author'))
+            .limit(1);
+        let builder = db.db
+            .selectFrom('notification as notif')
+            .where('notif.did', '=', actorDid)
+            .where((clause) => clause
+            .where('reasonSubject', 'is', null)
+            .orWhereExists(db.db
+            .selectFrom('record as subject')
+            .selectAll()
+            .whereRef('subject.uri', '=', ref('notif.reasonSubject'))))
+            .if(priority, (qb) => qb.whereExists(priorityFollowQb))
+            .select([
+            'notif.author as authorDid',
+            'notif.recordUri as uri',
+            'notif.recordCid as cid',
+            'notif.reason as reason',
+            'notif.reasonSubject as reasonSubject',
+            'notif.sortAt as sortAt',
+        ])
+            .select(priorityFollowQb.as('priority'));
+        const keyset = new pagination_1.TimeCidKeyset(ref('notif.sortAt'), ref('notif.recordCid'));
+        builder = (0, pagination_1.paginate)(builder, {
+            cursor,
+            limit,
+            keyset,
+            tryIndex: true,
+        });
+        const notifsRes = await builder.execute();
+        const notifications = notifsRes.map((notif) => ({
+            recipientDid: actorDid,
+            uri: notif.uri,
+            reason: notif.reason,
+            reasonSubject: notif.reasonSubject ?? undefined,
+            timestamp: protobuf_1.Timestamp.fromDate(new Date(notif.sortAt)),
+            priority: notif.priority ?? false,
+        }));
+        return {
+            notifications,
+            cursor: keyset.packFromResult(notifsRes),
+        };
+    },
+    async getNotificationSeen(req) {
+        const { actorDid, priority } = req;
+        const res = await db.db
+            .selectFrom('actor_state')
+            .where('did', '=', actorDid)
+            .selectAll()
+            .executeTakeFirst();
+        if (!res) {
+            return {};
+        }
+        const lastSeen = priority && res.lastSeenPriorityNotifs
+            ? res.lastSeenPriorityNotifs
+            : res.lastSeenNotifs;
+        return {
+            timestamp: protobuf_1.Timestamp.fromDate(new Date(lastSeen)),
+        };
+    },
+    async getUnreadNotificationCount(req) {
+        const { actorDid, priority } = req;
+        const { ref } = db.db.dynamic;
+        const lastSeenRes = await db.db
+            .selectFrom('actor_state')
+            .where('did', '=', actorDid)
+            .selectAll()
+            .executeTakeFirst();
+        const lastSeen = priority && lastSeenRes?.lastSeenPriorityNotifs
+            ? lastSeenRes.lastSeenPriorityNotifs
+            : lastSeenRes?.lastSeenNotifs;
+        const result = await db.db
+            .selectFrom('notification')
+            .select(util_1.countAll.as('count'))
+            .innerJoin('actor', 'actor.did', 'notification.did')
+            .leftJoin('actor_state', 'actor_state.did', 'actor.did')
+            .innerJoin('record', 'record.uri', 'notification.recordUri')
+            .where((0, util_1.notSoftDeletedClause)(ref('record')))
+            .where((0, util_1.notSoftDeletedClause)(ref('actor')))
+            // Ensure to hit notification_did_sortat_idx, handling case where lastSeenNotifs is null.
+            .where('notification.did', '=', actorDid)
+            .where('notification.sortAt', '>', lastSeen ?? '')
+            .if(priority, (qb) => qb.whereExists(db.db
+            .selectFrom('follow')
+            .select((0, kysely_1.sql) `${true}`.as('val'))
+            .where('creator', '=', actorDid)
+            .whereRef('subjectDid', '=', ref('notification.author'))))
+            .executeTakeFirst();
+        return {
+            count: result?.count,
+        };
+    },
+    async updateNotificationSeen(req) {
+        const { actorDid, timestamp, priority } = req;
+        if (!timestamp) {
+            return;
+        }
+        const timestampIso = timestamp.toDate().toISOString();
+        let builder = db.db
+            .updateTable('actor_state')
+            .where('did', '=', actorDid)
+            .returningAll();
+        if (priority) {
+            builder = builder.set({ lastSeenPriorityNotifs: timestampIso });
+        }
+        else {
+            builder = builder.set({ lastSeenNotifs: timestampIso });
+        }
+        const updateRes = await builder.executeTakeFirst();
+        if (updateRes) {
+            return;
+        }
+        await db.db
+            .insertInto('actor_state')
+            .values({
+            did: actorDid,
+            lastSeenNotifs: timestampIso,
+            priorityNotifs: priority,
+            lastSeenPriorityNotifs: priority ? timestampIso : undefined,
+        })
+            .onConflict((oc) => oc.doNothing())
+            .executeTakeFirst();
+    },
+});

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@atproto/common");
+exports.default = (db) => ({
+    async getPostReplyCounts(req) {
+        const uris = req.refs.map((ref) => ref.uri);
+        if (uris.length === 0) {
+            return { counts: [] };
+        }
+        const res = await db.db
+            .selectFrom('post_agg')
+            .select(['uri', 'replyCount'])
+            .where('uri', 'in', uris)
+            .execute();
+        const byUri = (0, common_1.keyBy)(res, 'uri');
+        const counts = uris.map((uri) => byUri.get(uri)?.replyCount ?? 0);
+        return { counts };
+    },
+});