@atproto/bsync 0.0.0

package/LICENSE.txt

@@ -0,0 +1,7 @@
+Dual MIT/Apache-2.0 License
+
+Copyright (c) 2022-2023 Bluesky PBC, and Contributors
+
+Except as otherwise noted in individual files, this software is licensed under the MIT license (<http://opensource.org/licenses/MIT>), or the Apache License, Version 2.0 (<http://www.apache.org/licenses/LICENSE-2.0>).
+
+Downstream projects and end users may chose either license individually, or both together, at their discretion. The motivation for this dual-licensing is the additional software patent assurance provided by Apache 2.0.

package/README.md

@@ -0,0 +1,15 @@
+# @atproto/bsync: Synchronizing Service for the Bluesky AppView
+
+This is an optional service that may be used to synchronize certain state between otherwise independent AppViews.
+
+[![NPM](https://img.shields.io/npm/v/@atproto/bsync)](https://www.npmjs.com/package/@atproto/bsync)
+[![Github CI Status](https://github.com/bluesky-social/atproto/actions/workflows/repo.yaml/badge.svg)](https://github.com/bluesky-social/atproto/actions/workflows/repo.yaml)
+
+## License
+
+This project is dual-licensed under MIT and Apache 2.0 terms:
+
+- MIT license ([LICENSE-MIT.txt](https://github.com/bluesky-social/atproto/blob/main/LICENSE-MIT.txt) or http://opensource.org/licenses/MIT)
+- Apache License, Version 2.0, ([LICENSE-APACHE.txt](https://github.com/bluesky-social/atproto/blob/main/LICENSE-APACHE.txt) or http://www.apache.org/licenses/LICENSE-2.0)
+
+Downstream projects and end users may chose either license individually, or both together, at their discretion. The motivation for this dual-licensing is the additional software patent assurance provided by Apache 2.0.

package/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: [['@babel/preset-env']],
+}

package/bin/migration-create.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env ts-node
+
+import * as fs from 'fs/promises'
+import * as path from 'path'
+
+export async function main() {
+  const now = new Date()
+  const prefix = now.toISOString().replace(/[^a-z0-9]/gi, '') // Order of migrations matches alphabetical order of their names
+  const name = process.argv[2]
+  if (!name || !name.match(/^[a-z0-9-]+$/)) {
+    process.exitCode = 1
+    return console.error(
+      'Must pass a migration name consisting of lowercase digits, numbers, and dashes.',
+    )
+  }
+  const filename = `${prefix}-${name}`
+  const dir = path.join(__dirname, '..', 'src', 'db', 'migrations')
+
+  await fs.writeFile(path.join(dir, `${filename}.ts`), template, { flag: 'wx' })
+  await fs.writeFile(
+    path.join(dir, 'index.ts'),
+    `export * as _${prefix} from './${filename}'\n`,
+    { flag: 'a' },
+  )
+}
+
+const template = `import { Kysely } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  // Migration code
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  // Migration code
+}
+`
+
+main()

package/buf.gen.yaml

@@ -0,0 +1,13 @@
+version: v1
+plugins:
+  - plugin: es
+    opt:
+      - target=ts
+      - import_extension=.ts
+
+    out: src/gen
+  - plugin: connect-es
+    opt:
+      - target=ts
+      - import_extension=.ts
+    out: src/gen

package/build.js

@@ -0,0 +1,18 @@
+const { nodeExternalsPlugin } = require('esbuild-node-externals')
+
+const buildShallow =
+  process.argv.includes('--shallow') || process.env.ATP_BUILD_SHALLOW === 'true'
+
+require('esbuild').build({
+  logLevel: 'info',
+  entryPoints: ['src/index.ts'],
+  bundle: true,
+  sourcemap: true,
+  outdir: 'dist',
+  platform: 'node',
+  external: [
+    // Referenced in pg driver, but optional and we don't use it
+    'pg-native',
+  ],
+  plugins: buildShallow ? [nodeExternalsPlugin()] : [],
+})

package/dist/client.d.ts

@@ -0,0 +1,6 @@
+import { Interceptor, PromiseClient } from '@connectrpc/connect';
+import { ConnectTransportOptions } from '@connectrpc/connect-node';
+import { Service } from './gen/bsync_connect';
+export type BsyncClient = PromiseClient<typeof Service>;
+export declare const createClient: (opts: ConnectTransportOptions) => BsyncClient;
+export declare const authWithApiKey: (apiKey: string) => Interceptor;

package/dist/config.d.ts

@@ -0,0 +1,36 @@
+export declare const envToCfg: (env: ServerEnvironment) => ServerConfig;
+export type ServerConfig = {
+    service: ServiceConfig;
+    db: DatabaseConfig;
+    auth: AuthConfig;
+};
+type ServiceConfig = {
+    port: number;
+    version?: string;
+    longPollTimeoutMs: number;
+};
+type DatabaseConfig = {
+    url: string;
+    schema?: string;
+    poolSize?: number;
+    poolMaxUses?: number;
+    poolIdleTimeoutMs?: number;
+    migrate?: boolean;
+};
+type AuthConfig = {
+    apiKeys: Set<string>;
+};
+export declare const readEnv: () => ServerEnvironment;
+export type ServerEnvironment = {
+    port?: number;
+    version?: string;
+    longPollTimeoutMs?: number;
+    dbUrl?: string;
+    dbSchema?: string;
+    dbPoolSize?: number;
+    dbPoolMaxUses?: number;
+    dbPoolIdleTimeoutMs?: number;
+    dbMigrate?: boolean;
+    apiKeys: string[];
+};
+export {};

package/dist/context.d.ts

@@ -0,0 +1,19 @@
+import TypedEventEmitter from 'typed-emitter';
+import { ServerConfig } from './config';
+import Database from './db';
+import { createMuteOpChannel } from './db/schema/mute_op';
+export type AppContextOptions = {
+    db: Database;
+    cfg: ServerConfig;
+};
+export declare class AppContext {
+    db: Database;
+    cfg: ServerConfig;
+    events: TypedEventEmitter<AppEvents>;
+    constructor(opts: AppContextOptions);
+    static fromConfig(cfg: ServerConfig, overrides?: Partial<AppContextOptions>): Promise<AppContext>;
+}
+export default AppContext;
+export type AppEvents = {
+    [createMuteOpChannel]: () => void;
+};

package/dist/db/index.d.ts

@@ -0,0 +1,31 @@
+import { Migrator } from 'kysely';
+import TypedEmitter from 'typed-emitter';
+import { Pool as PgPool } from 'pg';
+import DatabaseSchema from './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;
+    });
+    get schema(): string | undefined;
+    get isTransaction(): boolean;
+    assertTransaction(): void;
+    assertNotTransaction(): void;
+    transaction<T>(fn: (db: Database) => Promise<T>): Promise<T>;
+    onCommit(fn: () => void): void;
+    close(): Promise<void>;
+    migrateToOrThrow(migration: string): Promise<import("kysely").MigrationResult[]>;
+    migrateToLatestOrThrow(): Promise<import("kysely").MigrationResult[]>;
+}
+export default Database;
+type TxnEmitter = TypedEmitter<TxnEvents>;
+type TxnEvents = {
+    commit: () => void;
+};

package/dist/db/migrations/20240108T220751294Z-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/db/migrations/index.d.ts

@@ -0,0 +1 @@
+export * as _20240108T220751294Z from './20240108T220751294Z-init';

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

@@ -0,0 +1,6 @@
+import { Migration, MigrationProvider } from 'kysely';
+export declare class DbMigrationProvider implements MigrationProvider {
+    private migrations;
+    constructor(migrations: Record<string, Migration>);
+    getMigrations(): Promise<Record<string, Migration>>;
+}

package/dist/db/schema/index.d.ts

@@ -0,0 +1,6 @@
+import { Kysely } from 'kysely';
+import * as muteOp from './mute_op';
+import * as muteItem from './mute_item';
+export type DatabaseSchemaType = muteItem.PartialDB & muteOp.PartialDB;
+export type DatabaseSchema = Kysely<DatabaseSchemaType>;
+export default DatabaseSchema;

package/dist/db/schema/mute_item.d.ts

@@ -0,0 +1,11 @@
+import { Selectable } from 'kysely';
+export interface MuteItem {
+    actorDid: string;
+    subject: string;
+    fromId: number;
+}
+export type MuteItemEntry = Selectable<MuteItem>;
+export declare const tableName = "mute_item";
+export type PartialDB = {
+    [tableName]: MuteItem;
+};

package/dist/db/schema/mute_op.d.ts

@@ -0,0 +1,15 @@
+import { GeneratedAlways, Selectable } from 'kysely';
+import { MuteOperation_Type } from '../../gen/bsync_pb';
+export interface MuteOp {
+    id: GeneratedAlways<number>;
+    type: MuteOperation_Type;
+    actorDid: string;
+    subject: string;
+    createdAt: GeneratedAlways<Date>;
+}
+export type MuteOpEntry = Selectable<MuteOp>;
+export declare const tableName = "mute_op";
+export type PartialDB = {
+    [tableName]: MuteOp;
+};
+export declare const createMuteOpChannel = "mute_op_create";

package/dist/db/types.d.ts

@@ -0,0 +1,12 @@
+import { Pool as PgPool } from 'pg';
+import { DynamicModule, RawBuilder, SelectQueryBuilder } from 'kysely';
+export type DbRef = RawBuilder | ReturnType<DynamicModule['ref']>;
+export type AnyQb = SelectQueryBuilder<any, any, any>;
+export type PgOptions = {
+    url: string;
+    pool?: PgPool;
+    schema?: string;
+    poolSize?: number;
+    poolMaxUses?: number;
+    poolIdleTimeoutMs?: number;
+};

package/dist/gen/bsync_connect.d.ts

@@ -0,0 +1,25 @@
+import { AddMuteOperationRequest, AddMuteOperationResponse, PingRequest, PingResponse, ScanMuteOperationsRequest, ScanMuteOperationsResponse } from './bsync_pb.ts';
+import { MethodKind } from '@bufbuild/protobuf';
+export declare const Service: {
+    readonly typeName: "bsync.Service";
+    readonly methods: {
+        readonly addMuteOperation: {
+            readonly name: "AddMuteOperation";
+            readonly I: typeof AddMuteOperationRequest;
+            readonly O: typeof AddMuteOperationResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        readonly scanMuteOperations: {
+            readonly name: "ScanMuteOperations";
+            readonly I: typeof ScanMuteOperationsRequest;
+            readonly O: typeof ScanMuteOperationsResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        readonly ping: {
+            readonly name: "Ping";
+            readonly I: typeof PingRequest;
+            readonly O: typeof PingResponse;
+            readonly kind: MethodKind.Unary;
+        };
+    };
+};

package/dist/gen/bsync_pb.d.ts

@@ -0,0 +1,90 @@
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from '@bufbuild/protobuf';
+import { Message, proto3 } from '@bufbuild/protobuf';
+export declare class MuteOperation extends Message<MuteOperation> {
+    id: string;
+    type: MuteOperation_Type;
+    actorDid: string;
+    subject: string;
+    constructor(data?: PartialMessage<MuteOperation>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.MuteOperation";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MuteOperation;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MuteOperation;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MuteOperation;
+    static equals(a: MuteOperation | PlainMessage<MuteOperation> | undefined, b: MuteOperation | PlainMessage<MuteOperation> | undefined): boolean;
+}
+export declare enum MuteOperation_Type {
+    UNSPECIFIED = 0,
+    ADD = 1,
+    REMOVE = 2,
+    CLEAR = 3
+}
+export declare class AddMuteOperationRequest extends Message<AddMuteOperationRequest> {
+    type: MuteOperation_Type;
+    actorDid: string;
+    subject: string;
+    constructor(data?: PartialMessage<AddMuteOperationRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.AddMuteOperationRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AddMuteOperationRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AddMuteOperationRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AddMuteOperationRequest;
+    static equals(a: AddMuteOperationRequest | PlainMessage<AddMuteOperationRequest> | undefined, b: AddMuteOperationRequest | PlainMessage<AddMuteOperationRequest> | undefined): boolean;
+}
+export declare class AddMuteOperationResponse extends Message<AddMuteOperationResponse> {
+    operation?: MuteOperation;
+    constructor(data?: PartialMessage<AddMuteOperationResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.AddMuteOperationResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AddMuteOperationResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AddMuteOperationResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AddMuteOperationResponse;
+    static equals(a: AddMuteOperationResponse | PlainMessage<AddMuteOperationResponse> | undefined, b: AddMuteOperationResponse | PlainMessage<AddMuteOperationResponse> | undefined): boolean;
+}
+export declare class ScanMuteOperationsRequest extends Message<ScanMuteOperationsRequest> {
+    cursor: string;
+    limit: number;
+    constructor(data?: PartialMessage<ScanMuteOperationsRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.ScanMuteOperationsRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ScanMuteOperationsRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ScanMuteOperationsRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ScanMuteOperationsRequest;
+    static equals(a: ScanMuteOperationsRequest | PlainMessage<ScanMuteOperationsRequest> | undefined, b: ScanMuteOperationsRequest | PlainMessage<ScanMuteOperationsRequest> | undefined): boolean;
+}
+export declare class ScanMuteOperationsResponse extends Message<ScanMuteOperationsResponse> {
+    operations: MuteOperation[];
+    cursor: string;
+    constructor(data?: PartialMessage<ScanMuteOperationsResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.ScanMuteOperationsResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ScanMuteOperationsResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ScanMuteOperationsResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ScanMuteOperationsResponse;
+    static equals(a: ScanMuteOperationsResponse | PlainMessage<ScanMuteOperationsResponse> | undefined, b: ScanMuteOperationsResponse | PlainMessage<ScanMuteOperationsResponse> | undefined): boolean;
+}
+export declare class PingRequest extends Message<PingRequest> {
+    constructor(data?: PartialMessage<PingRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.PingRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PingRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PingRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PingRequest;
+    static equals(a: PingRequest | PlainMessage<PingRequest> | undefined, b: PingRequest | PlainMessage<PingRequest> | undefined): boolean;
+}
+export declare class PingResponse extends Message<PingResponse> {
+    constructor(data?: PartialMessage<PingResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.PingResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PingResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PingResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PingResponse;
+    static equals(a: PingResponse | PlainMessage<PingResponse> | undefined, b: PingResponse | PlainMessage<PingResponse> | undefined): boolean;
+}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import http from 'node:http';
+import AppContext, { AppContextOptions } from './context';
+import { ServerConfig } from './config';
+export * from './config';
+export * from './client';
+export { Database } from './db';
+export { AppContext } from './context';
+export { httpLogger } from './logger';
+export declare class BsyncService {
+    ctx: AppContext;
+    server: http.Server;
+    private ac;
+    private terminator;
+    private dbStatsInterval;
+    constructor(opts: {
+        ctx: AppContext;
+        server: http.Server;
+        ac: AbortController;
+    });
+    static create(cfg: ServerConfig, overrides?: Partial<AppContextOptions>): Promise<BsyncService>;
+    start(): Promise<http.Server>;
+    destroy(): Promise<void>;
+    setupAppEvents(): Promise<void>;
+}
+export default BsyncService;