commit 05fbd57d79f414c8421f24f41035980129c7ad8d · cduck.me/statusphere-example-app-fork

biome.json

···

       1
       1
        
       {

     

       2
       2
        
         "$schema": "https://biomejs.dev/schemas/1.8.3/schema.json",

     

       3
       3
       +
         "javascript": {

     

       4
       4
       +
           "formatter": {

     

       5
       5
       +
             "semicolons": "asNeeded",

     

       6
       6
       +
             "quoteStyle": "single"

     

       7
       7
       +
           }

     

       8
       8
       +
         },

     

       3
       9
        
         "formatter": {

     

       4
       10
        
           "indentStyle": "space",

     

       5
       11
        
           "lineWidth": 120

+7 -7

src/config.ts

···

       1
       1
       -
       import type pino from "pino";

     

       2
       2
       -
       import type { Database } from "#/db";

     

       3
       3
       -
       import type { Ingester } from "#/firehose/ingester";

     

       1
       1
       +
       import type pino from 'pino'

     

       2
       2
       +
       import type { Database } from '#/db'

     

       3
       3
       +
       import type { Ingester } from '#/firehose/ingester'

     

       4
       4
        
       

     

       5
       5
        
       export type AppContext = {

     

       6
       6
       -
         db: Database;

     

       7
       7
       -
         ingester: Ingester;

     

       8
       8
       -
         logger: pino.Logger;

     

       9
       9
       -
       };

     

       6
       6
       +
         db: Database

     

       7
       7
       +
         ingester: Ingester

     

       8
       8
       +
         logger: pino.Logger

     

       9
       9
       +
       }

+11 -11

src/db/index.ts

···

       1
       1
       -
       import SqliteDb from "better-sqlite3";

     

       2
       2
       -
       import { Kysely, Migrator, SqliteDialect } from "kysely";

     

       3
       3
       -
       import { migrationProvider } from "./migrations";

     

       4
       4
       -
       import type { DatabaseSchema } from "./schema";

     

       1
       1
       +
       import SqliteDb from 'better-sqlite3'

     

       2
       2
       +
       import { Kysely, Migrator, SqliteDialect } from 'kysely'

     

       3
       3
       +
       import { migrationProvider } from './migrations'

     

       4
       4
       +
       import type { DatabaseSchema } from './schema'

     

       5
       5
        
       

     

       6
       6
        
       export const createDb = (location: string): Database => {

     

       7
       7
        
         return new Kysely<DatabaseSchema>({

     

       8
       8
        
           dialect: new SqliteDialect({

     

       9
       9
        
             database: new SqliteDb(location),

     

       10
       10
        
           }),

     

       11
       11
       -
         });

     

       12
       12
       -
       };

     

       11
       11
       +
         })

     

       12
       12
       +
       }

     

       13
       13
        
       

     

       14
       14
        
       export const migrateToLatest = async (db: Database) => {

     

       15
       15
       -
         const migrator = new Migrator({ db, provider: migrationProvider });

     

       16
       16
       -
         const { error } = await migrator.migrateToLatest();

     

       17
       17
       -
         if (error) throw error;

     

       18
       18
       -
       };

     

       15
       15
       +
         const migrator = new Migrator({ db, provider: migrationProvider })

     

       16
       16
       +
         const { error } = await migrator.migrateToLatest()

     

       17
       17
       +
         if (error) throw error

     

       18
       18
       +
       }

     

       19
       19
        
       

     

       20
       20
       -
       export type Database = Kysely<DatabaseSchema>;

     

       20
       20
       +
       export type Database = Kysely<DatabaseSchema>

+12 -12

src/db/migrations.ts

···

       1
       1
       -
       import type { Kysely, Migration, MigrationProvider } from "kysely";

     

       1
       1
       +
       import type { Kysely, Migration, MigrationProvider } from 'kysely'

     

       2
       2
        
       

     

       3
       3
       -
       const migrations: Record<string, Migration> = {};

     

       3
       3
       +
       const migrations: Record<string, Migration> = {}

     

       4
       4
        
       

     

       5
       5
        
       export const migrationProvider: MigrationProvider = {

     

       6
       6
        
         async getMigrations() {

     

       7
       7
       -
           return migrations;

     

       7
       7
       +
           return migrations

     

       8
       8
        
         },

     

       9
       9
       -
       };

     

       9
       9
       +
       }

     

       10
       10
        
       

     

       11
       11
       -
       migrations["001"] = {

     

       11
       11
       +
       migrations['001'] = {

     

       12
       12
        
         async up(db: Kysely<unknown>) {

     

       13
       13
        
           await db.schema

     

       14
       14
       -
             .createTable("post")

     

       15
       15
       -
             .addColumn("uri", "varchar", (col) => col.primaryKey())

     

       16
       16
       -
             .addColumn("text", "varchar", (col) => col.notNull())

     

       17
       17
       -
             .addColumn("indexedAt", "varchar", (col) => col.notNull())

     

       18
       18
       -
             .execute();

     

       14
       14
       +
             .createTable('post')

     

       15
       15
       +
             .addColumn('uri', 'varchar', (col) => col.primaryKey())

     

       16
       16
       +
             .addColumn('text', 'varchar', (col) => col.notNull())

     

       17
       17
       +
             .addColumn('indexedAt', 'varchar', (col) => col.notNull())

     

       18
       18
       +
             .execute()

     

       19
       19
        
         },

     

       20
       20
        
         async down(db: Kysely<unknown>) {

     

       21
       21
       -
           await db.schema.dropTable("post").execute();

     

       21
       21
       +
           await db.schema.dropTable('post').execute()

     

       22
       22
        
         },

     

       23
       23
       -
       };

     

       23
       23
       +
       }

+6 -6

src/db/schema.ts

···

       1
       1
        
       export type DatabaseSchema = {

     

       2
       2
       -
         post: Post;

     

       3
       3
       -
       };

     

       2
       2
       +
         post: Post

     

       3
       3
       +
       }

     

       4
       4
        
       

     

       5
       5
        
       export type Post = {

     

       6
       6
       -
         uri: string;

     

       7
       7
       -
         text: string;

     

       8
       8
       -
         indexedAt: string;

     

       9
       9
       -
       };

     

       6
       6
       +
         uri: string

     

       7
       7
       +
         text: string

     

       8
       8
       +
         indexedAt: string

     

       9
       9
       +
       }

+7 -7

src/env.ts

···

       1
       1
       -
       import dotenv from "dotenv";

     

       2
       2
       -
       import { cleanEnv, host, num, port, str, testOnly } from "envalid";

     

       1
       1
       +
       import dotenv from 'dotenv'

     

       2
       2
       +
       import { cleanEnv, host, num, port, str, testOnly } from 'envalid'

     

       3
       3
        
       

     

       4
       4
       -
       dotenv.config();

     

       4
       4
       +
       dotenv.config()

     

       5
       5
        
       

     

       6
       6
        
       export const env = cleanEnv(process.env, {

     

       7
       7
       -
         NODE_ENV: str({ devDefault: testOnly("test"), choices: ["development", "production", "test"] }),

     

       8
       8
       -
         HOST: host({ devDefault: testOnly("localhost") }),

     

       7
       7
       +
         NODE_ENV: str({ devDefault: testOnly('test'), choices: ['development', 'production', 'test'] }),

     

       8
       8
       +
         HOST: host({ devDefault: testOnly('localhost') }),

     

       9
       9
        
         PORT: port({ devDefault: testOnly(3000) }),

     

       10
       10
       -
         CORS_ORIGIN: str({ devDefault: testOnly("http://localhost:3000") }),

     

       10
       10
       +
         CORS_ORIGIN: str({ devDefault: testOnly('http://localhost:3000') }),

     

       11
       11
        
         COMMON_RATE_LIMIT_MAX_REQUESTS: num({ devDefault: testOnly(1000) }),

     

       12
       12
        
         COMMON_RATE_LIMIT_WINDOW_MS: num({ devDefault: testOnly(1000) }),

     

       13
       13
       -
       });

     

       13
       13
       +
       })

+88 -94

src/firehose/firehose.ts

