@clioplaylists/clio 0.1.0 → 0.1.1

package/dist/.env

@@ -1,5 +1,5 @@
 NODE_ENV='development'
-CLIO_VERSION=v0.0.1
+CLIO_VERSION=v0.1.0
 CLIO_PORT=8000
 DID_PLC_URL='https://plc.directory'
 LOG_ENABLED=true

package/dist/api/health.d.ts

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

package/dist/api/index.d.ts

@@ -0,0 +1,4 @@
+import AppContext from '../context';
+import { Server } from '../lexicons';
+export * as health from './health';
+export default function (server: Server, ctx: AppContext): Server;

package/dist/api/util.d.ts

@@ -0,0 +1,9 @@
+import { ParsedLabelers } from '../util';
+export declare const ATPROTO_CONTENT_LABELERS = "Atproto-Content-Labelers";
+export declare const ATPROTO_REPO_REV = "Atproto-Repo-Rev";
+type ResHeaderOpts = {
+    labelers: ParsedLabelers;
+    repoRev: string | null;
+};
+export declare const resHeaders: (opts: Partial<ResHeaderOpts>) => Record<string, string>;
+export {};

package/dist/auth-verifier.d.ts

@@ -0,0 +1,92 @@
+import { VerifySignatureWithKeyFn } from '@atproto/xrpc-server';
+import express from 'express';
+import { KeyObject } from 'node:crypto';
+import { DataPlaneClient } from './client';
+type ReqCtx = {
+    req: express.Request;
+};
+type StandardAuthOpts = {
+    skipAudCheck?: boolean;
+    lxmCheck?: (method?: string) => boolean;
+};
+export declare enum RoleStatus {
+    Valid = 0,
+    Invalid = 1,
+    Missing = 2
+}
+type NullOutput = {
+    credentials: {
+        type: 'none';
+        iss: null;
+    };
+};
+type StandardOutput = {
+    credentials: {
+        type: 'standard';
+        aud: string;
+        iss: string;
+    };
+};
+type RoleOutput = {
+    credentials: {
+        type: 'role';
+        admin: boolean;
+    };
+};
+type ModServiceOutput = {
+    credentials: {
+        type: 'mod_service';
+        aud: string;
+        iss: string;
+    };
+};
+export type AuthVerifierOpts = {
+    ownDid: string;
+    alternateAudienceDids: string[];
+    modServiceDid: string;
+    adminPasses: string[];
+    entrywayJwtPublicKey?: KeyObject;
+};
+export declare class AuthVerifier {
+    dataplane: DataPlaneClient;
+    ownDid: string;
+    standardAudienceDids: Set<string>;
+    modServiceDid: string;
+    private adminPasses;
+    private entrywayJwtPublicKey?;
+    constructor(dataplane: DataPlaneClient, opts: AuthVerifierOpts);
+    standardOptionalParameterized: (opts: StandardAuthOpts) => (ctx: ReqCtx) => Promise<StandardOutput | NullOutput>;
+    standardOptional: (ctx: ReqCtx) => Promise<StandardOutput | NullOutput>;
+    standard: (ctx: ReqCtx) => Promise<StandardOutput>;
+    role: (ctx: ReqCtx) => RoleOutput;
+    standardOrRole: (ctx: ReqCtx) => Promise<StandardOutput | RoleOutput>;
+    optionalStandardOrRole: (ctx: ReqCtx) => Promise<StandardOutput | RoleOutput | NullOutput>;
+    entrywaySession: (reqCtx: ReqCtx) => Promise<StandardOutput>;
+    parseRoleCreds(req: express.Request): {
+        status: RoleStatus;
+        admin: boolean;
+        moderator: boolean;
+        triage: boolean;
+    } | {
+        status: RoleStatus;
+        admin: boolean;
+        moderator?: undefined;
+        triage?: undefined;
+    };
+    isModService(iss: string): boolean;
+    nullCreds(): NullOutput;
+    parseCreds(creds: StandardOutput | RoleOutput | ModServiceOutput | NullOutput): {
+        viewer: string | null;
+        includeTakedowns: boolean;
+        include3pBlocks: boolean;
+        canPerformTakedown: boolean;
+    };
+}
+export declare const parseBasicAuth: (token: string) => {
+    username: string;
+    password: string;
+} | null;
+export declare const buildBasicAuth: (username: string, password: string) => string;
+export declare const createPublicKeyObject: (publicKeyHex: string) => KeyObject;
+export declare const verifySignatureWithKey: VerifySignatureWithKeyFn;
+export {};

