@clioplaylists/clio 0.1.0

package/dist/client.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBaseClient = void 0;
+const connect_1 = require("@connectrpc/connect");
+const connect_node_1 = require("@connectrpc/connect-node");
+const node_assert_1 = __importDefault(require("node:assert"));
+const clio_connect_1 = require("./rpc/clio_connect");
+const createBaseClient = (baseUrl, opts) => {
+    const { httpVersion = '2', rejectUnauthorized = true } = opts;
+    const transport = (0, connect_node_1.createGrpcTransport)({
+        baseUrl,
+        acceptCompression: [],
+        httpVersion,
+        nodeOptions: { rejectUnauthorized },
+    });
+    (0, node_assert_1.default)(validateUrl(baseUrl));
+    return (0, connect_1.createClient)(clio_connect_1.ClioService, transport);
+};
+exports.createBaseClient = createBaseClient;
+const validateUrl = (urlStr) => {
+    let url;
+    try {
+        url = new URL(urlStr);
+    }
+    catch {
+        return undefined;
+    }
+    if (!['http:', 'https:'].includes(url.protocol)) {
+        return undefined;
+    }
+    else if (!url.hostname) {
+        return undefined;
+    }
+    else {
+        return urlStr;
+    }
+};

package/dist/config.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerConfig = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+class ServerConfig {
+    constructor(cfg) {
+        Object.defineProperty(this, "cfg", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cfg
+        });
+        Object.defineProperty(this, "assignedPort", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    static readEnv(overrides) {
+        const version = overrides?.version || process.env.CLIO_VERSION || undefined;
+        const debugMode = overrides?.debugMode || process.env.NODE_ENV !== 'production';
+        const serverDid = overrides?.serverDid || process.env.CLIO_SERVER_DID || 'did:example:test';
+        const didPlcUrl = overrides?.didPlcUrl || process.env.DID_PLC_URL || 'http://localhost:2582';
+        // const handleResolverNameservers = process.env.BSKY_HANDLE_RESOLVER_NAMESERVERS
+        //   ? process.env.BSKY_HANDLE_RESOLVER_NAMESERVERS.split(',')
+        //   : []
+        const envPort = overrides?.port || parseInt(process.env.CLIO_PORT || '', 10);
+        const port = isNaN(envPort) ? 2635 : envPort;
+        return new ServerConfig({
+            version,
+            debugMode,
+            port,
+            serverDid,
+            didPlcUrl,
+        });
+    }
+    assignPort(port) {
+        (0, node_assert_1.default)(!this.cfg.port || this.cfg.port === port, 'Conflicting port in config');
+        this.assignedPort = port;
+    }
+    get version() {
+        return this.cfg.version;
+    }
+    get debugMode() {
+        return !!this.cfg.debugMode;
+    }
+    get port() {
+        return this.assignedPort || this.cfg.port;
+    }
+    get localUrl() {
+        (0, node_assert_1.default)(this.port, 'No port assigned');
+        return `http://localhost:${this.port}`;
+    }
+    get serverDid() {
+        return this.cfg.serverDid;
+    }
+    get didPlcUrl() {
+        return this.cfg.didPlcUrl;
+    }
+}
+exports.ServerConfig = ServerConfig;

package/dist/context.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AppContext {
+    constructor(opts) {
+        Object.defineProperty(this, "opts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: opts
+        });
+    }
+    get cfg() {
+        return this.opts.cfg;
+    }
+    get dataplane() {
+        return this.opts.dataplane;
+    }
+}
+exports.default = AppContext;