···

       1
       1
       -
       import type { RepoRecord } from "@atproto/lexicon";

     

       2
       2
       -
       import { cborToLexRecord, readCar } from "@atproto/repo";

     

       3
       3
       -
       import { AtUri } from "@atproto/syntax";

     

       4
       4
       -
       import { Subscription } from "@atproto/xrpc-server";

     

       5
       5
       -
       import type { CID } from "multiformats/cid";

     

       1
       1
       +
       import type { RepoRecord } from '@atproto/lexicon'

     

       2
       2
       +
       import { cborToLexRecord, readCar } from '@atproto/repo'

     

       3
       3
       +
       import { AtUri } from '@atproto/syntax'

     

       4
       4
       +
       import { Subscription } from '@atproto/xrpc-server'

     

       5
       5
       +
       import type { CID } from 'multiformats/cid'

     

       6
       6
        
       import {

     

       7
       7
        
         type Account,

     

       8
       8
        
         type Commit,

     
···

       12
       12
        
         isCommit,

     

       13
       13
        
         isIdentity,

     

       14
       14
        
         isValidRepoEvent,

     

       15
       15
       -
       } from "./lexicons";

     

       15
       15
       +
       } from './lexicons'

     

       16
       16
        
       

     

       17
       17
        
       type Opts = {

     

       18
       18
       -
         service?: string;

     

       19
       19
       -
         getCursor?: () => Promise<number | undefined>;

     

       20
       20
       -
         setCursor?: (cursor: number) => Promise<void>;

     

       21
       21
       -
         subscriptionReconnectDelay?: number;

     

       22
       22
       -
         filterCollections?: string[];

     

       23
       23
       -
         excludeIdentity?: boolean;

     

       24
       24
       -
         excludeAccount?: boolean;

     

       25
       25
       -
         excludeCommit?: boolean;

     

       26
       26
       -
       };

     

       18
       18
       +
         service?: string

     

       19
       19
       +
         getCursor?: () => Promise<number | undefined>

     

       20
       20
       +
         setCursor?: (cursor: number) => Promise<void>

     

       21
       21
       +
         subscriptionReconnectDelay?: number

     

       22
       22
       +
         filterCollections?: string[]

     

       23
       23
       +
         excludeIdentity?: boolean

     

       24
       24
       +
         excludeAccount?: boolean

     

       25
       25
       +
         excludeCommit?: boolean

     

       26
       26
       +
       }

     

       27
       27
        
       

     

       28
       28
        
       export class Firehose {

     

       29
       29
       -
         public sub: Subscription<RepoEvent>;

     

       30
       30
       -
         private abortController: AbortController;

     

       29
       29
       +
         public sub: Subscription<RepoEvent>

     

       30
       30
       +
         private abortController: AbortController

     

       31
       31
        
       

     

       32
       32
        
         constructor(public opts: Opts) {

     

       33
       33
       -
           this.abortController = new AbortController();

     

       33
       33
       +
           this.abortController = new AbortController()

     

       34
       34
        
           this.sub = new Subscription({

     

       35
       35
       -
             service: opts.service ?? "https://bsky.network",

     

       36
       36
       -
             method: "com.atproto.sync.subscribeRepos",

     

       35
       35
       +
             service: opts.service ?? 'https://bsky.network',

     

       36
       36
       +
             method: 'com.atproto.sync.subscribeRepos',

     

       37
       37
        
             signal: this.abortController.signal,

     

       38
       38
        
             getParams: async () => {

     

       39
       39
       -
               if (!opts.getCursor) return undefined;

     

       40
       40
       -
               const cursor = await opts.getCursor();

     

       41
       41
       -
               return { cursor };

     

       39
       39
       +
               if (!opts.getCursor) return undefined

     

       40
       40
       +
               const cursor = await opts.getCursor()

     

       41
       41
       +
               return { cursor }

     

       42
       42
        
             },

     

       43
       43
        
             validate: (value: unknown) => {

     

       44
       44
        
               try {

     

       45
       45
       -
                 return isValidRepoEvent(value);

     

       45
       45
       +
                 return isValidRepoEvent(value)

     

       46
       46
        
               } catch (err) {

     

       47
       47
       -
                 console.error("repo subscription skipped invalid message", err);

     

       47
       47
       +
                 console.error('repo subscription skipped invalid message', err)

     

       48
       48
        
               }

     

       49
       49
        
             },

     

       50
       50
       -
           });

     

       50
       50
       +
           })

     

       51
       51
        
         }

     

       52
       52
        
       

     

       53
       53
        
         async *run(): AsyncGenerator<Event> {

     
···

       55
       55
        
             for await (const evt of this.sub) {

     

       56
       56
        
               try {

     

       57
       57
        
                 if (isCommit(evt) && !this.opts.excludeCommit) {

     

       58
       58
       -
                   const parsed = await parseCommit(evt);

     

       58
       58
       +
                   const parsed = await parseCommit(evt)

     

       59
       59
        
                   for (const write of parsed) {

     

       60
       60
       -
                     if (

     

       61
       61
       -
                       !this.opts.filterCollections ||

     

       62
       62
       -
                       this.opts.filterCollections.includes(write.uri.collection)

     

       63
       63
       -
                     ) {

     

       64
       64
       -
                       yield write;

     

       60
       60
       +
                     if (!this.opts.filterCollections || this.opts.filterCollections.includes(write.uri.collection)) {

     

       61
       61
       +
                       yield write

     

       65
       62
        
                     }

     

       66
       63
        
                   }

     

       67
       64
        
                 } else if (isAccount(evt) && !this.opts.excludeAccount) {

     

       68
       68
       -
                   const parsed = parseAccount(evt);

     

       65
       65
       +
                   const parsed = parseAccount(evt)

     

       69
       66
        
                   if (parsed) {

     

       70
       70
       -
                     yield parsed;

     

       67
       67
       +
                     yield parsed

     

       71
       68
        
                   }

     

       72
       69
        
                 } else if (isIdentity(evt) && !this.opts.excludeIdentity) {

     

       73
       73
       -
                   yield parseIdentity(evt);

     

       70
       70
       +
                   yield parseIdentity(evt)

     

       74
       71
        
                 }

     

       75
       72
        
               } catch (err) {

     

       76
       76
       -
                 console.error("repo subscription could not handle message", err);

     

       73
       73
       +
                 console.error('repo subscription could not handle message', err)

     

       77
       74
        
               }

     

       78
       78
       -
               if (this.opts.setCursor && typeof evt.seq === "number") {

     

       79
       79
       -
                 await this.opts.setCursor(evt.seq);

     

       75
       75
       +
               if (this.opts.setCursor && typeof evt.seq === 'number') {

     

       76
       76
       +
                 await this.opts.setCursor(evt.seq)

     

       80
       77
        
               }

     

       81
       78
        
             }

     

       82
       79
        
           } catch (err) {

     

       83
       83
       -
             console.error("repo subscription errored", err);

     

       84
       84
       -
             setTimeout(

     

       85
       85
       -
               () => this.run(),

     

       86
       86
       -
               this.opts.subscriptionReconnectDelay ?? 3000

     

       87
       87
       -
             );

     

       80
       80
       +
             console.error('repo subscription errored', err)

     

       81
       81
       +
             setTimeout(() => this.run(), this.opts.subscriptionReconnectDelay ?? 3000)

     

       88
       82
        
           }

     

       89
       83
        
         }

     

       90
       84
        
       

     

       91
       85
        
         destroy() {

     

       92
       92
       -
           this.abortController.abort();

     

       86
       86
       +
           this.abortController.abort()

     

       93
       87
        
         }

     

       94
       88
        
       }

     

       95
       89
        
       

     

       96
       90
        
       export const parseCommit = async (evt: Commit): Promise<CommitEvt[]> => {

     

       97
       97
       -
         const car = await readCar(evt.blocks);

     

       91
       91
       +
         const car = await readCar(evt.blocks)

     

       98
       92
        
       

     

       99
       99
       -
         const evts: CommitEvt[] = [];

     

       93
       93
       +
         const evts: CommitEvt[] = []

     

       100
       94
        
       

     

       101
       95
        
         for (const op of evt.ops) {

     

       102
       102
       -
           const uri = new AtUri(`at://${evt.repo}/${op.path}`);

     

       96
       96
       +
           const uri = new AtUri(`at://${evt.repo}/${op.path}`)

     

       103
       97
        
       

     

       104
       98
        
           const meta: CommitMeta = {

     

       105
       99
        
             uri,

     

       106
       100
        
             author: uri.host,

     

       107
       101
        
             collection: uri.collection,

     

       108
       102
        
             rkey: uri.rkey,

     

       109
       109
       -
           };

     

       103
       103
       +
           }

     

       110
       104
        
       

     

       111
       111
       -
           if (op.action === "create" || op.action === "update") {

     

       112
       112
       -
             if (!op.cid) continue;

     

       113
       113
       -
             const recordBytes = car.blocks.get(op.cid);

     

       114
       114
       -
             if (!recordBytes) continue;

     

       115
       115
       -
             const record = cborToLexRecord(recordBytes);

     

       105
       105
       +
           if (op.action === 'create' || op.action === 'update') {

     

       106
       106
       +
             if (!op.cid) continue

     

       107
       107
       +
             const recordBytes = car.blocks.get(op.cid)

     

       108
       108
       +
             if (!recordBytes) continue

     

       109
       109
       +
             const record = cborToLexRecord(recordBytes)

     

       116
       110
        
             evts.push({

     

       117
       111
        
               ...meta,

     

       118
       118
       -
               event: op.action as "create" | "update",

     

       112
       112
       +
               event: op.action as 'create' | 'update',

     

       119
       113
        
               cid: op.cid,

     

       120
       114
        
               record,

     

       121
       121
       -
             });

     

       115
       115
       +
             })

     

       122
       116
        
           }

     

       123
       117
        
       

     

       124
       124
       -
           if (op.action === "delete") {

     

       118
       118
       +
           if (op.action === 'delete') {

     

       125
       119
        
             evts.push({

     

       126
       120
        
               ...meta,

     

       127
       127
       -
               event: "delete",

     

       128
       128
       -
             });

     

       121
       121
       +
               event: 'delete',

     

       122
       122
       +
             })

     

       129
       123
        
           }

     

       130
       124
        
         }

     

       131
       125
        
       

     

       132
       132
       -
         return evts;

     

       133
       133
       -
       };

     

       126
       126
       +
         return evts

     

       127
       127
       +
       }

     

       134
       128
        
       

     

       135
       129
        
       export const parseIdentity = (evt: Identity): IdentityEvt => {

     

       136
       130
        
         return {

     

       137
       137
       -
           event: "identity",

     

       131
       131
       +
           event: 'identity',

     

       138
       132
        
           did: evt.did,

     

       139
       133
        
           handle: evt.handle,

     

       140
       140
       -
         };

     

       141
       141
       -
       };

     

       134
       134
       +
         }

     

       135
       135
       +
       }

     

       142
       136
        
       

     

       143
       137
        
       export const parseAccount = (evt: Account): AccountEvt | undefined => {

     

       144
       144
       -
         if (evt.status && !isValidStatus(evt.status)) return;

     

       138
       138
       +
         if (evt.status && !isValidStatus(evt.status)) return

     

       145
       139
        
         return {

     

       146
       146
       -
           event: "account",

     

       140
       140
       +
           event: 'account',

     

       147
       141
        
           did: evt.did,

     

       148
       142
        
           active: evt.active,

     

       149
       143
        
           status: evt.status as AccountStatus,

     

       150
       150
       -
         };

     

       151
       151
       -
       };

     

       144
       144
       +
         }

     

       145
       145
       +
       }

     

       152
       146
        
       

     

       153
       147
        
       const isValidStatus = (str: string): str is AccountStatus => {

     

       154
       154
       -
         return ["takendown", "suspended", "deleted", "deactivated"].includes(str);

     

       155
       155
       -
       };

     

       148
       148
       +
         return ['takendown', 'suspended', 'deleted', 'deactivated'].includes(str)

     

       149
       149
       +
       }

     

       156
       150
        
       

     

       157
       157
       -
       type Event = CommitEvt | IdentityEvt | AccountEvt;

     

       151
       151
       +
       type Event = CommitEvt | IdentityEvt | AccountEvt

     

       158
       152
        
       

     

       159
       153
        
       type CommitMeta = {

     

       160
       160
       -
         uri: AtUri;

     

       161
       161
       -
         author: string;

     

       162
       162
       -
         collection: string;

     

       163
       163
       -
         rkey: string;

     

       164
       164
       -
       };

     

       154
       154
       +
         uri: AtUri

     

       155
       155
       +
         author: string

     

       156
       156
       +
         collection: string

     

       157
       157
       +
         rkey: string

     

       158
       158
       +
       }

     

       165
       159
        
       

     

       166
       166
       -
       type CommitEvt = Create | Update | Delete;

     

       160
       160
       +
       type CommitEvt = Create | Update | Delete

     

       167
       161
        
       

     

       168
       162
        
       type Create = CommitMeta & {

     

       169
       169
       -
         event: "create";

     

       170
       170
       -
         record: RepoRecord;

     

       171
       171
       -
         cid: CID;

     

       172
       172
       -
       };

     

       163
       163
       +
         event: 'create'

     

       164
       164
       +
         record: RepoRecord

     

       165
       165
       +
         cid: CID

     

       166
       166
       +
       }

     

       173
       167
        
       

     

       174
       168
        
       type Update = CommitMeta & {

     

       175
       175
       -
         event: "update";

     

       176
       176
       -
       };

     

       169
       169
       +
         event: 'update'

     

       170
       170
       +
       }

     

       177
       171
        
       

     

       178
       172
        
       type Delete = CommitMeta & {

     

       179
       179
       -
         event: "delete";

     

       180
       180
       -
       };

     

       173
       173
       +
         event: 'delete'

     

       174
       174
       +
       }

     

       181
       175
        
       

     

       182
       176
        
       type IdentityEvt = {

     

       183
       183
       -
         event: "identity";

     

       184
       184
       -
         did: string;

     

       185
       185
       -
         handle?: string;

     

       186
       186
       -
       };

     

       177
       177
       +
         event: 'identity'

     

       178
       178
       +
         did: string

     

       179
       179
       +
         handle?: string

     

       180
       180
       +
       }

     

       187
       181
        
       

     

       188
       182
        
       type AccountEvt = {

     

       189
       189
       -
         event: "account";

     

       190
       190
       -
         did: string;

     

       191
       191
       -
         active: boolean;

     

       192
       192
       -
         status?: AccountStatus;

     

       193
       193
       -
       };

     

       183
       183
       +
         event: 'account'

     

       184
       184
       +
         did: string

     

       185
       185
       +
         active: boolean

     

       186
       186
       +
         status?: AccountStatus

     

       187
       187
       +
       }

     

       194
       188
        
       

     

       195
       195
       -
       type AccountStatus = "takendown" | "suspended" | "deleted" | "deactivated";

     

       189
       189
       +
       type AccountStatus = 'takendown' | 'suspended' | 'deleted' | 'deactivated'