package/dist/client.d.ts

@@ -0,0 +1,9 @@
+import { Client } from '@connectrpc/connect';
+import { ClioService } from './rpc/clio_connect';
+export type DataPlaneClient = Client<typeof ClioService>;
+type HttpVersion = '1.1' | '2';
+export declare const createBaseClient: (baseUrl: string, opts: {
+    httpVersion?: HttpVersion;
+    rejectUnauthorized?: boolean;
+}) => DataPlaneClient;
+export {};

package/dist/config.d.ts

@@ -0,0 +1,21 @@
+export interface ServerConfigValues {
+    version?: string;
+    debugMode?: boolean;
+    port?: number;
+    serverDid: string;
+    didPlcUrl: string;
+    handleResolverNameservers?: string[];
+}
+export declare class ServerConfig {
+    private cfg;
+    private assignedPort?;
+    constructor(cfg: ServerConfigValues);
+    static readEnv(overrides?: Partial<ServerConfigValues>): ServerConfig;
+    assignPort(port: number): void;
+    get version(): string | undefined;
+    get debugMode(): boolean;
+    get port(): number | undefined;
+    get localUrl(): string;
+    get serverDid(): string;
+    get didPlcUrl(): string;
+}

package/dist/context.d.ts

@@ -0,0 +1,11 @@
+import { DataPlaneClient } from './client';
+import { ServerConfig } from './config';
+export default class AppContext {
+    private opts;
+    constructor(opts: {
+        cfg: ServerConfig;
+        dataplane: DataPlaneClient;
+    });
+    get cfg(): ServerConfig;
+    get dataplane(): DataPlaneClient;
+}

package/dist/dataplane/client.d.ts

@@ -0,0 +1,27 @@
+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/index.d.ts

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

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

@@ -0,0 +1,13 @@
+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/db/database-schema.d.ts

@@ -0,0 +1,13 @@
+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/db.d.ts

@@ -0,0 +1,32 @@
+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;
+};

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

@@ -0,0 +1 @@
+export * from './db';

package/dist/dataplane/server/db/migrations/20230309T045948368Z-init.d.ts

@@ -0,0 +1,3 @@
+import { Kysely } from 'kysely';
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;

package/dist/dataplane/server/db/migrations/20230420T211446071Z-did-cache.d.ts

@@ -0,0 +1,3 @@
+import { Kysely } from 'kysely';
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;

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

@@ -0,0 +1,2 @@
+export * as _20230309T045948368Z from './20230309T045948368Z-init';
+export * as _20230420T211446071Z from './20230420T211446071Z-did-cache';

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

@@ -0,0 +1,11 @@
+import { Kysely, Migration, MigrationProvider } from 'kysely';
+export declare class CtxMigrationProvider<T> implements MigrationProvider {
+    private migrations;
+    private ctx;
+    constructor(migrations: Record<string, CtxMigration<T>>, ctx: T);
+    getMigrations(): Promise<Record<string, Migration>>;
+}
+export interface CtxMigration<T> {
+    up(db: Kysely<unknown>, ctx: T): Promise<void>;
+    down?(db: Kysely<unknown>, ctx: T): Promise<void>;
+}

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

