@clioplaylists/clio 0.1.6 → 0.1.8

package/dist/client.js

@@ -1,25 +1,18 @@
-"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) => {
+import { createClient } from '@connectrpc/connect';
+import { createGrpcTransport } from '@connectrpc/connect-node';
+import assert from 'node:assert';
+import { ClioService } from './rpc/clio_connect';
+export const createBaseClient = (baseUrl, opts) => {
     const { httpVersion = '2', rejectUnauthorized = true } = opts;
-    const transport = (0, connect_node_1.createGrpcTransport)({
+    const transport = createGrpcTransport({
         baseUrl,
         acceptCompression: [],
         httpVersion,
         nodeOptions: { rejectUnauthorized },
     });
-    (0, node_assert_1.default)(validateUrl(baseUrl));
-    return (0, connect_1.createClient)(clio_connect_1.ClioService, transport);
+    assert(validateUrl(baseUrl));
+    return createClient(ClioService, transport);
 };
-exports.createBaseClient = createBaseClient;
 const validateUrl = (urlStr) => {
     let url;
     try {

package/dist/config.d.ts

@@ -5,6 +5,7 @@ export interface ServerConfigValues {
     serverDid: string;
     didPlcUrl: string;
     handleResolverNameservers?: string[];
+    dataplaneUrls: string[];
 }
 export declare class ServerConfig {
     private cfg;
@@ -18,4 +19,5 @@ export declare class ServerConfig {
     get localUrl(): string;
     get serverDid(): string;
     get didPlcUrl(): string;
+    get dataplaneUrls(): string[];
 }

package/dist/config.js

@@ -1,30 +1,16 @@
-"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 {
+import assert from 'node:assert';
+export class ServerConfig {
+    cfg;
+    assignedPort;
     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
-        });
+        this.cfg = cfg;
     }
     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 dataplaneUrls = overrides?.dataplaneUrls ?? envList(process.env.CLIO_DATAPLANE_URLS);
         // const handleResolverNameservers = process.env.BSKY_HANDLE_RESOLVER_NAMESERVERS
         //   ? process.env.BSKY_HANDLE_RESOLVER_NAMESERVERS.split(',')
         //   : []
@@ -36,10 +22,11 @@ class ServerConfig {
             port,
             serverDid,
             didPlcUrl,
+            dataplaneUrls,
         });
     }
     assignPort(port) {
-        (0, node_assert_1.default)(!this.cfg.port || this.cfg.port === port, 'Conflicting port in config');
+        assert(!this.cfg.port || this.cfg.port === port, 'Conflicting port in config');
         this.assignedPort = port;
     }
     get version() {
@@ -52,7 +39,7 @@ class ServerConfig {
         return this.assignedPort || this.cfg.port;
     }
     get localUrl() {
-        (0, node_assert_1.default)(this.port, 'No port assigned');
+        assert(this.port, 'No port assigned');
         return `http://localhost:${this.port}`;
     }
     get serverDid() {
@@ -61,5 +48,12 @@ class ServerConfig {
     get didPlcUrl() {
         return this.cfg.didPlcUrl;
     }
+    get dataplaneUrls() {
+        return this.cfg.dataplaneUrls;
+    }
+}
+function envList(str) {
+    if (str === undefined || str.length === 0)
+        return [];
+    return str.split(',');
 }
-exports.ServerConfig = ServerConfig;

package/dist/context.d.ts

@@ -1,3 +1,4 @@
+import { Keypair } from '@atproto/crypto';
 import { DataPlaneClient } from './client';
 import { ServerConfig } from './config';
 export default class AppContext {
@@ -5,7 +6,9 @@ export default class AppContext {
     constructor(opts: {
         cfg: ServerConfig;
         dataplane: DataPlaneClient;
+        signingKey: Keypair;
     });
     get cfg(): ServerConfig;
     get dataplane(): DataPlaneClient;
+    get signingKey(): Keypair;
 }

package/dist/context.js

@@ -1,13 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class AppContext {
+export default class AppContext {
+    opts;
     constructor(opts) {
-        Object.defineProperty(this, "opts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: opts
-        });
+        this.opts = opts;
     }
     get cfg() {
         return this.opts.cfg;
@@ -15,5 +9,7 @@ class AppContext {
     get dataplane() {
         return this.opts.dataplane;
     }
+    get signingKey() {
+        return this.opts.signingKey;
+    }
 }
-exports.default = AppContext;

package/dist/dataplane/client/hosts.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Interface for a reactive list of hosts, i.e. for use with the dataplane client.
+ */
+export interface HostList {
+    get: () => Iterable<string>;
+    onUpdate(handler: HostListHandler): void;
+}
+type HostListHandler = (hosts: Iterable<string>) => void;
+/**
+ * Maintains a reactive HostList based on a simple setter.
+ */
+export declare class BasicHostList implements HostList {
+    private hosts;
+    private handlers;
+    constructor(hosts: Iterable<string>);
+    get(): Iterable<string>;
+    set(hosts: Iterable<string>): void;
+    private update;
+    onUpdate(handler: HostListHandler): void;
+}
+export {};

package/dist/dataplane/client/hosts.js

@@ -0,0 +1,25 @@
+/**
+ * Maintains a reactive HostList based on a simple setter.
+ */
+export class BasicHostList {
+    hosts;
+    handlers = [];
+    constructor(hosts) {
+        this.hosts = hosts;
+    }
+    get() {
+        return this.hosts;
+    }
+    set(hosts) {
+        this.hosts = hosts;
+        this.update();
+    }
+    update() {
+        for (const handler of this.handlers) {
+            handler(this.hosts);
+        }
+    }
+    onUpdate(handler) {
+        this.handlers.push(handler);
+    }
+}

package/dist/dataplane/client/index.d.ts

@@ -0,0 +1,11 @@
+import { Client, Code, ConnectError } from '@connectrpc/connect';
+import { ClioService } from '../../rpc/clio_connect';
+import { HostList } from './hosts';
+export type DataPlaneClient = Client<typeof ClioService>;
+type HttpVersion = '1.1' | '2';
+export declare const createDataPlaneClient: (hostList: HostList, opts: {
+    httpVersion?: HttpVersion;
+    rejectUnauthorized?: boolean;
+}) => DataPlaneClient;
+export { Code };
+export declare const isDataplaneError: (err: unknown, code?: Code) => err is ConnectError;

package/dist/dataplane/client/index.js

@@ -0,0 +1,97 @@
+import { Code, ConnectError, createClient, makeAnyClient, } from '@connectrpc/connect';
+import { createGrpcTransport } from '@connectrpc/connect-node';
+import assert from 'node:assert';
+import { randomInt } from 'node:crypto';
+import { ClioService } from '../../rpc/clio_connect';
+const MAX_RETRIES = 3;
+export const createDataPlaneClient = (hostList, opts) => {
+    const clients = new DataPlaneClients(hostList, opts);
+    return makeAnyClient(ClioService, (method) => {
+        return async (...args) => {
+            let tries = 0;
+            let error;
+            let remainingClients = clients.get();
+            while (tries < MAX_RETRIES) {
+                const client = randomElement(remainingClients);
+                assert(client, 'no clients available');
+                try {
+                    return await client[method.localName](...args);
+                }
+                catch (err) {
+                    if (err instanceof ConnectError &&
+                        (err.code === Code.Unavailable || err.code === Code.Aborted)) {
+                        tries++;
+                        error = err;
+                        remainingClients = getRemainingClients(remainingClients, client);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+            assert(error);
+            throw error;
+        };
+    });
+};
+export { Code };
+/**
+ * Uses a reactive HostList in order to maintain a pool of DataPlaneClients.
+ * Each DataPlaneClient is cached per host so that it maintains connections
+ * and other internal state when the underlying HostList is updated.
+ */
+class DataPlaneClients {
+    hostList;
+    clientOpts;
+    clients = [];
+    clientsByHost = new Map();
+    constructor(hostList, clientOpts) {
+        this.hostList = hostList;
+        this.clientOpts = clientOpts;
+        this.refresh();
+        this.hostList.onUpdate(() => this.refresh());
+    }
+    get() {
+        return this.clients;
+    }
+    refresh() {
+        this.clients = [];
+        for (const host of this.hostList.get()) {
+            let client = this.clientsByHost.get(host);
+            if (!client) {
+                client = this.createClient(host);
+                this.clientsByHost.set(host, client);
+            }
+            this.clients.push(client);
+        }
+    }
+    createClient(host) {
+        return createBaseClient(host, this.clientOpts);
+    }
+}
+export const isDataplaneError = (err, code) => {
+    if (err instanceof ConnectError) {
+        return !code || err.code === code;
+    }
+    return false;
+};
+const createBaseClient = (baseUrl, opts) => {
+    const { httpVersion = '2', rejectUnauthorized = true } = opts;
+    const transport = createGrpcTransport({
+        baseUrl,
+        httpVersion,
+        acceptCompression: [],
+        nodeOptions: { rejectUnauthorized },
+    });
+    return createClient(ClioService, transport);
+};
+const getRemainingClients = (clients, lastClient) => {
+    if (clients.length < 2)
+        return clients; // no clients to choose from
+    return clients.filter((c) => c !== lastClient);
+};
+const randomElement = (arr) => {
+    if (arr.length === 0)
+        return;
+    return arr[randomInt(arr.length)];
+};

package/dist/dataplane/client.js

@@ -1,68 +1,28 @@
-"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");
+import { getDidKeyFromMultibase } from '@atproto/identity';
+import { Code, ConnectError, createClient, makeAnyClient, } from '@connectrpc/connect';
+import { createGrpcTransport } from '@connectrpc/connect-node';
+import assert from 'node:assert';
+import { randomInt } from 'node:crypto';
+import * as ui8 from 'uint8arrays';
+import { ClioService } from '../rpc/clio_connect';
 const MAX_RETRIES = 3;
-const createDataPlaneClient = (baseUrls, opts) => {
+export 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) => {
+    assert(clients.length > 0, 'no clients available');
+    return makeAnyClient(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');
+                assert(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)) {
+                    if (err instanceof ConnectError &&
+                        (err.code === Code.Unavailable || err.code === Code.Aborted)) {
                         tries++;
                         error = err;
                         remainingClients = getRemainingClients(remainingClients, client);
@@ -72,29 +32,28 @@ const createDataPlaneClient = (baseUrls, opts) => {
                     }
                 }
             }
-            (0, node_assert_1.default)(error);
+            assert(error);
             throw error;
         };
     });
 };
-exports.createDataPlaneClient = createDataPlaneClient;
-const isDataplaneError = (err, code) => {
-    if (err instanceof connect_1.ConnectError) {
+export { Code };
+export const isDataplaneError = (err, code) => {
+    if (err instanceof 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)({
+    const transport = createGrpcTransport({
         baseUrl,
         httpVersion,
         acceptCompression: [],
         nodeOptions: { rejectUnauthorized },
     });
     return {
-        lib: (0, connect_1.createClient)(clio_connect_1.ClioService, transport),
+        lib: createClient(ClioService, transport),
         url: new URL(baseUrl),
     };
 };
@@ -113,38 +72,34 @@ const getRemainingClients = (clients, lastClient) => {
 const randomElement = (arr) => {
     if (arr.length === 0)
         return;
-    return arr[(0, node_crypto_1.randomInt)(arr.length)];
+    return arr[randomInt(arr.length)];
 };
-const unpackIdentityServices = (servicesBytes) => {
+export const unpackIdentityServices = (servicesBytes) => {
     const servicesStr = ui8.toString(servicesBytes, 'utf8');
     if (!servicesStr)
         return {};
     return JSON.parse(servicesStr);
 };
-exports.unpackIdentityServices = unpackIdentityServices;
-const unpackIdentityKeys = (keysBytes) => {
+export const unpackIdentityKeys = (keysBytes) => {
     const keysStr = ui8.toString(keysBytes, 'utf8');
     if (!keysStr)
         return {};
     return JSON.parse(keysStr);
 };
-exports.unpackIdentityKeys = unpackIdentityKeys;
-const getServiceEndpoint = (services, opts) => {
+export 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) => {
+export const getKeyAsDidKey = (keys, opts) => {
     const key = keys[opts.id] &&
-        (0, identity_1.getDidKeyFromMultibase)({
+        getDidKeyFromMultibase({
             type: keys[opts.id].Type,
             publicKeyMultibase: keys[opts.id].PublicKeyMultibase,
         });
     return key || undefined;
 };
-exports.getKeyAsDidKey = getKeyAsDidKey;
 const validateUrl = (urlStr) => {
     let url;
     try {

package/dist/dataplane/index.js

@@ -1,18 +1,2 @@
-"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);
+export * from './client';
+export * from './server';

package/dist/dataplane/server/background.js

@@ -1,32 +1,12 @@
-"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");
+import PQueue from 'p-queue';
+import { dbLogger } from '../../logger';
 // A simple queue for in-process, out-of-band/backgrounded work
-class BackgroundQueue {
+export class BackgroundQueue {
+    db;
+    queue = new PQueue();
+    destroyed = false;
     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
-        });
+        this.db = db;
     }
     add(task) {
         if (this.destroyed) {
@@ -35,7 +15,7 @@ class BackgroundQueue {
         this.queue
             .add(() => task(this.db))
             .catch((err) => {
-            logger_1.dbLogger.error(err, 'background queue task failed');
+            dbLogger.error(err, 'background queue task failed');
         });
     }
     async processAll() {
@@ -48,4 +28,3 @@ class BackgroundQueue {
         await this.queue.onIdle();
     }
 }
-exports.BackgroundQueue = BackgroundQueue;

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

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