+10 -10

src/firehose/ingester.ts

···

       1
       1
       -
       import type { Database } from "#/db";

     

       2
       2
       -
       import { Firehose } from "#/firehose/firehose";

     

       1
       1
       +
       import type { Database } from '#/db'

     

       2
       2
       +
       import { Firehose } from '#/firehose/firehose'

     

       3
       3
        
       

     

       4
       4
        
       export class Ingester {

     

       5
       5
       -
         firehose: Firehose | undefined;

     

       5
       5
       +
         firehose: Firehose | undefined

     

       6
       6
        
         constructor(public db: Database) {}

     

       7
       7
        
       

     

       8
       8
        
         async start() {

     

       9
       9
       -
           const firehose = new Firehose({});

     

       9
       9
       +
           const firehose = new Firehose({})

     

       10
       10
        
       

     

       11
       11
        
           for await (const evt of firehose.run()) {

     

       12
       12
       -
             if (evt.event === "create") {

     

       13
       13
       -
               if (evt.collection !== "app.bsky.feed.post") continue;

     

       14
       14
       -
               const post: any = evt.record; // @TODO fix types

     

       12
       12
       +
             if (evt.event === 'create') {

     

       13
       13
       +
               if (evt.collection !== 'app.bsky.feed.post') continue

     

       14
       14
       +
               const post: any = evt.record // @TODO fix types

     

       15
       15
        
               await this.db

     

       16
       16
       -
                 .insertInto("post")

     

       16
       16
       +
                 .insertInto('post')

     

       17
       17
        
                 .values({

     

       18
       18
        
                   uri: evt.uri.toString(),

     

       19
       19
        
                   text: post.text as string,

     

       20
       20
        
                   indexedAt: new Date().toISOString(),

     

       21
       21
        
                 })

     

       22
       22
       -
                 .execute();

     

       22
       22
       +
                 .execute()

     

       23
       23
        
             }

     

       24
       24
        
           }

     

       25
       25
        
         }

     

       26
       26
        
       

     

       27
       27
        
         destroy() {

     

       28
       28
       -
           this.firehose?.destroy();

     

       28
       28
       +
           this.firehose?.destroy()

     

       29
       29
        
         }

     

       30
       30
        
       }

+148 -205

src/firehose/lexicons.ts

···

       1
       1
       -
       import type { IncomingMessage } from "node:http";

     

       1
       1
       +
       import type { IncomingMessage } from 'node:http'

     

       2
       2
        
       

     

       3
       3
       -
       import { type LexiconDoc, Lexicons } from "@atproto/lexicon";

     

       4
       4
       -
       import type { ErrorFrame, HandlerAuth } from "@atproto/xrpc-server";

     

       5
       5
       -
       import type { CID } from "multiformats/cid";

     

       3
       3
       +
       import { type LexiconDoc, Lexicons } from '@atproto/lexicon'

     

       4
       4
       +
       import type { ErrorFrame, HandlerAuth } from '@atproto/xrpc-server'

     

       5
       5
       +
       import type { CID } from 'multiformats/cid'

     

       6
       6
        
       

     

       7
       7
        
       // @NOTE: this file is an ugly copy job of codegen output. I'd like to clean this whole thing up

     

       8
       8
        
       

     

       9
       9
        
       export function isObj(v: unknown): v is Record<string, unknown> {

     

       10
       10
       -
         return typeof v === "object" && v !== null;

     

       10
       10
       +
         return typeof v === 'object' && v !== null

     

       11
       11
        
       }

     

       12
       12
        
       

     

       13
       13
       -
       export function hasProp<K extends PropertyKey>(

     

       14
       14
       -
         data: object,

     

       15
       15
       -
         prop: K

     

       16
       16
       -
       ): data is Record<K, unknown> {

     

       17
       17
       -
         return prop in data;

     

       13
       13
       +
       export function hasProp<K extends PropertyKey>(data: object, prop: K): data is Record<K, unknown> {

     

       14
       14
       +
         return prop in data

     

       18
       15
        
       }

     

       19
       16
        
       

     

       20
       17
        
       export interface QueryParams {

     

       21
       18
        
         /** The last known event seq number to backfill from. */

     

       22
       22
       -
         cursor?: number;

     

       19
       19
       +
         cursor?: number

     

       23
       20
        
       }

     

       24
       21
        
       

     

       25
       22
        
       export type RepoEvent =

     
···

       30
       27
        
         | Migrate

     

       31
       28
        
         | Tombstone

     

       32
       29
        
         | Info

     

       33
       33
       -
         | { $type: string; [k: string]: unknown };

     

       34
       34
       -
       export type HandlerError = ErrorFrame<"FutureCursor" | "ConsumerTooSlow">;

     

       35
       35
       -
       export type HandlerOutput = HandlerError | RepoEvent;

     

       30
       30
       +
         | { $type: string; [k: string]: unknown }

     

       31
       31
       +
       export type HandlerError = ErrorFrame<'FutureCursor' | 'ConsumerTooSlow'>

     

       32
       32
       +
       export type HandlerOutput = HandlerError | RepoEvent

     

       36
       33
        
       export type HandlerReqCtx<HA extends HandlerAuth = never> = {

     

       37
       37
       -
         auth: HA;

     

       38
       38
       -
         params: QueryParams;

     

       39
       39
       -
         req: IncomingMessage;

     

       40
       40
       -
         signal: AbortSignal;

     

       41
       41
       -
       };

     

       42
       42
       -
       export type Handler<HA extends HandlerAuth = never> = (

     

       43
       43
       -
         ctx: HandlerReqCtx<HA>

     

       44
       44
       -
       ) => AsyncIterable<HandlerOutput>;

     

       34
       34
       +
         auth: HA

     

       35
       35
       +
         params: QueryParams

     

       36
       36
       +
         req: IncomingMessage

     

       37
       37
       +
         signal: AbortSignal

     

       38
       38
       +
       }

     

       39
       39
       +
       export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => AsyncIterable<HandlerOutput>

     

       45
       40
        
       

     

       46
       41
        
       /** Represents an update of repository state. Note that empty commits are allowed, which include no repo data changes, but an update to rev and signature. */

     

       47
       42
        
       export interface Commit {

     

       48
       43
        
         /** The stream sequence number of this message. */

     

       49
       49
       -
         seq: number;

     

       44
       44
       +
         seq: number

     

       50
       45
        
         /** DEPRECATED -- unused */

     

       51
       51
       -
         rebase: boolean;

     

       46
       46
       +
         rebase: boolean

     

       52
       47
        
         /** Indicates that this commit contained too many ops, or data size was too large. Consumers will need to make a separate request to get missing data. */

     

       53
       53
       -
         tooBig: boolean;

     

       48
       48
       +
         tooBig: boolean

     

       54
       49
        
         /** The repo this event comes from. */

     

       55
       55
       -
         repo: string;

     

       50
       50
       +
         repo: string

     

       56
       51
        
         /** Repo commit object CID. */

     

       57
       57
       -
         commit: CID;

     

       52
       52
       +
         commit: CID

     

       58
       53
        
         /** DEPRECATED -- unused. WARNING -- nullable and optional; stick with optional to ensure golang interoperability. */

     

       59
       59
       -
         prev?: CID | null;

     

       54
       54
       +
         prev?: CID | null

     

       60
       55
        
         /** The rev of the emitted commit. Note that this information is also in the commit object included in blocks, unless this is a tooBig event. */

     

       61
       61
       -
         rev: string;

     

       56
       56
       +
         rev: string

     

       62
       57
        
         /** The rev of the last emitted commit from this repo (if any). */

     

       63
       63
       -
         since: string | null;

     

       58
       58
       +
         since: string | null

     

       64
       59
        
         /** CAR file containing relevant blocks, as a diff since the previous repo state. */

     

       65
       65
       -
         blocks: Uint8Array;

     

       66
       66
       -
         ops: RepoOp[];

     

       67
       67
       -
         blobs: CID[];

     

       60
       60
       +
         blocks: Uint8Array

     

       61
       61
       +
         ops: RepoOp[]

     

       62
       62
       +
         blobs: CID[]

     

       68
       63
        
         /** Timestamp of when this message was originally broadcast. */

     

       69
       69
       -
         time: string;

     

       70
       70
       -
         [k: string]: unknown;

     

       64
       64
       +
         time: string

     

       65
       65
       +
         [k: string]: unknown

     

       71
       66
        
       }

     

       72
       67
        
       

     

       73
       68
        
       export function isCommit(v: unknown): v is Commit {

     

       74
       74
       -
         return (

     

       75
       75
       -
           isObj(v) &&

     

       76
       76
       -
           hasProp(v, "$type") &&

     

       77
       77
       -
           v.$type === "com.atproto.sync.subscribeRepos#commit"

     

       78
       78
       -
         );

     

       69
       69
       +
         return isObj(v) && hasProp(v, '$type') && v.$type === 'com.atproto.sync.subscribeRepos#commit'

     

       79
       70
        
       }

     

       80
       71
        
       

     

       81
       72
        
       /** Represents a change to an account's identity. Could be an updated handle, signing key, or pds hosting endpoint. Serves as a prod to all downstream services to refresh their identity cache. */

     

       82
       73
        
       export interface Identity {

     

       83
       83
       -
         seq: number;

     

       84
       84
       -
         did: string;

     

       85
       85
       -
         time: string;

     

       74
       74
       +
         seq: number

     

       75
       75
       +
         did: string

     

       76
       76
       +
         time: string

     

       86
       77
        
         /** The current handle for the account, or 'handle.invalid' if validation fails. This field is optional, might have been validated or passed-through from an upstream source. Semantics and behaviors for PDS vs Relay may evolve in the future; see atproto specs for more details. */

     

       87
       87
       -
         handle?: string;

     

       88
       88
       -
         [k: string]: unknown;

     

       78
       78
       +
         handle?: string

     

       79
       79
       +
         [k: string]: unknown

     

       89
       80
        
       }

     

       90
       81
        
       

     

       91
       82
        
       export function isIdentity(v: unknown): v is Identity {

     

       92
       92
       -
         return (

     

       93
       93
       -
           isObj(v) &&

     

       94
       94
       -
           hasProp(v, "$type") &&

     

       95
       95
       -
           v.$type === "com.atproto.sync.subscribeRepos#identity"

     

       96
       96
       -
         );

     

       83
       83
       +
         return isObj(v) && hasProp(v, '$type') && v.$type === 'com.atproto.sync.subscribeRepos#identity'

     

       97
       84
        
       }

     

       98
       85
        
       

     

       99
       86
        
       /** Represents a change to an account's status on a host (eg, PDS or Relay). The semantics of this event are that the status is at the host which emitted the event, not necessarily that at the currently active PDS. Eg, a Relay takedown would emit a takedown with active=false, even if the PDS is still active. */

     

       100
       87
        
       export interface Account {

     

       101
       101
       -
         seq: number;

     

       102
       102
       -
         did: string;

     

       103
       103
       -
         time: string;

     

       88
       88
       +
         seq: number

     

       89
       89
       +
         did: string

     

       90
       90
       +
         time: string

     

       104
       91
        
         /** Indicates that the account has a repository which can be fetched from the host that emitted this event. */

     

       105
       105
       -
         active: boolean;

     

       92
       92
       +
         active: boolean

     

       106
       93
        
         /** If active=false, this optional field indicates a reason for why the account is not active. */

     

       107
       107
       -
         status?:

     

       108
       108
       -
           | "takendown"

     

       109
       109
       -
           | "suspended"

     

       110
       110
       -
           | "deleted"

     

       111
       111
       -
           | "deactivated"

     

       112
       112
       -
           | (string & {});

     

       113
       113
       -
         [k: string]: unknown;

     

       94
       94
       +
         status?: 'takendown' | 'suspended' | 'deleted' | 'deactivated' | (string & {})

     

       95
       95
       +
         [k: string]: unknown

     

       114
       96
        
       }

     

       115
       97
        
       

     

       116
       98
        
       export function isAccount(v: unknown): v is Account {

     

       117
       117
       -
         return (

     

       118
       118
       -
           isObj(v) &&

     

       119
       119
       -
           hasProp(v, "$type") &&

     

       120
       120
       -
           v.$type === "com.atproto.sync.subscribeRepos#account"

     

       121
       121
       -
         );

     

       99
       99
       +
         return isObj(v) && hasProp(v, '$type') && v.$type === 'com.atproto.sync.subscribeRepos#account'

     

       122
       100
        
       }

     

       123
       101
        
       

     

       124
       102
        
       /** DEPRECATED -- Use #identity event instead */

     

       125
       103
        
       export interface Handle {

     

       126
       126
       -
         seq: number;

     

       127
       127
       -
         did: string;

     

       128
       128
       -
         handle: string;

     

       129
       129
       -
         time: string;

     

       130
       130
       -
         [k: string]: unknown;

     

       104
       104
       +
         seq: number

     

       105
       105
       +
         did: string

     

       106
       106
       +
         handle: string

     

       107
       107
       +
         time: string

     

       108
       108
       +
         [k: string]: unknown

     

       131
       109
        
       }

     

       132
       110
        
       

     

       133
       111
        
       export function isHandle(v: unknown): v is Handle {

     

       134
       134
       -
         return (

     

       135
       135
       -
           isObj(v) &&

     

       136
       136
       -
           hasProp(v, "$type") &&

     

       137
       137
       -
           v.$type === "com.atproto.sync.subscribeRepos#handle"

     

       138
       138
       -
         );

     

       112
       112
       +
         return isObj(v) && hasProp(v, '$type') && v.$type === 'com.atproto.sync.subscribeRepos#handle'

     

       139
       113
        
       }

     

       140
       114
        
       

     

       141
       115
        
       /** DEPRECATED -- Use #account event instead */

     

       142
       116
        
       export interface Migrate {

     

       143
       143
       -
         seq: number;

     

       144
       144
       -
         did: string;

     

       145
       145
       -
         migrateTo: string | null;

     

       146
       146
       -
         time: string;

     

       147
       147
       -
         [k: string]: unknown;

     

       117
       117
       +
         seq: number

     

       118
       118
       +
         did: string

     

       119
       119
       +
         migrateTo: string | null

     

       120
       120
       +
         time: string

     

       121
       121
       +
         [k: string]: unknown

     

       148
       122
        
       }

     

       149
       123
        
       

     

       150
       124
        
       export function isMigrate(v: unknown): v is Migrate {

     

       151
       151
       -
         return (

     

       152
       152
       -
           isObj(v) &&

     

       153
       153
       -
           hasProp(v, "$type") &&

     

       154
       154
       -
           v.$type === "com.atproto.sync.subscribeRepos#migrate"

     

       155
       155
       -
         );

     

       125
       125
       +
         return isObj(v) && hasProp(v, '$type') && v.$type === 'com.atproto.sync.subscribeRepos#migrate'

     

       156
       126
        
       }

     

       157
       127
        
       

     

       158
       128
        
       /** DEPRECATED -- Use #account event instead */

     

       159
       129
        
       export interface Tombstone {

     

       160
       160
       -
         seq: number;

     

       161
       161
       -
         did: string;

     

       162
       162
       -
         time: string;

     

       163
       163
       -
         [k: string]: unknown;

     

       130
       130
       +
         seq: number

     

       131
       131
       +
         did: string

     

       132
       132
       +
         time: string

     

       133
       133
       +
         [k: string]: unknown

     

       164
       134
        
       }

     

       165
       135
        
       

     

       166
       136
        
       export function isTombstone(v: unknown): v is Tombstone {

     

       167
       167
       -
         return (

     

       168
       168
       -
           isObj(v) &&

     

       169
       169
       -
           hasProp(v, "$type") &&

     

       170
       170
       -
           v.$type === "com.atproto.sync.subscribeRepos#tombstone"

     

       171
       171
       -
         );

     

       137
       137
       +
         return isObj(v) && hasProp(v, '$type') && v.$type === 'com.atproto.sync.subscribeRepos#tombstone'

     

       172
       138
        
       }

     

       173
       139
        
       

     

       174
       140
        
       export interface Info {

     

       175
       175
       -
         name: "OutdatedCursor" | (string & {});

     

       176
       176
       -
         message?: string;

     

       177
       177
       -
         [k: string]: unknown;

     

       141
       141
       +
         name: 'OutdatedCursor' | (string & {})

     

       142
       142
       +
         message?: string

     

       143
       143
       +
         [k: string]: unknown

     

       178
       144
        
       }

     

       179
       145
        
       

     

       180
       146
        
       export function isInfo(v: unknown): v is Info {

     

       181
       181
       -
         return (

     

       182
       182
       -
           isObj(v) &&

     

       183
       183
       -
           hasProp(v, "$type") &&

     

       184
       184
       -
           v.$type === "com.atproto.sync.subscribeRepos#info"

     

       185
       185
       -
         );

     

       147
       147
       +
         return isObj(v) && hasProp(v, '$type') && v.$type === 'com.atproto.sync.subscribeRepos#info'

     

       186
       148
        
       }

     

       187
       149
        
       

     

       188
       150
        
       /** A repo operation, ie a mutation of a single record. */

     

       189
       151
        
       export interface RepoOp {

     

       190
       190
       -
         action: "create" | "update" | "delete" | (string & {});

     

       191
       191
       -
         path: string;

     

       152
       152
       +
         action: 'create' | 'update' | 'delete' | (string & {})

     

       153
       153
       +
         path: string

     

       192
       154
        
         /** For creates and updates, the new record CID. For deletions, null. */

     

       193
       193
       -
         cid: CID | null;

     

       194
       194
       -
         [k: string]: unknown;

     

       155
       155
       +
         cid: CID | null

     

       156
       156
       +
         [k: string]: unknown

     

       195
       157
        
       }

     

       196
       158
        
       

     

       197
       159
        
       export function isRepoOp(v: unknown): v is RepoOp {

     

       198
       198
       -
         return (

     

       199
       199
       -
           isObj(v) &&

     

       200
       200
       -
           hasProp(v, "$type") &&

     

       201
       201
       -
           v.$type === "com.atproto.sync.subscribeRepos#repoOp"

     

       202
       202
       -
         );

     

       160
       160
       +
         return isObj(v) && hasProp(v, '$type') && v.$type === 'com.atproto.sync.subscribeRepos#repoOp'

     

       203
       161
        
       }

     

       204
       162
        
       

     

       205
       163
        
       export const ComAtprotoSyncSubscribeRepos: LexiconDoc = {

     

       206
       164
        
         lexicon: 1,

     

       207
       207
       -
         id: "com.atproto.sync.subscribeRepos",

     

       165
       165
       +
         id: 'com.atproto.sync.subscribeRepos',

     

       208
       166
        
         defs: {

     

       209
       167
        
           main: {

     

       210
       210
       -
             type: "subscription",

     

       211
       211
       -
             description: "Subscribe to repo updates",

     

       168
       168
       +
             type: 'subscription',

     

       169
       169
       +
             description: 'Subscribe to repo updates',

     

       212
       170
        
             parameters: {

     

       213
       213
       -
               type: "params",

     

       171
       171
       +
               type: 'params',

     

       214
       172
        
               properties: {

     

       215
       173
        
                 cursor: {

     

       216
       216
       -
                   type: "integer",

     

       217
       217
       -
                   description: "The last known event to backfill from.",

     

       174
       174
       +
                   type: 'integer',

     

       175
       175
       +
                   description: 'The last known event to backfill from.',

     

       218
       176
        
                 },

     

       219
       177
        
               },

     

       220
       178
        
             },

     

       221
       179
        
             message: {

     

       222
       180
        
               schema: {

     

       223
       223
       -
                 type: "union",

     

       181
       181
       +
                 type: 'union',

     

       224
       182
        
                 refs: [

     

       225
       225
       -
                   "lex:com.atproto.sync.subscribeRepos#commit",

     

       226
       226
       -
                   "lex:com.atproto.sync.subscribeRepos#handle",

     

       227
       227
       -
                   "lex:com.atproto.sync.subscribeRepos#migrate",

     

       228
       228
       -
                   "lex:com.atproto.sync.subscribeRepos#tombstone",

     

       229
       229
       -
                   "lex:com.atproto.sync.subscribeRepos#info",

     

       183
       183
       +
                   'lex:com.atproto.sync.subscribeRepos#commit',

     

       184
       184
       +
                   'lex:com.atproto.sync.subscribeRepos#handle',

     

       185
       185
       +
                   'lex:com.atproto.sync.subscribeRepos#migrate',

     

       186
       186
       +
                   'lex:com.atproto.sync.subscribeRepos#tombstone',

     

       187
       187
       +
                   'lex:com.atproto.sync.subscribeRepos#info',

     

       230
       188
        
                 ],

     

       231
       189
        
               },

     

       232
       190
        
             },

     

       233
       191
        
             errors: [

     

       234
       192
        
               {

     

       235
       235
       -
                 name: "FutureCursor",

     

       193
       193
       +
                 name: 'FutureCursor',

     

       236
       194
        
               },

     

       237
       195
        
               {

     

       238
       238
       -
                 name: "ConsumerTooSlow",

     

       196
       196
       +
                 name: 'ConsumerTooSlow',

     

       239
       197
        
               },

     

       240
       198
        
             ],

     

       241
       199
        
           },

     

       242
       200
        
           commit: {

     

       243
       243
       -
             type: "object",

     

       244
       244
       -
             required: [

     

       245
       245
       -
               "seq",

     

       246
       246
       -
               "rebase",

     

       247
       247
       -
               "tooBig",

     

       248
       248
       -
               "repo",

     

       249
       249
       -
               "commit",

     

       250
       250
       -
               "rev",

     

       251
       251
       -
               "since",

     

       252
       252
       -
               "blocks",

     

       253
       253
       -
               "ops",

     

       254
       254
       -
               "blobs",

     

       255
       255
       -
               "time",

     

       256
       256
       -
             ],

     

       257
       257
       -
             nullable: ["prev", "since"],

     

       201
       201
       +
             type: 'object',

     

       202
       202
       +
             required: ['seq', 'rebase', 'tooBig', 'repo', 'commit', 'rev', 'since', 'blocks', 'ops', 'blobs', 'time'],

     

       203
       203
       +
             nullable: ['prev', 'since'],

     

       258
       204
        
             properties: {

     

       259
       205
        
               seq: {

     

       260
       260
       -
                 type: "integer",

     

       206
       206
       +
                 type: 'integer',

     

       261
       207
        
               },

     

       262
       208
        
               rebase: {

     

       263
       263
       -
                 type: "boolean",

     

       209
       209
       +
                 type: 'boolean',

     

       264
       210
        
               },

     

       265
       211
        
               tooBig: {

     

       266
       266
       -
                 type: "boolean",

     

       212
       212
       +
                 type: 'boolean',

     

       267
       213
        
               },

     

       268
       214
        
               repo: {

     

       269
       269
       -
                 type: "string",

     

       270
       270
       -
                 format: "did",

     

       215
       215
       +
                 type: 'string',

     

       216
       216
       +
                 format: 'did',

     

       271
       217
        
               },

     

       272
       218
        
               commit: {

     

       273
       273
       -
                 type: "cid-link",

     

       219
       219
       +
                 type: 'cid-link',

     

       274
       220
        
               },

     

       275
       221
        
               prev: {

     

       276
       276
       -
                 type: "cid-link",

     

       222
       222
       +
                 type: 'cid-link',

     

       277
       223
        
               },

     

       278
       224
        
               rev: {

     

       279
       279
       -
                 type: "string",

     

       280
       280
       -
                 description: "The rev of the emitted commit",

     

       225
       225
       +
                 type: 'string',

     

       226
       226
       +
                 description: 'The rev of the emitted commit',

     

       281
       227
        
               },

     

       282
       228
        
               since: {

     

       283
       283
       -
                 type: "string",

     

       284
       284
       -
                 description: "The rev of the last emitted commit from this repo",

     

       229
       229
       +
                 type: 'string',

     

       230
       230
       +
                 description: 'The rev of the last emitted commit from this repo',

     

       285
       231
        
               },

     

       286
       232
        
               blocks: {

     

       287
       287
       -
                 type: "bytes",

     

       288
       288
       -
                 description: "CAR file containing relevant blocks",

     

       233
       233
       +
                 type: 'bytes',

     

       234
       234
       +
                 description: 'CAR file containing relevant blocks',

     

       289
       235
        
                 maxLength: 1000000,

     

       290
       236
        
               },

     

       291
       237
        
               ops: {

     

       292
       292
       -
                 type: "array",

     

       238
       238
       +
                 type: 'array',

     

       293
       239
        
                 items: {

     

       294
       294
       -
                   type: "ref",

     

       295
       295
       -
                   ref: "lex:com.atproto.sync.subscribeRepos#repoOp",

     

       240
       240
       +
                   type: 'ref',

     

       241
       241
       +
                   ref: 'lex:com.atproto.sync.subscribeRepos#repoOp',

     

       296
       242
        
                 },

     

       297
       243
        
                 maxLength: 200,

     

       298
       244
        
               },

     

       299
       245
        
               blobs: {

     

       300
       300
       -
                 type: "array",

     

       246
       246
       +
                 type: 'array',

     

       301
       247
        
                 items: {

     

       302
       302
       -
                   type: "cid-link",

     

       248
       248
       +
                   type: 'cid-link',

     

       303
       249
        
                 },

     

       304
       250
        
               },

     

       305
       251
        
               time: {

     

       306
       306
       -
                 type: "string",

     

       307
       307
       -
                 format: "datetime",

     

       252
       252
       +
                 type: 'string',

     

       253
       253
       +
                 format: 'datetime',

     

       308
       254
        
               },

     

       309
       255
        
             },

     

       310
       256
        
           },

     

       311
       257
        
           handle: {

     

       312
       312
       -
             type: "object",

     

       313
       313
       -
             required: ["seq", "did", "handle", "time"],

     

       258
       258
       +
             type: 'object',

     

       259
       259
       +
             required: ['seq', 'did', 'handle', 'time'],

     

       314
       260
        
             properties: {

     

       315
       261
        
               seq: {

     

       316
       316
       -
                 type: "integer",

     

       262
       262
       +
                 type: 'integer',

     

       317
       263
        
               },

     

       318
       264
        
               did: {

     

       319
       319
       -
                 type: "string",

     

       320
       320
       -
                 format: "did",

     

       265
       265
       +
                 type: 'string',

     

       266
       266
       +
                 format: 'did',

     

       321
       267
        
               },

     

       322
       268
        
               handle: {

     

       323
       323
       -
                 type: "string",

     

       324
       324
       -
                 format: "handle",

     

       269
       269
       +
                 type: 'string',

     

       270
       270
       +
                 format: 'handle',

     

       325
       271
        
               },

     

       326
       272
        
               time: {

     

       327
       327
       -
                 type: "string",

     

       328
       328
       -
                 format: "datetime",

     

       273
       273
       +
                 type: 'string',

     

       274
       274
       +
                 format: 'datetime',

     

       329
       275
        
               },

     

       330
       276
        
             },

     

       331
       277
        
           },

     

       332
       278
        
           migrate: {

     

       333
       333
       -
             type: "object",

     

       334
       334
       -
             required: ["seq", "did", "migrateTo", "time"],

     

       335
       335
       -
             nullable: ["migrateTo"],

     

       279
       279
       +
             type: 'object',

     

       280
       280
       +
             required: ['seq', 'did', 'migrateTo', 'time'],

     

       281
       281
       +
             nullable: ['migrateTo'],

     

       336
       282
        
             properties: {

     

       337
       283
        
               seq: {

     

       338
       338
       -
                 type: "integer",

     

       284
       284
       +
                 type: 'integer',

     

       339
       285
        
               },

     

       340
       286
        
               did: {

     

       341
       341
       -
                 type: "string",

     

       342
       342
       -
                 format: "did",

     

       287
       287
       +
                 type: 'string',

     

       288
       288
       +
                 format: 'did',

     

       343
       289
        
               },

     

       344
       290
        
               migrateTo: {

     

       345
       345
       -
                 type: "string",

     

       291
       291
       +
                 type: 'string',

     

       346
       292
        
               },

     

       347
       293
        
               time: {

     

       348
       348
       -
                 type: "string",

     

       349
       349
       -
                 format: "datetime",

     

       294
       294
       +
                 type: 'string',

     

       295
       295
       +
                 format: 'datetime',

     

       350
       296
        
               },

     

       351
       297
        
             },

     

       352
       298
        
           },

     

       353
       299
        
           tombstone: {

     

       354
       354
       -
             type: "object",

     

       355
       355
       -
             required: ["seq", "did", "time"],

     

       300
       300
       +
             type: 'object',

     

       301
       301
       +
             required: ['seq', 'did', 'time'],

     

       356
       302
        
             properties: {

     

       357
       303
        
               seq: {

     

       358
       358
       -
                 type: "integer",

     

       304
       304
       +
                 type: 'integer',

     

       359
       305
        
               },

     

       360
       306
        
               did: {

     

       361
       361
       -
                 type: "string",

     

       362
       362
       -
                 format: "did",

     

       307
       307
       +
                 type: 'string',

     

       308
       308
       +
                 format: 'did',

     

       363
       309
        
               },

     

       364
       310
        
               time: {

     

       365
       365
       -
                 type: "string",

     

       366
       366
       -
                 format: "datetime",

     

       311
       311
       +
                 type: 'string',

     

       312
       312
       +
                 format: 'datetime',

     

       367
       313
        
               },

     

       368
       314
        
             },

     

       369
       315
        
           },

     

       370
       316
        
           info: {

     

       371
       371
       -
             type: "object",

     

       372
       372
       -
             required: ["name"],

     

       317
       317
       +
             type: 'object',

     

       318
       318
       +
             required: ['name'],

     

       373
       319
        
             properties: {

     

       374
       320
        
               name: {

     

       375
       375
       -
                 type: "string",

     

       376
       376
       -
                 knownValues: ["OutdatedCursor"],

     

       321
       321
       +
                 type: 'string',

     

       322
       322
       +
                 knownValues: ['OutdatedCursor'],

     

       377
       323
        
               },

     

       378
       324
        
               message: {

     

       379
       379
       -
                 type: "string",

     

       325
       325
       +
                 type: 'string',

     

       380
       326
        
               },

     

       381
       327
        
             },

     

       382
       328
        
           },

     

       383
       329
        
           repoOp: {

     

       384
       384
       -
             type: "object",

     

       330
       330
       +
             type: 'object',

     

       385
       331
        
             description:

     

       386
       332
        
               "A repo operation, ie a write of a single record. For creates and updates, cid is the record's CID as of this operation. For deletes, it's null.",

     

       387
       387
       -
             required: ["action", "path", "cid"],

     

       388
       388
       -
             nullable: ["cid"],

     

       333
       333
       +
             required: ['action', 'path', 'cid'],

     

       334
       334
       +
             nullable: ['cid'],

     

       389
       335
        
             properties: {

     

       390
       336
        
               action: {

     

       391
       391
       -
                 type: "string",

     

       392
       392
       -
                 knownValues: ["create", "update", "delete"],

     

       337
       337
       +
                 type: 'string',

     

       338
       338
       +
                 knownValues: ['create', 'update', 'delete'],

     

       393
       339
        
               },

     

       394
       340
        
               path: {

     

       395
       395
       -
                 type: "string",

     

       341
       341
       +
                 type: 'string',

     

       396
       342
        
               },

     

       397
       343
        
               cid: {

     

       398
       398
       -
                 type: "cid-link",

     

       344
       344
       +
                 type: 'cid-link',

     

       399
       345
        
               },

     

       400
       346
        
             },

     

       401
       347
        
           },

     

       402
       348
        
         },

     

       403
       403
       -
       };

     

       349
       349
       +
       }

     

       404
       350
        
       

     

       405
       405
       -
       const lexicons = new Lexicons([ComAtprotoSyncSubscribeRepos]);

     

       351
       351
       +
       const lexicons = new Lexicons([ComAtprotoSyncSubscribeRepos])

     

       406
       352
        
       

     

       407
       353
        
       export const isValidRepoEvent = (evt: unknown) => {

     

       408
       408
       -
         return lexicons.assertValidXrpcMessage<RepoEvent>(

     

       409
       409
       -
           "com.atproto.sync.subscribeRepos",

     

       410
       410
       -
           evt

     

       411
       411
       -
         );

     

       412
       412
       -
       };

     

       354
       354
       +
         return lexicons.assertValidXrpcMessage<RepoEvent>('com.atproto.sync.subscribeRepos', evt)

     

       355
       355
       +
       }