@@ -0,0 +1,86 @@
+import { AnyQb, DbRef } from './util';
+export type Cursor = {
+    primary: string;
+    secondary: string;
+};
+export type LabeledResult = {
+    primary: string | number;
+    secondary: string | number;
+};
+/**
+ * The GenericKeyset is an abstract class that sets-up the interface and partial implementation
+ * of a keyset-paginated cursor with two parts. There are three types involved:
+ *  - Result: a raw result (i.e. a row from the db) containing data that will make-up a cursor.
+ *    - E.g. { createdAt: '2022-01-01T12:00:00Z', cid: 'bafyx' }
+ *  - LabeledResult: a Result processed such that the "primary" and "secondary" parts of the cursor are labeled.
+ *    - E.g. { primary: '2022-01-01T12:00:00Z', secondary: 'bafyx' }
+ *  - Cursor: the two string parts that make-up the packed/string cursor.
+ *    - E.g. packed cursor '1641038400000__bafyx' in parts { primary: '1641038400000', secondary: 'bafyx' }
+ *
+ * These types relate as such. Implementers define the relations marked with a *:
+ *   Result -*-> LabeledResult <-*-> Cursor <--> packed/string cursor
+ *                     ↳ SQL Condition
+ */
+export declare abstract class GenericKeyset<R, LR extends LabeledResult> {
+    primary: DbRef;
+    secondary: DbRef;
+    constructor(primary: DbRef, secondary: DbRef);
+    abstract labelResult(result: R): LR;
+    abstract labeledResultToCursor(labeled: LR): Cursor;
+    abstract cursorToLabeledResult(cursor: Cursor): LR;
+    packFromResult(results: R | R[]): string | undefined;
+    pack(labeled?: LR): string | undefined;
+    unpack(cursorStr?: string): LR | undefined;
+    packCursor(cursor?: Cursor): string | undefined;
+    unpackCursor(cursorStr?: string): Cursor | undefined;
+    getSql(labeled?: LR, direction?: 'asc' | 'desc', tryIndex?: boolean): import("kysely").RawBuilder<unknown> | undefined;
+}
+type SortAtCidResult = {
+    sortAt: string;
+    cid: string;
+};
+type TimeCidLabeledResult = Cursor;
+export declare class TimeCidKeyset<TimeCidResult = SortAtCidResult> extends GenericKeyset<TimeCidResult, TimeCidLabeledResult> {
+    labelResult(result: TimeCidResult): TimeCidLabeledResult;
+    labeledResultToCursor(labeled: TimeCidLabeledResult): {
+        primary: string;
+        secondary: string;
+    };
+    cursorToLabeledResult(cursor: Cursor): {
+        primary: string;
+        secondary: string;
+    };
+}
+export declare class CreatedAtDidKeyset extends TimeCidKeyset<{
+    createdAt: string;
+    did: string;
+}> {
+    labelResult(result: {
+        createdAt: string;
+        did: string;
+    }): {
+        primary: string;
+        secondary: string;
+    };
+}
+export declare class IndexedAtDidKeyset extends TimeCidKeyset<{
+    indexedAt: string;
+    did: string;
+}> {
+    labelResult(result: {
+        indexedAt: string;
+        did: string;
+    }): {
+        primary: string;
+        secondary: string;
+    };
+}
+export declare const paginate: <QB extends AnyQb, K extends GenericKeyset<unknown, any>>(qb: QB, opts: {
+    limit?: number;
+    cursor?: string;
+    direction?: "asc" | "desc";
+    keyset: K;
+    tryIndex?: boolean;
+    nullsLast?: boolean;
+}) => QB;
+export {};

package/dist/dataplane/server/db/tables/actor-sync.d.ts

@@ -0,0 +1,9 @@
+export declare const tableName = "actor_sync";
+export interface ActorSync {
+    did: string;
+    commitCid: string;
+    repoRev: string | null;
+}
+export type PartialDB = {
+    [tableName]: ActorSync;
+};

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

@@ -0,0 +1,11 @@
+export declare const tableName = "actor";
+export interface ActorTable {
+    did: string;
+    handle?: string | null;
+    indexed_at: string;
+    takedownRef?: string | null;
+    upstreamStatus?: string | null;
+}
+export type PartialDB = {
+    [tableName]: ActorTable;
+};

package/dist/dataplane/server/db/tables/artist-list-item.d.ts

@@ -0,0 +1,11 @@
+import { Generated } from 'kysely';
+export declare const tableName = "artist_list_item";
+export interface ArtistListItemTable {
+    id: Generated<number>;
+    song_id: number;
+    seq_num: number;
+    artist_id: number;
+}
+export type PartialDB = {
+    [tableName]: ArtistListItemTable;
+};

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

@@ -0,0 +1,10 @@
+import { Generated } from 'kysely';
+export declare const tableName = "artist";
+export interface ArtistTable {
+    id: Generated<number>;
+    name: string;
+    mb_id: string;
+}
+export type PartialDB = {
+    [tableName]: ArtistTable;
+};

package/dist/dataplane/server/db/tables/playlist-idea.d.ts

@@ -0,0 +1,14 @@
+export declare const tableName = "playlist_idea";
+export interface PlaylistIdeaTable {
+    uri: string;
+    title: string;
+    description?: string;
+    creator_did: string;
+    owner_did: string;
+    master_playlist_id?: number;
+    recommended_playlist_id?: number;
+    created_at: string;
+}
+export type PartialDB = {
+    [tableName]: PlaylistIdeaTable;
+};

package/dist/dataplane/server/db/tables/playlist-item.d.ts

