@clioplaylists/clio 0.1.7 → 0.1.8

package/dist/api/well-known.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import AppContext from '../context';
+export declare const createRouter: (ctx: AppContext) => Router;

package/dist/api/well-known.js

@@ -0,0 +1,31 @@
+import { Router } from 'express';
+export const createRouter = (ctx) => {
+    const router = Router();
+    const did = ctx.cfg.serverDid;
+    if (did.startsWith('did:web:')) {
+        const hostname = did.slice('did:web:'.length);
+        const serviceEndpoint = `https://${hostname}`;
+        router.get('/.well-known/did.json', (_req, res) => {
+            res.json({
+                '@context': ['https://www.w3.org/ns/did/v1'],
+                id: did,
+                verificationMethod: [
+                    {
+                        id: `${did}#atproto`,
+                        type: 'Multikey',
+                        controller: did,
+                        publicKeyMultibase: ctx.signingKey.did().replace('did:key:', ''),
+                    },
+                ],
+                service: [
+                    {
+                        id: '#clio_appview',
+                        type: 'ClioAppView',
+                        serviceEndpoint,
+                    }
+                ],
+            });
+        });
+    }
+    return router;
+};

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

@@ -10,6 +10,7 @@ export class ServerConfig {
         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(',')
         //   : []
@@ -21,6 +22,7 @@ export class ServerConfig {
             port,
             serverDid,
             didPlcUrl,
+            dataplaneUrls,
         });
     }
     assignPort(port) {
@@ -46,4 +48,12 @@ export 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(',');
 }

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

@@ -9,4 +9,7 @@ export default class AppContext {
     get dataplane() {
         return this.opts.dataplane;
     }
+    get signingKey() {
+        return this.opts.signingKey;
+    }
 }

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/index.d.ts

@@ -1,3 +1,4 @@
+import { Keypair } from '@atproto/crypto';
 import express from 'express';
 import { Server } from 'http';
 import { ServerConfig } from './config';
@@ -13,6 +14,7 @@ export declare class ClioAppView {
     });
     static create(opts: {
         config: ServerConfig;
+        signingKey: Keypair;
     }): ClioAppView;
     start(): Promise<Server>;
     destroy(): Promise<void>;

package/dist/index.js

@@ -5,8 +5,9 @@ import events from 'events';
 import express from 'express';
 import { createHttpTerminator } from 'http-terminator';
 import API, { health } from './api';
-import { createBaseClient } from './client';
 import AppContext from './context';
+import { createDataPlaneClient } from './dataplane';
+import { BasicHostList } from './dataplane/client/hosts';
 import * as error from './error';
 import { createServer } from './lexicons';
 import { loggerMiddleware } from './logger';
@@ -21,15 +22,20 @@ export class ClioAppView {
         this.app = opts.app;
     }
     static create(opts) {
-        const { config } = opts;
+        const { config, signingKey } = opts;
         const app = express();
         app.use(cors({ maxAge: DAY / SECOND }));
         app.use(loggerMiddleware);
-        const dataplane = createBaseClient('http://localhost:4000', {});
+        const dataplaneHostList = new BasicHostList(config.dataplaneUrls);
+        const dataplane = createDataPlaneClient(dataplaneHostList, {
+            httpVersion: '2',
+            rejectUnauthorized: false,
+        });
         const server = createServer();
         const ctx = new AppContext({
             cfg: config,
             dataplane,
+            signingKey,
         });
         const api = API(server, ctx);
         app.use(health.createRouter(ctx));

package/dist/start.js

@@ -1,13 +1,21 @@
 'use strict';
+const assert = require('node:assert');
 const { ClioAppView } = require('./index');
 const { ServerConfig } = require('./config');
+const { Secp256k1Keypair } = require('@atproto/crypto');
 const main = async () => {
+    const env = getEnv();
     const config = ServerConfig.readEnv();
-    const clio = ClioAppView.create({ config });
+    assert(env.serviceSigningKey, 'must set BSKY_SERVICE_SIGNING_KEY');
+    const signingKey = await Secp256k1Keypair.import(env.serviceSigningKey);
+    const clio = ClioAppView.create({ config, signingKey });
     await clio.start();
     const shutdown = async () => {
         await clio.destroy();
     };
     process.on('SIGTERM', shutdown);
 };
+const getEnv = () => ({
+    serviceSigningKey: process.env.BSKY_SERVICE_SIGNING_KEY || undefined,
+});
 main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clioplaylists/clio",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Appview server for the Clio application",
   "main": "dist/start.js",
   "types": "dist/index.d.ts",