+10 -10

src/index.ts

···

       1
       1
       -
       import { Server } from "#/server";

     

       1
       1
       +
       import { Server } from '#/server'

     

       2
       2
        
       

     

       3
       3
        
       const run = async () => {

     

       4
       4
       -
         const server = await Server.create();

     

       4
       4
       +
         const server = await Server.create()

     

       5
       5
        
       

     

       6
       6
        
         const onCloseSignal = async () => {

     

       7
       7
       -
           setTimeout(() => process.exit(1), 10000).unref(); // Force shutdown after 10s

     

       8
       8
       -
           await server.close();

     

       9
       9
       -
           process.exit();

     

       10
       10
       -
         };

     

       7
       7
       +
           setTimeout(() => process.exit(1), 10000).unref() // Force shutdown after 10s

     

       8
       8
       +
           await server.close()

     

       9
       9
       +
           process.exit()

     

       10
       10
       +
         }

     

       11
       11
        
       

     

       12
       12
       -
         process.on("SIGINT", onCloseSignal);

     

       13
       13
       -
         process.on("SIGTERM", onCloseSignal);

     

       14
       14
       -
       };

     

       12
       12
       +
         process.on('SIGINT', onCloseSignal)

     

       13
       13
       +
         process.on('SIGTERM', onCloseSignal)

     

       14
       14
       +
       }

     

       15
       15
        
       

     

       16
       16
       -
       run();

     

       16
       16
       +
       run()