@@ -0,0 +1,11 @@
+import { Generated } from 'kysely';
+export declare const tableName = "playlist_item";
+export interface PlaylistItemTable {
+    id: Generated<number>;
+    playlist_id: number;
+    song_id: number;
+    position: number;
+}
+export type PartialDB = {
+    [tableName]: PlaylistItemTable;
+};

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

@@ -0,0 +1,10 @@
+import { Generated } from 'kysely';
+export declare const tableName = "playlist";
+export interface PlaylistTable {
+    id: Generated<number>;
+    playlist_idea_uri: string;
+    type: string;
+}
+export type PartialDB = {
+    [tableName]: PlaylistTable;
+};

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

@@ -0,0 +1,15 @@
+export declare const tableName = "profile";
+export interface ProfileTable {
+    uri: string;
+    cid: string;
+    creator: string;
+    display_name?: string;
+    description?: string;
+    avatar_cid?: string;
+    banner_cid?: string;
+    created_at: string;
+    indexed_at: string;
+}
+export type PartialDB = {
+    [tableName]: ProfileTable;
+};

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

@@ -0,0 +1,12 @@
+export declare const tableName = "record";
+export interface RecordTable {
+    uri: string;
+    cid: string;
+    did: string;
+    json: string;
+    indexed_at: string;
+    takedown_ref?: string;
+}
+export type PartialDB = {
+    [tableName]: RecordTable;
+};

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

@@ -0,0 +1,12 @@
+import { Generated } from 'kysely';
+export declare const tableName = "song";
+export interface SongTable {
+    id: Generated<number>;
+    track_name: string;
+    track_mb_id: string;
+    album_artwork_ref?: string;
+    created_at?: string;
+}
+export type PartialDB = {
+    [tableName]: SongTable;
+};

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

@@ -0,0 +1,9 @@
+import { Pool as PgPool } from 'pg';
+export type PgOptions = {
+    url: string;
+    pool?: PgPool;
+    schema?: string;
+    poolSize?: number;
+    poolMaxUses?: number;
+    poolIdleTimeoutMs?: number;
+};

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

