commit 1b2d4175c9f665a0ad2f0663cd722a94ef2183b2 · mewsse.pet/pet.mewsse.link

+9 -6

src/db.ts

···

       4
       4
        
       

     

       5
       5
        
       import type { Migration, MigrationProvider } from 'kysely'

     

       6
       6
        
       import type { Blob, LegacyBlob } from '@atcute/lexicons'

     

       7
       7
       +
       

     

       7
       8
        
       export type DatabaseSchema = {

     

       8
       9
        
         links: Link,

     

       9
       10
        
         revs: Rev

     

       10
       11
        
       }

     

       12
       12
       +
       

     

       13
       13
       +
       export type Embed = { 

     

       14
       14
       +
           '$type': string, 

     

       15
       15
       +
           image?: Blob | LegacyBlob,

     

       16
       16
       +
           alt?: string, 

     

       17
       17
       +
           uri?: string 

     

       18
       18
       +
         } | null

     

       11
       19
        
       

     

       12
       20
        
       export type Link = {

     

       13
       21
        
         rkey: string,

     

       14
       22
        
         link: string,

     

       15
       23
        
         title: string,

     

       16
       24
        
         description: string | null,

     

       17
       17
       -
         embed: { 

     

       18
       18
       -
           '$type': string, 

     

       19
       19
       -
           image?: Blob | LegacyBlob,

     

       20
       20
       -
           alt?: string, 

     

       21
       21
       -
           uri?: string 

     

       22
       22
       -
         } | null,

     

       25
       25
       +
         embed: Embed,

     

       23
       26
        
         nsfw: number,

     

       24
       27
        
         big: number,

     

       25
       28
        
         createdAt: string,

+17 -8

src/index.ts

···

       1
       1
       +
       import { findUserPDS, getUserDID } from './id-resolver.ts'

     

       1
       2
        
       import { createDb, migrateToLatest } from './db.ts'

     

       2
       3
        
       import { createIngester } from './ingester.ts'

     

       3
       4
        
       import { Jetstream } from '@skyware/jetstream'

     
···

       7
       8
        
       import process from 'node:process'

     

       8
       9
        
       import dotenv from 'dotenv'

     

       9
       10
        
       

     

       11
       11
       +
       import type { Did } from '@atcute/lexicons/syntax'

     

       10
       12
        
       import type { Database } from './db.ts'

     

       11
       13
        
       

     

       12
       14
        
       dotenv.config()

     
···

       14
       16
        
       export type Context = {

     

       15
       17
        
         db: Database

     

       16
       18
        
         jetstream: Jetstream,

     

       17
       17
       -
         httpServer: Router

     

       19
       19
       +
         httpServer: Router,

     

       20
       20
       +
         did: Did<"web"> | Did<"plc">,

     

       21
       21
       +
         pds: string

     

       18
       22
        
       }

     

       19
       23
        
       

     

       20
       24
        
       export class Server {

     
···

       30
       34
        
           const port = process.env.PORT || "8080"

     

       31
       35
        
           const dbPath = process.env.DB_PATH || ":memory"

     

       32
       36
        
       

     

       37
       37
       +
           const did = getUserDID()

     

       38
       38
       +
           const pds = await findUserPDS()

     

       39
       39
       +
       

     

       33
       40
        
           const db = createDb(dbPath)

     

       34
       41
        
           await migrateToLatest(db)

     

       35
       42
        
           logger.info('Migrating db to latest version')

     

       36
       43
        
       

     

       37
       37
       -
           const ingester = createIngester(db)

     

       44
       44
       +
           const ingester = createIngester(db, did, pds)

     

       38
       45
        
           await ingester.backfill()

     

       39
       39
       -
           const jetstream = await ingester.jetstream()

     

       40
       40
       -
       

     

       41
       41
       -
           jetstream.start()

     

       42
       42
       -
           logger.info("Starting jetstream client")

     

       46
       46
       +
           const jetstream = await ingester.jetstream(did, pds)

     

       43
       47
        
       

     

       44
       48
        
           const httpServer = new Router()

     

       45
       45
       -
           createRoutes(httpServer, db)

     

       46
       49
        
       

     

       47
       50
        
           const ctx: Context = {

     

       48
       51
        
             db,

     

       49
       52
        
             jetstream,

     

       50
       50
       -
             httpServer

     

       53
       53
       +
             httpServer,

     

       54
       54
       +
             did,

     

       55
       55
       +
             pds

     

       51
       56
        
           }

     

       52
       57
        
       

     

       58
       58
       +
           jetstream.start()

     

       59
       59
       +
           logger.info("Starting jetstream client")

     

       60
       60
       +
       

     

       61
       61
       +
           createRoutes(ctx)

     

       53
       62
        
           httpServer.start(port)

     

       54
       63
        
           logger.info(`Starting http server on port ${port}`)

     

       55
       64

+2 -18

src/ingester.ts

···

       3
       3
        
       import type { Database, Link } from './db.ts'

     

       4
       4
        
       

     

       5
       5
        
       import { Client, simpleFetchHandler } from '@atcute/client'

     

       6
       6
       -
       import { findUserPDS, getUserDID } from './id-resolver.ts'

     

       7
       6
        
       import { CommitType, Jetstream } from '@skyware/jetstream'

     

       8
       7
        
       import { RepoReader } from '@atcute/car/v4'

     

       9
       8
        
       import { decode } from '@atcute/cbor'

     
···

       22
       21
        
         }

     

       23
       22
        
       }

     

       24
       23
        
       

     

       25
       25
       -
       export function findImage(did: Did<"web"> | Did<"plc">, pds: string, record: any): string | null {

     

       26
       26
       -
         const imageCid = record.image ? record.image.ref.$link : null

     

       27
       27
       -
         if (!imageCid) return null

     

       28
       28
       -
       

     

       29
       29
       -
         // let the user pull the blob with their browser directly fomr the pds

     

       30
       30
       -
         // decreasing space needed to run the service and prevent duplication

     

       31
       31
       -
         // if hosted at the same place as the pds (self host anyone ?)

     

       32
       32
       -
         return `${pds}/xrpc/com.atproto.sync.getBlob?did=${did}&cid=${imageCid}`

     

       33
       33
       -
       }

     

       34
       34
       -
       

     

       35
       35
       -
       export function createIngester(db: Database) {

     

       24
       24
       +
       export function createIngester(db: Database, did: Did<"web"> | Did<"plc">, pds: string) {

     

       36
       25
        
         return {

     

       37
       26
        
           async backfill(): Promise<any> {

     

       38
       38
       -
             const did = getUserDID()

     

       39
       39
       -
             const pds = await findUserPDS()

     

       40
       27
        
             const handler = simpleFetchHandler({ service: pds })

     

       41
       28
        
             const rpc = new Client({ handler })

     

       42
       29
        
             const now = new Date()

     
···

       158
       145
        
               }

     

       159
       146
        
           },

     

       160
       147
        
       

     

       161
       161
       -
           async jetstream(): Promise<Jetstream> {

     

       162
       162
       -
             const did = getUserDID()

     

       163
       163
       -
             const pds = await findUserPDS()

     

       164
       164
       -
       

     

       148
       148
       +
           async jetstream(did: Did<"web"> | Did<"plc">, pds: string): Promise<Jetstream> {

     

       165
       149
        
             const jetstream = new Jetstream({

     

       166
       150
        
               wantedDids: [did],

     

       167
       151
        
             })

+18 -12

src/routes.ts

···

       1
       1
        
       

     

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

     

       3
       3
       -
       import { Router } from "./lib/router.ts"

     

       3
       3
       +
       import { findEmbed } from "./lib/embed.ts"

     

       4
       4
        
       import path from "node:path"

     

       5
       5
        
       import { Eta } from "eta"

     

       6
       6
        
       

     

       7
       7
       -
       import type { Database } from './db.ts'

     

       7
       7
       +
       import type { Context } from "./index.ts"

     

       8
       8
        
       

     

       9
       9
       -
       export const createRoutes = (router: Router, db: Database) => {

     

       9
       9
       +
       export const createRoutes = (ctx: Context) => {

     

       10
       10
        
         const eta = new Eta({ views: path.join(import.meta.dirname, "views") })

     

       11
       11
        
         const itemPerPages = parseInt(process.env.ITEM_PER_PAGES || "10", 10)

     

       12
       12
       +
         const embed = findEmbed(ctx.did, ctx.pds)

     

       12
       13
        
       

     

       13
       14
        
         async function renderPage (

     

       14
       15
        
           req:IncomingMessage, 

     
···

       17
       18
        
         ) {

     

       18
       19
        
           const offset = params ? parseInt(params?.page, 10) - 1 : 0

     

       19
       20
        
       

     

       20
       20
       -
           const links = await db

     

       21
       21
       +
           const links = await ctx.db

     

       21
       22
        
             .selectFrom("links")

     

       22
       23
        
             .selectAll()

     

       23
       24
        
             .orderBy("createdAt", "desc")

     
···

       25
       26
        
             .limit(itemPerPages)

     

       26
       27
        
             .execute()

     

       27
       28
        
       

     

       28
       28
       -
           const totalLink = await db

     

       29
       29
       +
           const totalLink = await ctx.db

     

       29
       30
        
             .selectFrom("links")

     

       30
       30
       -
             .select(db.fn.countAll().as("count"))

     

       31
       31
       +
             .select(ctx.db.fn.countAll().as("count"))

     

       31
       32
        
             .executeTakeFirstOrThrow()

     

       32
       33
        
       

     

       33
       34
        
           const pages = Math.ceil(parseInt(totalLink.count.toString(), 10) / itemPerPages)

     
···

       35
       36
        
           const body = eta.render("./main", { 

     

       36
       37
        
             items: links, 

     

       37
       38
        
             pages: Array.from(Array(pages).keys()),

     

       38
       38
       -
             selected: parseInt(params?.page || "0", 10)

     

       39
       39
       +
             selected: parseInt(params?.page || "0", 10),

     

       40
       40
       +
             embed: embed

     

       39
       41
        
           })

     

       40
       42
        
       

     

       41
       43
        
           res.writeHead(200, { 'Content-Type': 'text/html' })

     

       42
       44
        
           res.end(body)

     

       43
       45
        
         }

     

       44
       46
        
       

     

       45
       45
       -
         router.get('/', async (req, res, params) => {

     

       47
       47
       +
         ctx.httpServer.get('/', async (req, res, params) => {

     

       46
       48
        
           await renderPage(req, res, params)

     

       47
       49
        
         })

     

       48
       50
        
       

     

       49
       49
       -
         router.get('/page/{page:number}', async (req, res, params) => {

     

       51
       51
       +
         ctx.httpServer.get('/page/{page:number}', async (req, res, params) => {

     

       50
       52
        
           await renderPage(req, res, params)

     

       51
       53
        
         })

     

       52
       54
        
       

     

       53
       53
       -
         router.get('/feed.atom', async (req, res, params) => {

     

       54
       54
       -
           const links = await db

     

       55
       55
       +
         ctx.httpServer.get('/feed.atom', async (req, res, params) => {

     

       56
       56
       +
           const links = await ctx.db

     

       55
       57
        
             .selectFrom("links")

     

       56
       58
        
             .selectAll()

     

       57
       59
        
             .orderBy("createdAt", "desc")

     
···

       60
       62
        
       

     

       61
       63
        
           const date = new Date(links[0].createdAt);

     

       62
       64
        
       

     

       63
       63
       -
           const body = eta.render("./feed", { items: links, date })

     

       65
       65
       +
           const body = eta.render("./feed", { 

     

       66
       66
       +
             items: links, 

     

       67
       67
       +
             date,

     

       68
       68
       +
             embed: embed

     

       69
       69
       +
           })

     

       64
       70
        
           res.writeHead(200, { 'Content-Type': 'application/atom+xml' })

     

       65
       71
        
           res.end(body)

     

       66
       72