+8 -8

src/middleware/errorHandler.ts

···

       1
       1
       -
       import type { ErrorRequestHandler, RequestHandler } from "express";

     

       2
       2
       -
       import { StatusCodes } from "http-status-codes";

     

       1
       1
       +
       import type { ErrorRequestHandler, RequestHandler } from 'express'

     

       2
       2
       +
       import { StatusCodes } from 'http-status-codes'

     

       3
       3
        
       

     

       4
       4
        
       const unexpectedRequest: RequestHandler = (_req, res) => {

     

       5
       5
       -
         res.sendStatus(StatusCodes.NOT_FOUND);

     

       6
       6
       -
       };

     

       5
       5
       +
         res.sendStatus(StatusCodes.NOT_FOUND)

     

       6
       6
       +
       }

     

       7
       7
        
       

     

       8
       8
        
       const addErrorToRequestLog: ErrorRequestHandler = (err, _req, res, next) => {

     

       9
       9
       -
         res.locals.err = err;

     

       10
       10
       -
         next(err);

     

       11
       11
       -
       };

     

       9
       9
       +
         res.locals.err = err

     

       10
       10
       +
         next(err)

     

       11
       11
       +
       }

     

       12
       12
        
       

     

       13
       13
       -
       export default () => [unexpectedRequest, addErrorToRequestLog];

     

       13
       13
       +
       export default () => [unexpectedRequest, addErrorToRequestLog]