@@ -0,0 +1,20 @@
+import { DummyDriver, DynamicModule, ExpressionBuilder, RawBuilder, SelectQueryBuilder, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from 'kysely';
+import { DatabaseSchema, DatabaseSchemaType } from './database-schema';
+export declare const actorWhereClause: (actor: string) => RawBuilder<0 | 1>;
+export declare const notSoftDeletedClause: (alias: DbRef) => RawBuilder<unknown>;
+export declare const softDeleted: (actorOrRecord: {
+    takedownRef: string | null;
+}) => boolean;
+export declare const countAll: RawBuilder<number>;
+export declare const excluded: <T>(db: DatabaseSchema, col: any) => RawBuilder<T>;
+export declare const noMatch: RawBuilder<unknown>;
+export declare const valuesList: (vals: unknown[]) => RawBuilder<unknown>;
+export declare const dummyDialect: {
+    createAdapter(): SqliteAdapter;
+    createDriver(): DummyDriver;
+    createIntrospector(db: any): SqliteIntrospector;
+    createQueryCompiler(): SqliteQueryCompiler;
+};
+export type DbRef = RawBuilder | ReturnType<DynamicModule['ref']>;
+export type Subquery = ExpressionBuilder<DatabaseSchemaType, any>;
+export type AnyQb = SelectQueryBuilder<any, any, any>;

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

@@ -0,0 +1,11 @@
+import { IdResolver } from '@atproto/identity';
+import http from 'node:http';
+import { Database } from './db';
+export { RepoSubscription } from './subscription';
+export declare class DataPlaneServer {
+    server: http.Server;
+    idResolver: IdResolver;
+    constructor(server: http.Server, idResolver: IdResolver);
+    static create(db: Database, port: number, plcUrl?: string): Promise<DataPlaneServer>;
+    destroy(): Promise<void>;
+}

package/dist/dataplane/server/indexing/index.d.ts

@@ -0,0 +1,32 @@
+import { IdResolver } from '@atproto/identity';
+import { WriteOpAction } from '@atproto/repo';
+import { AtUri } from '@atproto/syntax';
+import { CID } from 'multiformats/cid';
+import { Database } from '../db';
+import * as PlaylistIdea from './plugins/playlist-idea';
+import * as Profile from './plugins/profile';
+import { RecordProcessor } from './processor';
+export declare class IndexingService {
+    db: Database;
+    idResolver: IdResolver;
+    records: {
+        playlistIdea: PlaylistIdea.PluginType;
+        profile: Profile.PluginType;
+    };
+    constructor(db: Database, idResolver: IdResolver);
+    transact(txn: Database): IndexingService;
+    indexRecord(uri: AtUri, cid: CID, obj: unknown, action: WriteOpAction.Create | WriteOpAction.Update, timestamp: string): Promise<void>;
+    deleteRecord(uri: AtUri, cascading?: boolean): Promise<void>;
+    indexHandle(did: string, timestamp: string, force?: boolean): Promise<void>;
+    indexRepo(did: string, commit?: string): Promise<void>;
+    updateActorStatus(did: string, active: boolean, status?: string): Promise<void>;
+    setCommitLastSeen(did: string, commit: CID, rev: string): Promise<void>;
+    getCurrentRecords(did: string): Promise<Record<string, {
+        uri: AtUri;
+        cid: CID;
+    }>>;
+    findIndexerForCollection(collection: string): RecordProcessor<unknown, unknown> | undefined;
+    deleteActor(did: string): Promise<void>;
+    private getActorIsHosted;
+    unindexActor(did: string): Promise<void>;
+}

package/dist/dataplane/server/indexing/plugins/playlist-idea.d.ts

@@ -0,0 +1,14 @@
+import { Selectable } from 'kysely';
+import { MasterPlaylist, Record as PlaylistIdeaRecord, RecommendedPlaylist } from '../../../../lexicons/types/com/clioplaylists/alpha/feed/playlistIdea';
+import { Database } from '../../db';
+import { DatabaseSchemaType } from '../../db/database-schema';
+import { RecordProcessor } from '../processor';
+type PlaylistIdea = Selectable<DatabaseSchemaType['playlist_idea']>;
+type IndexedPlaylistIdea = {
+    playlistIdea: PlaylistIdea;
+    masterPlaylist?: MasterPlaylist;
+    recommendedPlaylist?: RecommendedPlaylist;
+};
+export type PluginType = RecordProcessor<PlaylistIdeaRecord, IndexedPlaylistIdea>;
+export declare const makePlugin: (db: Database) => PluginType;
+export default makePlugin;

package/dist/dataplane/server/indexing/plugins/profile.d.ts

@@ -0,0 +1,8 @@
+import * as Profile from '../../../../lexicons/types/com/clioplaylists/alpha/actor/profile';
+import { Database } from '../../db';
+import { DatabaseSchemaType } from '../../db/database-schema';
+import { RecordProcessor } from '../processor';
+type IndexedProfile = DatabaseSchemaType['profile'];
+export type PluginType = RecordProcessor<Profile.Record, IndexedProfile>;
+export declare const makePlugin: (db: Database) => PluginType;
+export default makePlugin;

package/dist/dataplane/server/indexing/processor.d.ts

@@ -0,0 +1,22 @@
+import { AtUri } from '@atproto/syntax';
+import { CID } from 'multiformats/cid';
+import { Database } from '../db';
+import { DatabaseSchema } from '../db/database-schema';
+type RecordProcessorParams<T, S> = {
+    lexId: string;
+    insertFn: (db: DatabaseSchema, uri: AtUri, cid: CID, obj: T, timestamp: string) => Promise<S | null>;
+    findDuplicate: (db: DatabaseSchema, uri: AtUri, obj: T) => Promise<AtUri | null>;
+    deleteFn: (db: DatabaseSchema, uri: AtUri) => Promise<S | null>;
+};
+export declare class RecordProcessor<T, S> {
+    private params;
+    collection: string;
+    db: DatabaseSchema;
+    constructor(appDb: Database, params: RecordProcessorParams<T, S>);
+    matchesSchema(obj: unknown): obj is T;
+    assertValidRecord(obj: unknown): asserts obj is T;
+    insertRecord(uri: AtUri, cid: CID, obj: unknown, timestamp: string): Promise<void>;
+    updateRecord(uri: AtUri, cid: CID, obj: unknown, timestamp: string): Promise<void>;
+    deleteRecord(uri: AtUri, cascading?: boolean): Promise<void>;
+}
+export default RecordProcessor;

package/dist/dataplane/server/routes/identity.d.ts

@@ -0,0 +1,6 @@
+import { IdResolver } from '@atproto/identity';
+import { ServiceImpl } from '@connectrpc/connect';
+import { ClioService } from '../../../rpc/clio_connect';
+import { Database } from '../db';
+declare const _default: (_db: Database, idResolver: IdResolver) => Partial<ServiceImpl<typeof ClioService>>;
+export default _default;