@atproto/ozone 0.0.2

package/dist/daemon/config.d.ts

@@ -0,0 +1,23 @@
+export interface DaemonConfigValues {
+    version: string;
+    dbPostgresUrl: string;
+    dbPostgresSchema?: string;
+    serverDid: string;
+    appviewUrl: string;
+    appviewDid?: string;
+    pdsUrl?: string;
+    pdsDid?: string;
+}
+export declare class DaemonConfig {
+    private cfg;
+    constructor(cfg: DaemonConfigValues);
+    static readEnv(overrides?: Partial<DaemonConfigValues>): DaemonConfig;
+    get version(): string;
+    get dbPostgresUrl(): string;
+    get dbPostgresSchema(): string | undefined;
+    get serverDid(): string;
+    get appviewUrl(): string;
+    get appviewDid(): string | undefined;
+    get pdsUrl(): string | undefined;
+    get pdsDid(): string | undefined;
+}

package/dist/daemon/context.d.ts

@@ -0,0 +1,25 @@
+import { Keypair } from '@atproto/crypto';
+import { OzoneConfig, OzoneSecrets } from '../config';
+import { Database } from '../db';
+import { EventPusher } from './event-pusher';
+import { EventReverser } from './event-reverser';
+import { ModerationServiceCreator } from '../mod-service';
+export type DaemonContextOptions = {
+    db: Database;
+    cfg: OzoneConfig;
+    modService: ModerationServiceCreator;
+    signingKey: Keypair;
+    eventPusher: EventPusher;
+    eventReverser: EventReverser;
+};
+export declare class DaemonContext {
+    private opts;
+    constructor(opts: DaemonContextOptions);
+    static fromConfig(cfg: OzoneConfig, secrets: OzoneSecrets, overrides?: Partial<DaemonContextOptions>): Promise<DaemonContext>;
+    get db(): Database;
+    get cfg(): OzoneConfig;
+    get modService(): ModerationServiceCreator;
+    get eventPusher(): EventPusher;
+    get eventReverser(): EventReverser;
+}
+export default DaemonContext;

package/dist/daemon/event-pusher.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+import AtpAgent from '@atproto/api';
+import Database from '../db';
+type PollState = {
+    timer?: NodeJS.Timer;
+    promise: Promise<void>;
+};
+type AuthHeaders = {
+    headers: {
+        authorization: string;
+    };
+};
+type Service = {
+    agent: AtpAgent;
+    did: string;
+};
+export declare class EventPusher {
+    db: Database;
+    createAuthHeaders: (aud: string) => Promise<AuthHeaders>;
+    destroyed: boolean;
+    repoPollState: PollState;
+    recordPollState: PollState;
+    blobPollState: PollState;
+    appview: Service | undefined;
+    pds: Service | undefined;
+    constructor(db: Database, createAuthHeaders: (aud: string) => Promise<AuthHeaders>, services: {
+        appview?: {
+            url: string;
+            did: string;
+        };
+        pds?: {
+            url: string;
+            did: string;
+        };
+    });
+    start(): void;
+    poll(state: PollState, fn: () => Promise<void>): void;
+    processAll(): Promise<void>;
+    destroy(): Promise<void>;
+    pushRepoEvents(): Promise<void>;
+    pushRecordEvents(): Promise<void>;
+    pushBlobEvents(): Promise<void>;
+    private updateSubjectOnService;
+    attemptRepoEvent(id: number): Promise<void>;
+    attemptRecordEvent(id: number): Promise<void>;
+    attemptBlobEvent(id: number): Promise<void>;
+}
+export {};

package/dist/daemon/event-reverser.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { ModerationServiceCreator, ReversalSubject } from '../mod-service';
+import Database from '../db';
+export declare class EventReverser {
+    private db;
+    private modService;
+    destroyed: boolean;
+    reversalPromise: Promise<void>;
+    timer: NodeJS.Timer | undefined;
+    constructor(db: Database, modService: ModerationServiceCreator);
+    start(): void;
+    poll(): void;
+    destroy(): Promise<void>;
+    revertState(subject: ReversalSubject): Promise<void>;
+    findAndRevertDueActions(): Promise<void>;
+}

package/dist/daemon/index.d.ts

@@ -0,0 +1,13 @@
+import { OzoneConfig, OzoneSecrets } from '../config';
+import DaemonContext from './context';
+import { AppContextOptions } from '../context';
+export { EventPusher } from './event-pusher';
+export { EventReverser } from './event-reverser';
+export declare class OzoneDaemon {
+    ctx: DaemonContext;
+    constructor(ctx: DaemonContext);
+    static create(cfg: OzoneConfig, secrets: OzoneSecrets, overrides?: Partial<AppContextOptions>): Promise<OzoneDaemon>;
+    start(): Promise<void>;
+    processAll(): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/db/index.d.ts

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