+52 -52

src/middleware/requestLogger.ts

···

       1
       1
       -
       import { randomUUID } from "node:crypto";

     

       2
       2
       -
       import type { IncomingMessage, ServerResponse } from "node:http";

     

       3
       3
       -
       import type { Request, RequestHandler, Response } from "express";

     

       4
       4
       -
       import { StatusCodes, getReasonPhrase } from "http-status-codes";

     

       5
       5
       -
       import type { LevelWithSilent } from "pino";

     

       6
       6
       -
       import { type CustomAttributeKeys, type Options, pinoHttp } from "pino-http";

     

       1
       1
       +
       import { randomUUID } from 'node:crypto'

     

       2
       2
       +
       import type { IncomingMessage, ServerResponse } from 'node:http'

     

       3
       3
       +
       import type { Request, RequestHandler, Response } from 'express'

     

       4
       4
       +
       import { StatusCodes, getReasonPhrase } from 'http-status-codes'

     

       5
       5
       +
       import type { LevelWithSilent } from 'pino'

     

       6
       6
       +
       import { type CustomAttributeKeys, type Options, pinoHttp } from 'pino-http'

     

       7
       7
        
       

     

       8
       8
       -
       import { env } from "#/common/utils/envConfig";

     

       8
       8
       +
       import { env } from '#/env'

     

       9
       9
        
       

     

       10
       10
        
       enum LogLevel {

     

       11
       11
       -
         Fatal = "fatal",

     

       12
       12
       -
         Error = "error",

     

       13
       13
       -
         Warn = "warn",

     

       14
       14
       -
         Info = "info",

     

       15
       15
       -
         Debug = "debug",

     

       16
       16
       -
         Trace = "trace",

     

       17
       17
       -
         Silent = "silent",

     

       11
       11
       +
         Fatal = 'fatal',

     

       12
       12
       +
         Error = 'error',

     

       13
       13
       +
         Warn = 'warn',

     

       14
       14
       +
         Info = 'info',

     

       15
       15
       +
         Debug = 'debug',

     

       16
       16
       +
         Trace = 'trace',

     

       17
       17
       +
         Silent = 'silent',

     

       18
       18
        
       }

     

       19
       19
        
       

     

       20
       20
        
       type PinoCustomProps = {

     

       21
       21
       -
         request: Request;

     

       22
       22
       -
         response: Response;

     

       23
       23
       -
         error: Error;

     

       24
       24
       -
         responseBody: unknown;

     

       25
       25
       -
       };

     

       21
       21
       +
         request: Request

     

       22
       22
       +
         response: Response

     

       23
       23
       +
         error: Error

     

       24
       24
       +
         responseBody: unknown

     

       25
       25
       +
       }

     

       26
       26
        
       

     

       27
       27
        
       const requestLogger = (options?: Options): RequestHandler[] => {

     

       28
       28
        
         const pinoOptions: Options = {

     

       29
       29
        
           enabled: env.isProduction,

     

       30
       30
       -
           customProps: customProps as unknown as Options["customProps"],

     

       30
       30
       +
           customProps: customProps as unknown as Options['customProps'],

     

       31
       31
        
           redact: [],

     

       32
       32
        
           genReqId,

     

       33
       33
        
           customLogLevel,

     
···

       36
       36
        
           customErrorMessage: (_req, res) => `request errored with status code: ${res.statusCode}`,

     

       37
       37
        
           customAttributeKeys,

     

       38
       38
        
           ...options,

     

       39
       39
       -
         };

     

       40
       40
       -
         return [responseBodyMiddleware, pinoHttp(pinoOptions)];

     

       41
       41
       -
       };

     

       39
       39
       +
         }

     

       40
       40
       +
         return [responseBodyMiddleware, pinoHttp(pinoOptions)]

     

       41
       41
       +
       }

     

       42
       42
        
       

     

       43
       43
        
       const customAttributeKeys: CustomAttributeKeys = {

     

       44
       44
       -
         req: "request",

     

       45
       45
       -
         res: "response",

     

       46
       46
       -
         err: "error",

     

       47
       47
       -
         responseTime: "timeTaken",

     

       48
       48
       -
       };

     

       44
       44
       +
         req: 'request',

     

       45
       45
       +
         res: 'response',

     

       46
       46
       +
         err: 'error',

     

       47
       47
       +
         responseTime: 'timeTaken',

     

       48
       48
       +
       }

     

       49
       49
        
       

     

       50
       50
        
       const customProps = (req: Request, res: Response): PinoCustomProps => ({

     

       51
       51
        
         request: req,

     

       52
       52
        
         response: res,

     

       53
       53
        
         error: res.locals.err,

     

       54
       54
        
         responseBody: res.locals.responseBody,

     

       55
       55
       -
       });

     

       55
       55
       +
       })

     

       56
       56
        
       

     

       57
       57
        
       const responseBodyMiddleware: RequestHandler = (_req, res, next) => {

     

       58
       58
       -
         const isNotProduction = !env.isProduction;

     

       58
       58
       +
         const isNotProduction = !env.isProduction

     

       59
       59
        
         if (isNotProduction) {

     

       60
       60
       -
           const originalSend = res.send;

     

       60
       60
       +
           const originalSend = res.send

     

       61
       61
        
           res.send = (content) => {

     

       62
       62
       -
             res.locals.responseBody = content;

     

       63
       63
       -
             res.send = originalSend;

     

       64
       64
       -
             return originalSend.call(res, content);

     

       65
       65
       -
           };

     

       62
       62
       +
             res.locals.responseBody = content

     

       63
       63
       +
             res.send = originalSend

     

       64
       64
       +
             return originalSend.call(res, content)

     

       65
       65
       +
           }

     

       66
       66
        
         }

     

       67
       67
       -
         next();

     

       68
       68
       -
       };

     

       67
       67
       +
         next()

     

       68
       68
       +
       }

     

       69
       69
        
       

     

       70
       70
        
       const customLogLevel = (_req: IncomingMessage, res: ServerResponse<IncomingMessage>, err?: Error): LevelWithSilent => {

     

       71
       71
       -
         if (err || res.statusCode >= StatusCodes.INTERNAL_SERVER_ERROR) return LogLevel.Error;

     

       72
       72
       -
         if (res.statusCode >= StatusCodes.BAD_REQUEST) return LogLevel.Warn;

     

       73
       73
       -
         if (res.statusCode >= StatusCodes.MULTIPLE_CHOICES) return LogLevel.Silent;

     

       74
       74
       -
         return LogLevel.Info;

     

       75
       75
       -
       };

     

       71
       71
       +
         if (err || res.statusCode >= StatusCodes.INTERNAL_SERVER_ERROR) return LogLevel.Error

     

       72
       72
       +
         if (res.statusCode >= StatusCodes.BAD_REQUEST) return LogLevel.Warn

     

       73
       73
       +
         if (res.statusCode >= StatusCodes.MULTIPLE_CHOICES) return LogLevel.Silent

     

       74
       74
       +
         return LogLevel.Info

     

       75
       75
       +
       }

     

       76
       76
        
       

     

       77
       77
        
       const customSuccessMessage = (req: IncomingMessage, res: ServerResponse<IncomingMessage>) => {

     

       78
       78
       -
         if (res.statusCode === StatusCodes.NOT_FOUND) return getReasonPhrase(StatusCodes.NOT_FOUND);

     

       79
       79
       -
         return `${req.method} completed`;

     

       80
       80
       -
       };

     

       78
       78
       +
         if (res.statusCode === StatusCodes.NOT_FOUND) return getReasonPhrase(StatusCodes.NOT_FOUND)

     

       79
       79
       +
         return `${req.method} completed`

     

       80
       80
       +
       }

     

       81
       81
        
       

     

       82
       82
        
       const genReqId = (req: IncomingMessage, res: ServerResponse<IncomingMessage>) => {

     

       83
       83
       -
         const existingID = req.id ?? req.headers["x-request-id"];

     

       84
       84
       -
         if (existingID) return existingID;

     

       85
       85
       -
         const id = randomUUID();

     

       86
       86
       -
         res.setHeader("X-Request-Id", id);

     

       87
       87
       -
         return id;

     

       88
       88
       -
       };

     

       83
       83
       +
         const existingID = req.id ?? req.headers['x-request-id']

     

       84
       84
       +
         if (existingID) return existingID

     

       85
       85
       +
         const id = randomUUID()

     

       86
       86
       +
         res.setHeader('X-Request-Id', id)

     

       87
       87
       +
         return id

     

       88
       88
       +
       }

     

       89
       89
        
       

     

       90
       90
       -
       export default requestLogger();

     

       90
       90
       +
       export default requestLogger()