package/dist/dataplane/bsync/index.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockBsync = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_events_1 = __importDefault(require("node:events"));
+const connect_express_1 = require("@connectrpc/connect-express");
+const express_1 = __importDefault(require("express"));
+const syntax_1 = require("@atproto/syntax");
+const lexicons_1 = require("../../lexicon/lexicons");
+const bsync_connect_1 = require("../../proto/bsync_connect");
+const bsync_pb_1 = require("../../proto/bsync_pb");
+class MockBsync {
+    constructor(server) {
+        Object.defineProperty(this, "server", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: server
+        });
+    }
+    static async create(db, port) {
+        const app = (0, express_1.default)();
+        const routes = createRoutes(db);
+        app.use((0, connect_express_1.expressConnectMiddleware)({ routes }));
+        const server = app.listen(port);
+        await node_events_1.default.once(server, 'listening');
+        return new MockBsync(server);
+    }
+    async destroy() {
+        return new Promise((resolve, reject) => {
+            this.server.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+}
+exports.MockBsync = MockBsync;
+const createRoutes = (db) => (router) => router.service(bsync_connect_1.Service, {
+    async addMuteOperation(req) {
+        const { type, actorDid, subject } = req;
+        if (type === bsync_pb_1.MuteOperation_Type.ADD) {
+            if (subject.startsWith('did:')) {
+                (0, node_assert_1.default)(actorDid !== subject, 'cannot mute yourself'); // @TODO pass message through in http error
+                await db.db
+                    .insertInto('mute')
+                    .values({
+                    mutedByDid: actorDid,
+                    subjectDid: subject,
+                    createdAt: new Date().toISOString(),
+                })
+                    .onConflict((oc) => oc.doNothing())
+                    .execute();
+            }
+            else {
+                const uri = new syntax_1.AtUri(subject);
+                if (uri.collection === lexicons_1.ids.AppBskyGraphList) {
+                    await db.db
+                        .insertInto('list_mute')
+                        .values({
+                        mutedByDid: actorDid,
+                        listUri: subject,
+                        createdAt: new Date().toISOString(),
+                    })
+                        .onConflict((oc) => oc.doNothing())
+                        .execute();
+                }
+                else {
+                    await db.db
+                        .insertInto('thread_mute')
+                        .values({
+                        mutedByDid: actorDid,
+                        rootUri: subject,
+                        createdAt: new Date().toISOString(),
+                    })
+                        .onConflict((oc) => oc.doNothing())
+                        .execute();
+                }
+            }
+        }
+        else if (type === bsync_pb_1.MuteOperation_Type.REMOVE) {
+            if (subject.startsWith('did:')) {
+                await db.db
+                    .deleteFrom('mute')
+                    .where('mutedByDid', '=', actorDid)
+                    .where('subjectDid', '=', subject)
+                    .execute();
+            }
+            else {
+                const uri = new syntax_1.AtUri(subject);
+                if (uri.collection === lexicons_1.ids.AppBskyGraphList) {
+                    await db.db
+                        .deleteFrom('list_mute')
+                        .where('mutedByDid', '=', actorDid)
+                        .where('listUri', '=', subject)
+                        .execute();
+                }
+                else {
+                    await db.db
+                        .deleteFrom('thread_mute')
+                        .where('mutedByDid', '=', actorDid)
+                        .where('rootUri', '=', subject)
+                        .execute();
+                }
+            }
+        }
+        else if (type === bsync_pb_1.MuteOperation_Type.CLEAR) {
+            await db.db
+                .deleteFrom('mute')
+                .where('mutedByDid', '=', actorDid)
+                .execute();
+            await db.db
+                .deleteFrom('list_mute')
+                .where('mutedByDid', '=', actorDid)
+                .execute();
+        }
+        return {};
+    },
+    async scanMuteOperations() {
+        throw new Error('not implemented');
+    },
+    async addNotifOperation(req) {
+        const { actorDid, priority } = req;
+        if (priority !== undefined) {
+            await db.db
+                .insertInto('actor_state')
+                .values({
+                did: actorDid,
+                priorityNotifs: priority,
+                lastSeenNotifs: new Date().toISOString(),
+            })
+                .onConflict((oc) => oc.column('did').doUpdateSet({ priorityNotifs: priority }))
+                .execute();
+        }
+        return {};
+    },
+    async scanNotifOperations() {
+        throw new Error('not implemented');
+    },
+    async ping() {
+        return {};
+    },
+});

package/dist/dataplane/client.js

@@ -0,0 +1,165 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeyAsDidKey = exports.getServiceEndpoint = exports.unpackIdentityKeys = exports.unpackIdentityServices = exports.isDataplaneError = exports.Code = exports.createDataPlaneClient = void 0;
+const identity_1 = require("@atproto/identity");
+const connect_1 = require("@connectrpc/connect");
+Object.defineProperty(exports, "Code", { enumerable: true, get: function () { return connect_1.Code; } });
+const connect_node_1 = require("@connectrpc/connect-node");
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_crypto_1 = require("node:crypto");
+const ui8 = __importStar(require("uint8arrays"));
+const clio_connect_1 = require("../rpc/clio_connect");
+const MAX_RETRIES = 3;
+const createDataPlaneClient = (baseUrls, opts) => {
+    const clients = baseUrls.map((baseUrl) => createBaseClient(baseUrl, opts));
+    (0, node_assert_1.default)(clients.length > 0, 'no clients available');
+    return (0, connect_1.makeAnyClient)(clio_connect_1.ClioService, (method) => {
+        return async (...args) => {
+            let tries = 0;
+            let error;
+            let remainingClients = clients;
+            while (tries < MAX_RETRIES) {
+                const client = randomElement(remainingClients);
+                (0, node_assert_1.default)(client, 'no clients available');
+                try {
+                    return await client.lib[method.localName](...args);
+                }
+                catch (err) {
+                    if (err instanceof connect_1.ConnectError &&
+                        (err.code === connect_1.Code.Unavailable || err.code === connect_1.Code.Aborted)) {
+                        tries++;
+                        error = err;
+                        remainingClients = getRemainingClients(remainingClients, client);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+            (0, node_assert_1.default)(error);
+            throw error;
+        };
+    });
+};
+exports.createDataPlaneClient = createDataPlaneClient;
+const isDataplaneError = (err, code) => {
+    if (err instanceof connect_1.ConnectError) {
+        return !code || err.code === code;
+    }
+    return false;
+};
+exports.isDataplaneError = isDataplaneError;
+const createBaseClient = (baseUrl, opts) => {
+    const { httpVersion = '2', rejectUnauthorized = true } = opts;
+    const transport = (0, connect_node_1.createGrpcTransport)({
+        baseUrl,
+        httpVersion,
+        acceptCompression: [],
+        nodeOptions: { rejectUnauthorized },
+    });
+    return {
+        lib: (0, connect_1.createClient)(clio_connect_1.ClioService, transport),
+        url: new URL(baseUrl),
+    };
+};
+const getRemainingClients = (clients, lastClient) => {
+    if (clients.length < 2)
+        return clients; // no clients to choose from
+    if (lastClient.url.port) {
+        // if the last client had a port, we attempt to exclude its whole host.
+        const maybeRemaining = clients.filter((c) => c.url.hostname !== lastClient.url.hostname);
+        if (maybeRemaining.length) {
+            return maybeRemaining;
+        }
+    }
+    return clients.filter((c) => c !== lastClient);
+};
+const randomElement = (arr) => {
+    if (arr.length === 0)
+        return;
+    return arr[(0, node_crypto_1.randomInt)(arr.length)];
+};
+const unpackIdentityServices = (servicesBytes) => {
+    const servicesStr = ui8.toString(servicesBytes, 'utf8');
+    if (!servicesStr)
+        return {};
+    return JSON.parse(servicesStr);
+};
+exports.unpackIdentityServices = unpackIdentityServices;
+const unpackIdentityKeys = (keysBytes) => {
+    const keysStr = ui8.toString(keysBytes, 'utf8');
+    if (!keysStr)
+        return {};
+    return JSON.parse(keysStr);
+};
+exports.unpackIdentityKeys = unpackIdentityKeys;
+const getServiceEndpoint = (services, opts) => {
+    const endpoint = services[opts.id] &&
+        services[opts.id].Type === opts.type &&
+        validateUrl(services[opts.id].URL);
+    return endpoint || undefined;
+};
+exports.getServiceEndpoint = getServiceEndpoint;
+const getKeyAsDidKey = (keys, opts) => {
+    const key = keys[opts.id] &&
+        (0, identity_1.getDidKeyFromMultibase)({
+            type: keys[opts.id].Type,
+            publicKeyMultibase: keys[opts.id].PublicKeyMultibase,
+        });
+    return key || undefined;
+};
+exports.getKeyAsDidKey = getKeyAsDidKey;
+const validateUrl = (urlStr) => {
+    let url;
+    try {
+        url = new URL(urlStr);
+    }
+    catch {
+        return undefined;
+    }
+    if (!['http:', 'https:'].includes(url.protocol)) {
+        return undefined;
+    }
+    else if (!url.hostname) {
+        return undefined;
+    }
+    else {
+        return urlStr;
+    }
+};

package/dist/dataplane/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./server"), exports);

package/dist/dataplane/server/background.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackgroundQueue = void 0;
+const p_queue_1 = __importDefault(require("p-queue"));
+const logger_1 = require("../../logger");
+// A simple queue for in-process, out-of-band/backgrounded work
+class BackgroundQueue {
+    constructor(db) {
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: db
+        });
+        Object.defineProperty(this, "queue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new p_queue_1.default()
+        });
+        Object.defineProperty(this, "destroyed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    add(task) {
+        if (this.destroyed) {
+            return;
+        }
+        this.queue
+            .add(() => task(this.db))
+            .catch((err) => {
+            logger_1.dbLogger.error(err, 'background queue task failed');
+        });
+    }
+    async processAll() {
+        await this.queue.onIdle();
+    }
+    // On destroy we stop accepting new tasks, but complete all pending/in-progress tasks.
+    // The application calls this only once http connections have drained (tasks no longer being added).
+    async destroy() {
+        this.destroyed = true;
+        await this.queue.onIdle();
+    }
+}
+exports.BackgroundQueue = BackgroundQueue;

package/dist/dataplane/server/db/database-schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });