@clioplaylists/clio 0.1.1 → 0.1.3

package/dist/dataplane/bsync/index.js

@@ -1,150 +0,0 @@
-"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.d.ts

@@ -1,27 +0,0 @@
-import { Client, Code, ConnectError } from '@connectrpc/connect';
-import { ClioService } from '../rpc/clio_connect';
-export type DataPlaneClient = Client<typeof ClioService>;
-type HttpVersion = '1.1' | '2';
-export declare const createDataPlaneClient: (baseUrls: string[], opts: {
-    httpVersion?: HttpVersion;
-    rejectUnauthorized?: boolean;
-}) => DataPlaneClient;
-export { Code };
-export declare const isDataplaneError: (err: unknown, code?: Code) => err is ConnectError;
-export declare const unpackIdentityServices: (servicesBytes: Uint8Array) => UnpackedServices;
-export declare const unpackIdentityKeys: (keysBytes: Uint8Array) => UnpackedKeys;
-export declare const getServiceEndpoint: (services: UnpackedServices, opts: {
-    id: string;
-    type: string;
-}) => string | undefined;
-export declare const getKeyAsDidKey: (keys: UnpackedKeys, opts: {
-    id: string;
-}) => string | undefined;
-type UnpackedServices = Record<string, {
-    Type: string;
-    URL: string;
-}>;
-type UnpackedKeys = Record<string, {
-    Type: string;
-    PublicKeyMultibase: string;
-}>;

package/dist/dataplane/client.js

@@ -1,165 +0,0 @@
-"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.d.ts

@@ -1,2 +0,0 @@
-export * from './client';
-export * from './server';

package/dist/dataplane/index.js

@@ -1,18 +0,0 @@
-"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.d.ts

@@ -1,13 +0,0 @@
-import PQueue from 'p-queue';
-import { Database } from './db';
-export declare class BackgroundQueue {
-    db: Database;
-    queue: PQueue<import("p-queue/dist/priority-queue").default, import("p-queue").DefaultAddOptions>;
-    destroyed: boolean;
-    constructor(db: Database);
-    add(task: Task): void;
-    processAll(): Promise<void>;
-    destroy(): Promise<void>;
-}
-type Task = (db: Database) => Promise<void>;
-export {};

package/dist/dataplane/server/background.js

@@ -1,51 +0,0 @@
-"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.d.ts

@@ -1,13 +0,0 @@
-import { Kysely } from 'kysely';
-import * as actorTable from './tables/actor';
-import * as actorSyncTable from './tables/actor-sync';
-import * as artistTable from './tables/artist';
-import * as artistListItemTable from './tables/artist-list-item';
-import * as playlistTable from './tables/playlist';
-import * as playlistIdeaTable from './tables/playlist-idea';
-import * as playlistItemTable from './tables/playlist-item';
-import * as profileTable from './tables/profile';
-import * as recordTable from './tables/record';
-import * as songTable from './tables/song';
-export type DatabaseSchemaType = actorTable.PartialDB & actorSyncTable.PartialDB & artistTable.PartialDB & artistListItemTable.PartialDB & playlistTable.PartialDB & playlistIdeaTable.PartialDB & playlistItemTable.PartialDB & profileTable.PartialDB & recordTable.PartialDB & songTable.PartialDB;
-export type DatabaseSchema = Kysely<DatabaseSchemaType>;

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

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

package/dist/dataplane/server/db/db.d.ts

@@ -1,32 +0,0 @@
-import { Migrator } from 'kysely';
-import { Pool as PgPool } from 'pg';
-import TypedEmitter from 'typed-emitter';
-import { DatabaseSchema } from './database-schema';
-import { PgOptions } from './types';
-export declare class Database {
-    opts: PgOptions;
-    pool: PgPool;
-    db: DatabaseSchema;
-    migrator: Migrator;
-    txEvt: TxnEmitter;
-    destroyed: boolean;
-    constructor(opts: PgOptions, instances?: {
-        db: DatabaseSchema;
-        pool: PgPool;
-        migrator: Migrator;
-    });
-    get schema(): string | undefined;
-    transaction<T>(fn: (db: Database) => Promise<T>): Promise<T>;
-    get isTransaction(): boolean;
-    assertTransaction(): void;
-    assertNotTransaction(): void;
-    onCommit(fn: () => void): void;
-    migrateToOrThrow(migration: string): Promise<import("kysely").MigrationResult[]>;
-    migrateToLatestOrThrow(): Promise<import("kysely").MigrationResult[]>;
-    close(): Promise<void>;
-}
-export default Database;
-type TxnEmitter = TypedEmitter<TxnEvents>;
-type TxnEvents = {
-    commit: () => void;
-};