+12 -17

src/routes/index.ts

···

       1
       1
       -
       import express from "express";

     

       2
       2
       -
       import type { AppContext } from "#/config";

     

       3
       3
       -
       import { handler } from "./util";

     

       1
       1
       +
       import express from 'express'

     

       2
       2
       +
       import type { AppContext } from '#/config'

     

       3
       3
       +
       import { handler } from './util'

     

       4
       4
        
       

     

       5
       5
        
       export const createRouter = (ctx: AppContext) => {

     

       6
       6
       -
         const router = express.Router();

     

       6
       6
       +
         const router = express.Router()

     

       7
       7
        
       

     

       8
       8
        
         router.get(

     

       9
       9
       -
           "/",

     

       9
       9
       +
           '/',

     

       10
       10
        
           handler(async (req, res) => {

     

       11
       11
       -
             const posts = await ctx.db

     

       12
       12
       -
               .selectFrom("post")

     

       13
       13
       -
               .selectAll()

     

       14
       14
       -
               .orderBy("indexedAt", "desc")

     

       15
       15
       -
               .limit(10)

     

       16
       16
       -
               .execute();

     

       17
       17
       -
             const postTexts = posts.map((row) => row.text);

     

       18
       18
       -
             res.json(postTexts);

     

       19
       19
       -
           })

     

       20
       20
       -
         );

     

       11
       11
       +
             const posts = await ctx.db.selectFrom('post').selectAll().orderBy('indexedAt', 'desc').limit(10).execute()

     

       12
       12
       +
             const postTexts = posts.map((row) => row.text)

     

       13
       13
       +
             res.json(postTexts)

     

       14
       14
       +
           }),

     

       15
       15
       +
         )

     

       21
       16
        
       

     

       22
       22
       -
         return router;

     

       23
       23
       -
       };

     

       17
       17
       +
         return router

     

       18
       18
       +
       }

