@clioplaylists/clio 0.1.5 → 0.1.6

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.up = up;
+exports.down = down;
+async function up(db) {
+    await db.schema
+        .createTable('did_cache')
+        .addColumn('did', 'varchar', (col) => col.primaryKey())
+        .addColumn('doc', 'jsonb', (col) => col.notNull())
+        .addColumn('updatedAt', 'bigint', (col) => col.notNull())
+        .execute();
+}
+async function down(db) {
+    await db.schema.dropTable('did_cache').execute();
+}

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/index.js

@@ -0,0 +1,41 @@
+"use strict";
+// NOTE this file can be edited by hand, but it is also appended to by the migration:create command.
+// It's important that every migration is exported from here with the proper name. We'd simplify
+// this with kysely's FileMigrationProvider, but it doesn't play nicely with the build process.
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._20230420T211446071Z = exports._20230309T045948368Z = void 0;
+exports._20230309T045948368Z = __importStar(require("./20230309T045948368Z-init"));
+exports._20230420T211446071Z = __importStar(require("./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/migrations/provider.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CtxMigrationProvider = void 0;
+// Passes a context argument to migrations. We use this to thread the dialect into migrations
+class CtxMigrationProvider {
+    constructor(migrations, ctx) {
+        Object.defineProperty(this, "migrations", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: migrations
+        });
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ctx
+        });
+    }
+    async getMigrations() {
+        const ctxMigrations = {};
+        Object.entries(this.migrations).forEach(([name, migration]) => {
+            ctxMigrations[name] = {
+                up: async (db) => await migration.up(db, this.ctx),
+                down: async (db) => await migration.down?.(db, this.ctx),
+            };
+        });
+        return ctxMigrations;
+    }
+}
+exports.CtxMigrationProvider = CtxMigrationProvider;

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/pagination.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginate = exports.IndexedAtDidKeyset = exports.CreatedAtDidKeyset = exports.TimeCidKeyset = exports.GenericKeyset = void 0;
+const xrpc_server_1 = require("@atproto/xrpc-server");
+const kysely_1 = require("kysely");
+/**
+ * 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
+ */
+class GenericKeyset {
+    constructor(primary, secondary) {
+        Object.defineProperty(this, "primary", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: primary
+        });
+        Object.defineProperty(this, "secondary", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: secondary
+        });
+    }
+    packFromResult(results) {
+        const result = Array.isArray(results) ? results.at(-1) : results;
+        if (!result)
+            return;
+        return this.pack(this.labelResult(result));
+    }
+    pack(labeled) {
+        if (!labeled)
+            return;
+        const cursor = this.labeledResultToCursor(labeled);
+        return this.packCursor(cursor);
+    }
+    unpack(cursorStr) {
+        const cursor = this.unpackCursor(cursorStr);
+        if (!cursor)
+            return;
+        return this.cursorToLabeledResult(cursor);
+    }
+    packCursor(cursor) {
+        if (!cursor)
+            return;
+        return `${cursor.primary}__${cursor.secondary}`;
+    }
+    unpackCursor(cursorStr) {
+        if (!cursorStr)
+            return;
+        const result = cursorStr.split('__');
+        const [primary, secondary, ...others] = result;
+        if (!primary || !secondary || others.length > 0) {
+            throw new xrpc_server_1.InvalidRequestError('Malformed cursor');
+        }
+        return {
+            primary,
+            secondary,
+        };
+    }
+    getSql(labeled, direction, tryIndex) {
+        if (labeled === undefined)
+            return;
+        if (tryIndex) {
+            // The tryIndex param will likely disappear and become the default implementation: here for now for gradual rollout query-by-query.
+            if (direction === 'asc') {
+                return (0, kysely_1.sql) `((${this.primary}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}))`;
+            }
+            else {
+                return (0, kysely_1.sql) `((${this.primary}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}))`;
+            }
+        }
+        else {
+            // @NOTE this implementation can struggle to use an index on (primary, secondary) for pagination due to the "or" usage.
+            if (direction === 'asc') {
+                return (0, kysely_1.sql) `((${this.primary} > ${labeled.primary}) or (${this.primary} = ${labeled.primary} and ${this.secondary} > ${labeled.secondary}))`;
+            }
+            else {
+                return (0, kysely_1.sql) `((${this.primary} < ${labeled.primary}) or (${this.primary} = ${labeled.primary} and ${this.secondary} < ${labeled.secondary}))`;
+            }
+        }
+    }
+}
+exports.GenericKeyset = GenericKeyset;
+class TimeCidKeyset extends GenericKeyset {
+    labelResult(result) {
+        return { primary: result.sortAt, secondary: result.cid };
+    }
+    labeledResultToCursor(labeled) {
+        return {
+            primary: new Date(labeled.primary).getTime().toString(),
+            secondary: labeled.secondary,
+        };
+    }
+    cursorToLabeledResult(cursor) {
+        const primaryDate = new Date(parseInt(cursor.primary, 10));
+        if (isNaN(primaryDate.getTime())) {
+            throw new xrpc_server_1.InvalidRequestError('Malformed cursor');
+        }
+        return {
+            primary: primaryDate.toISOString(),
+            secondary: cursor.secondary,
+        };
+    }
+}
+exports.TimeCidKeyset = TimeCidKeyset;
+class CreatedAtDidKeyset extends TimeCidKeyset {
+    labelResult(result) {
+        return { primary: result.createdAt, secondary: result.did };
+    }
+}
+exports.CreatedAtDidKeyset = CreatedAtDidKeyset;
+class IndexedAtDidKeyset extends TimeCidKeyset {
+    labelResult(result) {
+        return { primary: result.indexedAt, secondary: result.did };
+    }
+}
+exports.IndexedAtDidKeyset = IndexedAtDidKeyset;
+const paginate = (qb, opts) => {
+    const { limit, cursor, keyset, direction = 'desc', tryIndex, nullsLast, } = opts;
+    const keysetSql = keyset.getSql(keyset.unpack(cursor), direction, tryIndex);
+    return qb
+        .if(!!limit, (q) => q.limit(limit))
+        .if(!nullsLast, (q) => q.orderBy(keyset.primary, direction).orderBy(keyset.secondary, direction))
+        .if(!!nullsLast, (q) => q
+        .orderBy(direction === 'asc'
+        ? (0, kysely_1.sql) `${keyset.primary} asc nulls last`
+        : (0, kysely_1.sql) `${keyset.primary} desc nulls last`)
+        .orderBy(direction === 'asc'
+        ? (0, kysely_1.sql) `${keyset.secondary} asc nulls last`
+        : (0, kysely_1.sql) `${keyset.secondary} desc nulls last`))
+        .if(!!keysetSql, (qb) => (keysetSql ? qb.where(keysetSql) : qb));
+};
+exports.paginate = paginate;

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-sync.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'actor_sync';

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/actor.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'actor';

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-list-item.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'artist_list_item';

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/artist.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'artist';

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-idea.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'playlist_idea';

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-item.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'playlist_item';

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/playlist.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'playlist';

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/profile.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'profile';

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/record.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'record';

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/tables/song.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'song';

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/types.js

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

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/db/util.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dummyDialect = exports.valuesList = exports.noMatch = exports.excluded = exports.countAll = exports.softDeleted = exports.notSoftDeletedClause = exports.actorWhereClause = void 0;
+const kysely_1 = require("kysely");
+const actorWhereClause = (actor) => {
+    if (actor.startsWith('did:')) {
+        return (0, kysely_1.sql) `"actor"."did" = ${actor}`;
+    }
+    else {
+        return (0, kysely_1.sql) `"actor"."handle" = ${actor}`;
+    }
+};
+exports.actorWhereClause = actorWhereClause;
+// Applies to actor or record table
+const notSoftDeletedClause = (alias) => {
+    return (0, kysely_1.sql) `${alias}."takedownRef" is null`;
+};
+exports.notSoftDeletedClause = notSoftDeletedClause;
+const softDeleted = (actorOrRecord) => {
+    return actorOrRecord.takedownRef !== null;
+};
+exports.softDeleted = softDeleted;
+exports.countAll = (0, kysely_1.sql) `count(*)`;
+// For use with doUpdateSet()
+const excluded = (db, col) => {
+    return (0, kysely_1.sql) `${db.dynamic.ref(`excluded.${col}`)}`;
+};
+exports.excluded = excluded;
+exports.noMatch = (0, kysely_1.sql) `1 = 0`;
+// Can be useful for large where-in clauses, to get the db to use a hash lookup on the list
+const valuesList = (vals) => {
+    return (0, kysely_1.sql) `(values (${kysely_1.sql.join(vals, (0, kysely_1.sql) `), (`)}))`;
+};
+exports.valuesList = valuesList;
+exports.dummyDialect = {
+    createAdapter() {
+        return new kysely_1.SqliteAdapter();
+    },
+    createDriver() {
+        return new kysely_1.DummyDriver();
+    },
+    createIntrospector(db) {
+        return new kysely_1.SqliteIntrospector(db);
+    },
+    createQueryCompiler() {
+        return new kysely_1.SqliteQueryCompiler();
+    },
+};

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>;
+}