+5 -10

src/routes/util.ts

···

       1
       1
       -
       import type express from "express";

     

       1
       1
       +
       import type express from 'express'

     

       2
       2
        
       

     

       3
       3
        
       export const handler =

     

       4
       4
       -
         (fn: express.Handler) =>

     

       5
       5
       -
         async (

     

       6
       6
       -
           req: express.Request,

     

       7
       7
       -
           res: express.Response,

     

       8
       8
       -
           next: express.NextFunction

     

       9
       9
       -
         ) => {

     

       4
       4
       +
         (fn: express.Handler) => async (req: express.Request, res: express.Response, next: express.NextFunction) => {

     

       10
       5
        
           try {

     

       11
       11
       -
             await fn(req, res, next);

     

       6
       6
       +
             await fn(req, res, next)

     

       12
       7
        
           } catch (err) {

     

       13
       13
       -
             next(err);

     

       8
       8
       +
             next(err)

     

       14
       9
        
           }

     

       15
       15
       -
         };

     

       10
       10
       +
         }

+41 -41

src/server.ts

···

       1
       1
       -
       import events from "node:events";

     

       2
       2
       -
       import type http from "node:http";

     

       3
       3
       -
       import cors from "cors";

     

       4
       4
       -
       import express, { type Express } from "express";

     

       5
       5
       -
       import helmet from "helmet";

     

       6
       6
       -
       import { pino } from "pino";

     

       1
       1
       +
       import events from 'node:events'

     

       2
       2
       +
       import type http from 'node:http'

     

       3
       3
       +
       import cors from 'cors'

     

       4
       4
       +
       import express, { type Express } from 'express'

     

       5
       5
       +
       import helmet from 'helmet'

     

       6
       6
       +
       import { pino } from 'pino'

     

       7
       7
        
       

     

       8
       8
       -
       import { createDb, migrateToLatest } from "#/db";

     

       9
       9
       -
       import { env } from "#/env";

     

       10
       10
       -
       import { Ingester } from "#/firehose/ingester";

     

       11
       11
       -
       import errorHandler from "#/middleware/errorHandler";

     

       12
       12
       -
       import requestLogger from "#/middleware/requestLogger";

     

       13
       13
       -
       import { createRouter } from "#/routes";

     

       14
       14
       -
       import type { AppContext } from "./config";

     

       8
       8
       +
       import { createDb, migrateToLatest } from '#/db'

     

       9
       9
       +
       import { env } from '#/env'

     

       10
       10
       +
       import { Ingester } from '#/firehose/ingester'

     

       11
       11
       +
       import errorHandler from '#/middleware/errorHandler'

     

       12
       12
       +
       import requestLogger from '#/middleware/requestLogger'

     

       13
       13
       +
       import { createRouter } from '#/routes'

     

       14
       14
       +
       import type { AppContext } from './config'

     

       15
       15
        
       

     

       16
       16
        
       export class Server {

     

       17
       17
        
         constructor(

     

       18
       18
        
           public app: express.Application,

     

       19
       19
        
           public server: http.Server,

     

       20
       20
       -
           public ctx: AppContext

     

       20
       20
       +
           public ctx: AppContext,

     

       21
       21
        
         ) {}

     

       22
       22
        
       

     

       23
       23
        
         static async create() {

     

       24
       24
       -
           const { NODE_ENV, HOST, PORT } = env;

     

       24
       24
       +
           const { NODE_ENV, HOST, PORT } = env

     

       25
       25
        
       

     

       26
       26
       -
           const logger = pino({ name: "server start" });

     

       27
       27
       -
           const db = createDb(":memory:");

     

       28
       28
       -
           await migrateToLatest(db);

     

       29
       29
       -
           const ingester = new Ingester(db);

     

       30
       30
       -
           ingester.start();

     

       26
       26
       +
           const logger = pino({ name: 'server start' })

     

       27
       27
       +
           const db = createDb(':memory:')

     

       28
       28
       +
           await migrateToLatest(db)

     

       29
       29
       +
           const ingester = new Ingester(db)

     

       30
       30
       +
           ingester.start()

     

       31
       31
        
           const ctx = {

     

       32
       32
        
             db,

     

       33
       33
        
             ingester,

     

       34
       34
        
             logger,

     

       35
       35
       -
           };

     

       35
       35
       +
           }

     

       36
       36
        
       

     

       37
       37
       -
           const app: Express = express();

     

       37
       37
       +
           const app: Express = express()

     

       38
       38
        
       

     

       39
       39
        
           // Set the application to trust the reverse proxy

     

       40
       40
       -
           app.set("trust proxy", true);

     

       40
       40
       +
           app.set('trust proxy', true)

     

       41
       41
        
       

     

       42
       42
        
           // TODO: middleware for sqlite server

     

       43
       43
        
           // TODO: middleware for OAuth

     

       44
       44
        
       

     

       45
       45
        
           // Middlewares

     

       46
       46
       -
           app.use(express.json());

     

       47
       47
       -
           app.use(express.urlencoded({ extended: true }));

     

       48
       48
       -
           app.use(cors({ origin: env.CORS_ORIGIN, credentials: true }));

     

       49
       49
       -
           app.use(helmet());

     

       46
       46
       +
           app.use(express.json())

     

       47
       47
       +
           app.use(express.urlencoded({ extended: true }))

     

       48
       48
       +
           app.use(cors({ origin: env.CORS_ORIGIN, credentials: true }))

     

       49
       49
       +
           app.use(helmet())

     

       50
       50
        
       

     

       51
       51
        
           // Request logging

     

       52
       52
       -
           app.use(requestLogger);

     

       52
       52
       +
           app.use(requestLogger)

     

       53
       53
        
       

     

       54
       54
        
           // Routes

     

       55
       55
       -
           const router = createRouter(ctx);

     

       56
       56
       -
           app.use(router);

     

       55
       55
       +
           const router = createRouter(ctx)

     

       56
       56
       +
           app.use(router)

     

       57
       57
        
       

     

       58
       58
        
           // Error handlers

     

       59
       59
       -
           app.use(errorHandler());

     

       59
       59
       +
           app.use(errorHandler())

     

       60
       60
        
       

     

       61
       61
       -
           const server = app.listen(env.PORT);

     

       62
       62
       -
           await events.once(server, "listening");

     

       63
       63
       -
           logger.info(`Server (${NODE_ENV}) running on port http://${HOST}:${PORT}`);

     

       61
       61
       +
           const server = app.listen(env.PORT)

     

       62
       62
       +
           await events.once(server, 'listening')

     

       63
       63
       +
           logger.info(`Server (${NODE_ENV}) running on port http://${HOST}:${PORT}`)

     

       64
       64
        
       

     

       65
       65
       -
           return new Server(app, server, ctx);

     

       65
       65
       +
           return new Server(app, server, ctx)

     

       66
       66
        
         }

     

       67
       67
        
       

     

       68
       68
        
         async close() {

     

       69
       69
       -
           this.ctx.logger.info("sigint received, shutting down");

     

       70
       70
       -
           this.ctx.ingester.destroy();

     

       69
       69
       +
           this.ctx.logger.info('sigint received, shutting down')

     

       70
       70
       +
           this.ctx.ingester.destroy()

     

       71
       71
        
           return new Promise<void>((resolve) => {

     

       72
       72
        
             this.server.close(() => {

     

       73
       73
       -
               this.ctx.logger.info("server closed");

     

       74
       74
       -
               resolve();

     

       75
       75
       -
             });

     

       76
       76
       -
           });

     

       73
       73
       +
               this.ctx.logger.info('server closed')

     

       74
       74
       +
               resolve()

     

       75
       75
       +
             })

     

       76
       76
       +
           })

     

       77
       77
        
         }

     

       78
       78
        
       }