commit 61fccc110f26f444eb0a7597c3695ec1d76b435a · mewsse.pet/pet.mewsse.link

+61 -49

lexicons/pet/mewsse/link.json

···

       1
       1
        
       {

     

       2
       2
       -
       	"lexicon": 1,

     

       3
       3
       -
       	"id": "pet.mewsse.link",

     

       4
       4
       -
       	"defs": {

     

       5
       5
       -
       		"main": {

     

       6
       6
       -
       			"type": "record",

     

       7
       7
       -
       			"description": "Record containing a link.",

     

       8
       8
       -
       			"key": "tid",

     

       9
       9
       -
       			"record": {

     

       10
       10
       -
       				"type": "object",

     

       11
       11
       -
       				"required": ["title", "link", "createdAt"],

     

       12
       12
       -
       				"properties": {

     

       13
       13
       -
       					"link": {

     

       14
       14
       -
       						"type": "string",

     

       15
       15
       -
       						"maxLength": 3000,

     

       16
       16
       -
       						"description": "The link to point to."

     

       17
       17
       -
       					},

     

       18
       18
       -
       					"title": {

     

       19
       19
       -
       						"type": "string",

     

       20
       20
       -
       						"maxLength": 3000,

     

       21
       21
       -
       						"description": "Title of the given link."

     

       22
       22
       -
       					},

     

       23
       23
       -
       					"description": {

     

       24
       24
       -
       						"type": "string",

     

       25
       25
       -
       						"description": "Short description for the content of the link."

     

       26
       26
       -
       					},

     

       27
       27
       -
                           "tag": {

     

       28
       28
       -
                               "type": "string",

     

       29
       29
       -
                               "description": "A tag for classify the link."

     

       30
       30
       -
                           },

     

       31
       31
       -
                           "image": {

     

       32
       32
       -
                               "type": "blob",

     

       33
       33
       -
                               "description": "An image to illustrate the link",

     

       34
       34
       -
                               "accept": ["image/*"],

     

       35
       35
       -
                               "maxSize": 1000000

     

       36
       36
       -
                           },

     

       37
       37
       -
                           "alt": {

     

       38
       38
       -
                               "type": "string",

     

       39
       39
       -
       						"maxLength": 3000,

     

       40
       40
       -
                               "description": "A alt text to describe the image."

     

       41
       41
       -
                           },

     

       42
       42
       -
       					"createdAt": {

     

       43
       43
       -
       						"type": "string",

     

       44
       44
       -
       						"format": "datetime",

     

       45
       45
       -
       						"description": "Client-declared timestamp when this post was originally created."

     

       46
       46
       -
       					}

     

       47
       47
       -
       				}

     

       48
       48
       -
       			}

     

       49
       49
       -
       		}

     

       50
       50
       -
       	}

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "pet.mewsse.link",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "record",

     

       7
       7
       +
             "description": "Record containing a link.",

     

       8
       8
       +
             "key": "tid",

     

       9
       9
       +
             "record": {

     

       10
       10
       +
               "type": "object",

     

       11
       11
       +
               "required": [

     

       12
       12
       +
                 "title",

     

       13
       13
       +
                 "link",

     

       14
       14
       +
                 "createdAt"

     

       15
       15
       +
               ],

     

       16
       16
       +
               "properties": {

     

       17
       17
       +
                 "link": {

     

       18
       18
       +
                   "type": "string",

     

       19
       19
       +
                   "maxLength": 3000,

     

       20
       20
       +
                   "description": "The link to point to."

     

       21
       21
       +
                 },

     

       22
       22
       +
                 "title": {

     

       23
       23
       +
                   "type": "string",

     

       24
       24
       +
                   "maxLength": 3000,

     

       25
       25
       +
                   "description": "Title of the given link."

     

       26
       26
       +
                 },

     

       27
       27
       +
                 "description": {

     

       28
       28
       +
                   "type": "string",

     

       29
       29
       +
                   "description": "Short description for the content of the link."

     

       30
       30
       +
                 },

     

       31
       31
       +
                 "image": {

     

       32
       32
       +
                   "type": "blob",

     

       33
       33
       +
                   "description": "An image to illustrate the link",

     

       34
       34
       +
                   "accept": [

     

       35
       35
       +
                     "image/*"

     

       36
       36
       +
                   ],

     

       37
       37
       +
                   "maxSize": 1000000

     

       38
       38
       +
                 },

     

       39
       39
       +
                 "alt": {

     

       40
       40
       +
                   "type": "string",

     

       41
       41
       +
                   "maxLength": 3000,

     

       42
       42
       +
                   "description": "A alt text to describe the image."

     

       43
       43
       +
                 },

     

       44
       44
       +
                 "nsfw": {

     

       45
       45
       +
                   "type": "boolean",

     

       46
       46
       +
                   "default": false,

     

       47
       47
       +
                   "description": "Is the link nsfw ?"

     

       48
       48
       +
                 },

     

       49
       49
       +
                 "big": {

     

       50
       50
       +
                   "type": "boolean",

     

       51
       51
       +
                   "default": false,

     

       52
       52
       +
                   "description": "Do we need to display the link as large content ?"

     

       53
       53
       +
                 },

     

       54
       54
       +
                 "createdAt": {

     

       55
       55
       +
                   "type": "string",

     

       56
       56
       +
                   "format": "datetime",

     

       57
       57
       +
                   "description": "Client-declared timestamp when this post was originally created."

     

       58
       58
       +
                 }

     

       59
       59
       +
               }

     

       60
       60
       +
             }

     

       61
       61
       +
           }

     

       62
       62
       +
         }

     

       51
       63
        
       }

+47 -45

src/db.ts

···

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

     

       5
       5
        
       

     

       6
       6
        
       export type DatabaseSchema = {

     

       7
       7
       -
           links: Link,

     

       8
       8
       -
           revs: Rev

     

       7
       7
       +
         links: Link,

     

       8
       8
       +
         revs: Rev

     

       9
       9
        
       }

     

       10
       10
        
       

     

       11
       11
        
       export type Link = {

     

       12
       12
       -
           rkey: string,

     

       13
       13
       -
           link: string,

     

       14
       14
       -
           title: string,

     

       15
       15
       -
           description: string | null,

     

       16
       16
       -
           tag: string | null,

     

       17
       17
       -
           image: string | null,

     

       18
       18
       -
           alt: string | null,

     

       19
       19
       -
           createdAt: string,

     

       12
       12
       +
         rkey: string,

     

       13
       13
       +
         link: string,

     

       14
       14
       +
         title: string,

     

       15
       15
       +
         description: string | null,

     

       16
       16
       +
         image: string | null,

     

       17
       17
       +
         alt: string | null,

     

       18
       18
       +
         nsfw: number,

     

       19
       19
       +
         big: number,

     

       20
       20
       +
         createdAt: string,

     

       20
       21
        
       }

     

       21
       22
        
       

     

       22
       23
        
       export type Rev = {

     

       23
       23
       -
           rkey: string,

     

       24
       24
       -
           createdAt: string,

     

       24
       24
       +
         rkey: string,

     

       25
       25
       +
         createdAt: string,

     

       25
       26
        
       }

     

       26
       27
        
       

     

       27
       28
        
       const migrations: Record<string, Migration> = {}

     

       28
       29
        
       const migrationProvider: MigrationProvider = {

     

       29
       29
       -
           async getMigrations() {

     

       30
       30
       -
               return migrations

     

       31
       31
       -
           },

     

       30
       30
       +
         async getMigrations() {

     

       31
       31
       +
           return migrations

     

       32
       32
       +
         },

     

       32
       33
        
       }

     

       33
       34
        
       

     

       34
       35
        
       migrations['001'] = {

     

       35
       35
       -
           async up(db: Kysely<any>) {

     

       36
       36
       -
               await db.schema

     

       37
       37
       -
                   .createTable('links')

     

       38
       38
       -
                   .addColumn('rkey', 'varchar', (col) => col.primaryKey())

     

       39
       39
       -
                   .addColumn('link', 'varchar', (col) => col.notNull())

     

       40
       40
       -
                   .addColumn('title', 'varchar', (col) => col.notNull())

     

       41
       41
       -
                   .addColumn('description', 'varchar')

     

       42
       42
       -
                   .addColumn('tag', 'varchar')

     

       43
       43
       -
                   .addColumn('image', 'varchar')

     

       44
       44
       -
                   .addColumn('alt', 'varchar')

     

       45
       45
       -
                   .addColumn('createdAt', 'varchar', (col) => col.notNull())

     

       46
       46
       -
                   .execute()

     

       36
       36
       +
         async up(db: Kysely<any>) {

     

       37
       37
       +
           await db.schema

     

       38
       38
       +
             .createTable('links')

     

       39
       39
       +
             .addColumn('rkey', 'varchar', (col) => col.primaryKey())

     

       40
       40
       +
             .addColumn('link', 'varchar', (col) => col.notNull())

     

       41
       41
       +
             .addColumn('title', 'varchar', (col) => col.notNull())

     

       42
       42
       +
             .addColumn('description', 'varchar')

     

       43
       43
       +
             .addColumn('image', 'varchar')

     

       44
       44
       +
             .addColumn('alt', 'varchar')

     

       45
       45
       +
             .addColumn('nsfw', 'integer')

     

       46
       46
       +
             .addColumn('big', 'integer')

     

       47
       47
       +
             .addColumn('createdAt', 'varchar', (col) => col.notNull())

     

       48
       48
       +
             .execute()

     

       47
       49
        
       

     

       48
       48
       -
               await db.schema

     

       49
       49
       -
                   .createTable('revs')

     

       50
       50
       -
                   .addColumn('rkey', 'varchar', (col) => col.primaryKey())

     

       51
       51
       -
                   .addColumn('createdAt', 'varchar', (col) => col.notNull())

     

       52
       52
       -
                   .execute()

     

       53
       53
       -
           },

     

       50
       50
       +
           await db.schema

     

       51
       51
       +
             .createTable('revs')

     

       52
       52
       +
             .addColumn('rkey', 'varchar', (col) => col.primaryKey())

     

       53
       53
       +
             .addColumn('createdAt', 'varchar', (col) => col.notNull())

     

       54
       54
       +
             .execute()

     

       55
       55
       +
         },

     

       54
       56
        
       

     

       55
       55
       -
           async down(db: Kysely<any>) {

     

       56
       56
       -
               await db.schema.dropTable('links').execute()

     

       57
       57
       -
               await db.schema.dropTable('rev').execute()

     

       58
       58
       -
           },

     

       57
       57
       +
         async down(db: Kysely<any>) {

     

       58
       58
       +
           await db.schema.dropTable('links').execute()

     

       59
       59
       +
           await db.schema.dropTable('rev').execute()

     

       60
       60
       +
         },

     

       59
       61
        
       }

     

       60
       62
        
       

     

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

     

       62
       62
       -
           return new Kysely<DatabaseSchema>({

     

       63
       63
       -
               dialect: new SqliteDialect({

     

       64
       64
       -
                   database: new SqliteDb(location)

     

       65
       65
       -
               }),

     

       66
       66
       -
           })

     

       64
       64
       +
         return new Kysely<DatabaseSchema>({

     

       65
       65
       +
           dialect: new SqliteDialect({

     

       66
       66
       +
             database: new SqliteDb(location)

     

       67
       67
       +
           }),

     

       68
       68
       +
         })

     

       67
       69
        
       }

     

       68
       70
        
       

     

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

     

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

     

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

     

       72
       72
       -
           if(error) throw error

     

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

     

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

     

       74
       74
       +
         if (error) throw error

     

       73
       75
        
       }

     

       74
       76
        
       

     

       75
       77
        
       export type Database = Kysely<DatabaseSchema>

+45 -45

src/id-resolver.ts

···

       1
       1
        
       import { CompositeDidDocumentResolver, PlcDidDocumentResolver, WebDidDocumentResolver } from '@atcute/identity-resolver'

     

       2
       2
       -
       import { isDid} from '@atcute/lexicons/syntax'

     

       2
       2
       +
       import { isDid } from '@atcute/lexicons/syntax'

     

       3
       3
        
       import process from 'node:process'

     

       4
       4
        
       

     

       5
       5
       -
       import type { DidDocument, Service } from '@atcute/identity'

     

       5
       5
       +
       import type { DidDocument } from '@atcute/identity'

     

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

     

       7
       7
        
       

     

       8
       8
        
       const docResolver = new CompositeDidDocumentResolver({

     

       9
       9
       -
           methods: {

     

       10
       10
       -
               plc: new PlcDidDocumentResolver(),

     

       11
       11
       -
               web: new WebDidDocumentResolver()

     

       12
       12
       -
           }

     

       9
       9
       +
         methods: {

     

       10
       10
       +
           plc: new PlcDidDocumentResolver(),

     

       11
       11
       +
           web: new WebDidDocumentResolver()

     

       12
       12
       +
         }

     

       13
       13
        
       })

     

       14
       14
        
       

     

       15
       15
        
       export class DIDError extends Error {

     

       16
       16
       -
           constructor(msg: string) {

     

       17
       17
       -
               super(msg)

     

       16
       16
       +
         constructor(msg: string) {

     

       17
       17
       +
           super(msg)

     

       18
       18
        
       

     

       19
       19
       -
               Object.setPrototypeOf(this, DIDError.prototype)

     

       20
       20
       -
           }

     

       19
       19
       +
           Object.setPrototypeOf(this, DIDError.prototype)

     

       20
       20
       +
         }

     

       21
       21
        
       }

     

       22
       22
        
       

     

       23
       23
        
       export class ServiceError extends Error {

     

       24
       24
       -
           constructor(msg: string) {

     

       25
       25
       -
               super(msg)

     

       24
       24
       +
         constructor(msg: string) {

     

       25
       25
       +
           super(msg)

     

       26
       26
        
       

     

       27
       27
       -
               Object.setPrototypeOf(this, ServiceError.prototype)

     

       28
       28
       -
           }

     

       27
       27
       +
           Object.setPrototypeOf(this, ServiceError.prototype)

     

       28
       28
       +
         }

     

       29
       29
        
       }

     

       30
       30
        
       

     

       31
       31
       -
       export function getUserDID() : Did<"web"> | Did<"plc"> {

     

       32
       32
       -
           const did = process.env.DID

     

       31
       31
       +
       export function getUserDID(): Did<"web"> | Did<"plc"> {

     

       32
       32
       +
         const did = process.env.DID

     

       33
       33
        
       

     

       34
       34
       -
           if (!did || did == "") {

     

       35
       35
       -
               throw new DIDError("Missing DID to ingest")

     

       36
       36
       -
           }

     

       34
       34
       +
         if (!did || did == "") {

     

       35
       35
       +
           throw new DIDError("Missing DID to ingest")

     

       36
       36
       +
         }

     

       37
       37
        
       

     

       38
       38
       -
           if (!isDid(did)) {

     

       39
       39
       -
               throw new DIDError("DID is not in the correct format")

     

       40
       40
       -
           }

     

       38
       38
       +
         if (!isDid(did)) {

     

       39
       39
       +
           throw new DIDError("DID is not in the correct format")

     

       40
       40
       +
         }

     

       41
       41
        
       

     

       42
       42
       -
           return did as Did<"web"> | Did<"plc">

     

       42
       42
       +
         return did as Did<"web"> | Did<"plc">

     

       43
       43
        
       }

     

       44
       44
        
       

     

       45
       45
       -
       export async function findUserDIDDoc() : Promise<DidDocument> {

     

       45
       45
       +
       export async function findUserDIDDoc(): Promise<DidDocument> {

     

       46
       46
        
       

     

       47
       47
       -
           try {

     

       48
       48
       -
               const did = getUserDID()

     

       49
       49
       -
               const doc = await docResolver.resolve(did)

     

       50
       50
       -
               return doc

     

       51
       51
       -
           } catch (err) {

     

       52
       52
       -
               throw err

     

       53
       53
       -
           }

     

       47
       47
       +
         try {

     

       48
       48
       +
           const did = getUserDID()

     

       49
       49
       +
           const doc = await docResolver.resolve(did)

     

       50
       50
       +
           return doc

     

       51
       51
       +
         } catch (err) {

     

       52
       52
       +
           throw err

     

       53
       53
       +
         }

     

       54
       54
        
       }

     

       55
       55
        
       

     

       56
       56
        
       export async function findUserPDS(): Promise<string> {

     

       57
       57
       -
           const didDoc = await findUserDIDDoc()

     

       57
       57
       +
         const didDoc = await findUserDIDDoc()

     

       58
       58
       +
       

     

       59
       59
       +
         if (!didDoc.service) {

     

       60
       60
       +
           throw new ServiceError("No service found on user did doc")

     

       61
       61
       +
         }

     

       58
       62
        
       

     

       59
       59
       -
           if (!didDoc.service) {

     

       60
       60
       -
               throw new ServiceError("No service found on user did doc")

     

       61
       61
       -
           }

     

       63
       63
       +
         const pds = didDoc.service.filter(service => service.id == "#atproto_pds")

     

       62
       64
        
       

     

       63
       63
       -
           const pds = didDoc.service.filter(service => service.id == "#atproto_pds")

     

       64
       64
       -
           

     

       65
       65
       -
           if (pds.length < 1) {

     

       66
       66
       -
               throw new ServiceError(`No valid service found for ${process.env.DID}`)

     

       67
       67
       -
           }

     

       65
       65
       +
         if (pds.length < 1) {

     

       66
       66
       +
           throw new ServiceError(`No valid service found for ${process.env.DID}`)

     

       67
       67
       +
         }

     

       68
       68
        
       

     

       69
       69
       -
           let serviceEndpoint = pds.shift()?.serviceEndpoint

     

       69
       69
       +
         let serviceEndpoint = pds.shift()?.serviceEndpoint

     

       70
       70
        
       

     

       71
       71
       -
           if (!serviceEndpoint || typeof serviceEndpoint != 'string' ) {

     

       72
       72
       -
               throw new ServiceError(`No valid service found for ${process.env.DID}`)

     

       73
       73
       -
           }

     

       71
       71
       +
         if (!serviceEndpoint || typeof serviceEndpoint != 'string') {

     

       72
       72
       +
           throw new ServiceError(`No valid service found for ${process.env.DID}`)

     

       73
       73
       +
         }

     

       74
       74
        
       

     

       75
       75
       -
           return serviceEndpoint

     

       75
       75
       +
         return serviceEndpoint

     

       76
       76
        
       }

+49 -49

src/index.ts

···

       12
       12
        
       dotenv.config()

     

       13
       13
        
       

     

       14
       14
        
       export type Context = {

     

       15
       15
       -
           db: Database

     

       16
       16
       -
           jetstream: Jetstream,

     

       17
       17
       -
           httpServer: Router

     

       15
       15
       +
         db: Database

     

       16
       16
       +
         jetstream: Jetstream,

     

       17
       17
       +
         httpServer: Router

     

       18
       18
        
       }

     

       19
       19
        
       

     

       20
       20
        
       export class Server {

     

       21
       21
       -
           public ctx: Context

     

       21
       21
       +
         public ctx: Context

     

       22
       22
        
       

     

       23
       23
       -
           constructor(

     

       24
       24
       -
               ctx: Context

     

       25
       25
       -
           ) {

     

       26
       26
       -
               this.ctx = ctx

     

       27
       27
       -
           }

     

       23
       23
       +
         constructor(

     

       24
       24
       +
           ctx: Context

     

       25
       25
       +
         ) {

     

       26
       26
       +
           this.ctx = ctx

     

       27
       27
       +
         }

     

       28
       28
        
       

     

       29
       29
       -
           static async create() {

     

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

     

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

     

       29
       29
       +
         static async create() {

     

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

     

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

     

       32
       32
        
       

     

       33
       33
       -
               const db = createDb(dbPath)

     

       34
       34
       -
               await migrateToLatest(db)

     

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

     

       33
       33
       +
           const db = createDb(dbPath)

     

       34
       34
       +
           await migrateToLatest(db)

     

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

     

       36
       36
        
       

     

       37
       37
       -
               const ingester = createIngester(db)

     

       38
       38
       -
               await ingester.backfill()

     

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

     

       37
       37
       +
           const ingester = createIngester(db)

     

       38
       38
       +
           await ingester.backfill()

     

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

     

       40
       40
        
       

     

       41
       41
       -
               jetstream.start()

     

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

     

       41
       41
       +
           jetstream.start()

     

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

     

       43
       43
        
       

     

       44
       44
       -
               const httpServer = new Router()

     

       45
       45
       -
               createRoutes(httpServer)

     

       44
       44
       +
           const httpServer = new Router()

     

       45
       45
       +
           createRoutes(httpServer, db)

     

       46
       46
        
       

     

       47
       47
       -
               const ctx: Context = {

     

       48
       48
       -
                   db,

     

       49
       49
       -
                   jetstream,

     

       50
       50
       -
                   httpServer

     

       51
       51
       -
               }

     

       52
       52
       -
               

     

       53
       53
       -
               httpServer.start(port)

     

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

     

       55
       55
       -
               

     

       56
       56
       -
               return new Server(ctx)

     

       47
       47
       +
           const ctx: Context = {

     

       48
       48
       +
             db,

     

       49
       49
       +
             jetstream,

     

       50
       50
       +
             httpServer

     

       57
       51
        
           }

     

       58
       58
       -
           

     

       59
       59
       -
           async close() {

     

       60
       60
       -
               logger.info("Stopping jetstream client")

     

       61
       61
       -
               await this.ctx.jetstream.close()

     

       62
       62
       -
               await this.ctx.httpServer.close()

     

       52
       52
       +
       

     

       53
       53
       +
           httpServer.start(port)

     

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

     

       55
       55
       +
       

     

       56
       56
       +
           return new Server(ctx)

     

       57
       57
       +
         }

     

       58
       58
       +
       

     

       59
       59
       +
         async close() {

     

       60
       60
       +
           logger.info("Stopping jetstream client")

     

       61
       61
       +
           await this.ctx.jetstream.close()

     

       62
       62
       +
           await this.ctx.httpServer.close()

     

       63
       63
        
       

     

       64
       64
       -
               return new Promise<void>((resolve) => {

     

       65
       65
       -
                   resolve()

     

       66
       66
       -
               })

     

       67
       67
       -
           }

     

       64
       64
       +
           return new Promise<void>((resolve) => {

     

       65
       65
       +
             resolve()

     

       66
       66
       +
           })

     

       67
       67
       +
         }

     

       68
       68
        
       }

     

       69
       69
        
       

     

       70
       70
        
       

     

       71
       71
        
       const run = async () => {

     

       72
       72
       -
           const server = await Server.create()

     

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

     

       73
       73
        
       

     

       74
       74
       -
           const onClose = async () => {

     

       75
       75
       -
               setTimeout(() => process.exit(1), 10000).unref()

     

       76
       76
       -
               // await server.close()

     

       77
       77
       -
               process.exit()

     

       78
       78
       -
           }

     

       74
       74
       +
         const onClose = async () => {

     

       75
       75
       +
           setTimeout(() => process.exit(1), 10000).unref()

     

       76
       76
       +
           // await server.close()

     

       77
       77
       +
           process.exit()

     

       78
       78
       +
         }

     

       79
       79
        
       

     

       80
       80
       -
           process.on('SIGINT', onClose)

     

       81
       81
       -
           process.on('SIGTERM', onClose)

     

       80
       80
       +
         process.on('SIGINT', onClose)

     

       81
       81
       +
         process.on('SIGTERM', onClose)

     

       82
       82
        
       }

     

       83
       83
        
       

     

       84
       84
        
       run()

+152 -148

src/ingester.ts

···

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

     

       10
       10
        
       import { logger } from "./lib/logger.ts"

     

       11
       11
        
       

     

       12
       12
       +
       import type { CommitCreate } from "@skyware/jetstream"

     

       13
       13
       +
       

     

       12
       14
        
       interface RepoParams {

     

       13
       13
       -
           did: Did<"web"> | Did<"plc">,

     

       14
       14
       -
           since?: string

     

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

     

       16
       16
       +
         since?: string

     

       15
       17
        
       }

     

       16
       18
        
       

     

       17
       19
        
       export class IngestionError extends Error {

     

       18
       18
       -
           constructor(msg: string) {

     

       19
       19
       -
               super(msg)

     

       20
       20
       +
         constructor(msg: string) {

     

       21
       21
       +
           super(msg)

     

       20
       22
        
       

     

       21
       21
       -
               Object.setPrototypeOf(this, IngestionError.prototype)

     

       22
       22
       -
           }

     

       23
       23
       +
           Object.setPrototypeOf(this, IngestionError.prototype)

     

       24
       24
       +
         }

     

       23
       25
        
       }

     

       24
       26
        
       

     

       25
       27
        
       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}`

     

       28
       28
       +
         const imageCid = record.image ? record.image.ref.$link : null

     

       29
       29
       +
         if (!imageCid) return null

     

       30
       30
       +
       

     

       31
       31
       +
         // let the user pull the blob with their browser directly fomr the pds

     

       32
       32
       +
         // decreasing space needed to run the service and prevent duplication

     

       33
       33
       +
         // if hosted at the same place as the pds (self host anyone ?)

     

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

     

       33
       35
        
       }

     

       34
       36
        
       

     

       35
       37
        
       export function createIngester(db: Database) {

     

       36
       36
       -
           return {

     

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

     

       38
       38
       -
                   const did = getUserDID()

     

       39
       39
       -
                   const pds = await findUserPDS()

     

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

     

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

     

       42
       42
       -
                   const now = new Date()

     

       38
       38
       +
         return {

     

       39
       39
       +
           async backfill(): Promise<any> {

     

       40
       40
       +
             const did = getUserDID()

     

       41
       41
       +
             const pds = await findUserPDS()

     

       42
       42
       +
             const handler = simpleFetchHandler({ service: pds })

     

       43
       43
       +
             const rpc = new Client({ handler })

     

       44
       44
       +
             const now = new Date()

     

       43
       45
        
       

     

       44
       44
       -
                   logger.info(`Starting backfilling`)

     

       46
       46
       +
             logger.info(`Starting backfilling`)

     

       45
       47
        
       

     

       46
       46
       -
                   const params: RepoParams = {

     

       47
       47
       -
                       did

     

       48
       48
       -
                   }

     

       48
       48
       +
             const params: RepoParams = {

     

       49
       49
       +
               did

     

       50
       50
       +
             }

     

       49
       51
        
       

     

       50
       50
       -
                   const lastRev = await db

     

       51
       51
       -
                       .selectFrom('revs')

     

       52
       52
       -
                       .select('rkey')

     

       53
       53
       -
                       .orderBy('createdAt', 'desc')

     

       54
       54
       -
                       .executeTakeFirst()

     

       52
       52
       +
             const lastRev = await db

     

       53
       53
       +
               .selectFrom('revs')

     

       54
       54
       +
               .select('rkey')

     

       55
       55
       +
               .orderBy('createdAt', 'desc')

     

       56
       56
       +
               .executeTakeFirst()

     

       55
       57
        
       

     

       56
       56
       -
                   if (lastRev) {

     

       57
       57
       -
                       params.since = lastRev.rkey

     

       58
       58
       -
                   }

     

       58
       58
       +
             if (lastRev) {

     

       59
       59
       +
               params.since = lastRev.rkey

     

       60
       60
       +
             }

     

       59
       61
        
       

     

       60
       60
       -
                   const {ok, data} = await rpc.get(`com.atproto.sync.getRepo`, {

     

       61
       61
       -
                       params,

     

       62
       62
       -
                       as: 'stream'

     

       63
       63
       -
                   })

     

       62
       62
       +
             const { ok, data } = await rpc.get(`com.atproto.sync.getRepo`, {

     

       63
       63
       +
               params,

     

       64
       64
       +
               as: 'stream'

     

       65
       65
       +
             })

     

       64
       66
        
       

     

       65
       65
       -
                   if (!ok) {

     

       66
       66
       -
                       throw new IngestionError(`Error while syncing repo for ${did} on ${pds}`)

     

       67
       67
       -
                   }

     

       67
       67
       +
             if (!ok) {

     

       68
       68
       +
               throw new IngestionError(`Error while syncing repo for ${did} on ${pds}`)

     

       69
       69
       +
             }

     

       68
       70
        
       

     

       69
       69
       -
                   await using repo = RepoReader.fromStream(data)

     

       70
       70
       -
                   let links:Array<Link> = []

     

       71
       71
       -
                   let repoRev = null;

     

       71
       71
       +
             await using repo = RepoReader.fromStream(data)

     

       72
       72
       +
             let links: Array<Link> = []

     

       73
       73
       +
             let repoRev = null;

     

       72
       74
        
       

     

       73
       73
       -
                   for await (const entry of repo) {

     

       74
       74
       -
                       if (!repoRev) repoRev = entry.rkey

     

       75
       75
       -
                       if (entry.collection != "pet.mewsse.link") continue

     

       76
       76
       -
                       const link : Link = decode(entry.bytes)

     

       75
       75
       +
             for await (const entry of repo) {

     

       76
       76
       +
               if (!repoRev) repoRev = entry.rkey

     

       77
       77
       +
               if (entry.collection != "pet.mewsse.link") continue

     

       78
       78
       +
               const link = decode(entry.bytes)

     

       77
       79
        
       

     

       78
       78
       -
                       links.push({

     

       79
       79
       -
                           rkey: entry.rkey,

     

       80
       80
       -
                           link: link.link,

     

       81
       81
       -
                           title: link.title,

     

       82
       82
       -
                           description: link.description,

     

       83
       83
       -
                           tag: link.tag ?? null,

     

       84
       84
       -
                           image: findImage(did, pds, link),

     

       85
       85
       -
                           alt: link.alt ?? null,

     

       86
       86
       -
                           createdAt: link.createdAt

     

       87
       87
       -
                       })

     

       88
       88
       -
                   }

     

       80
       80
       +
               links.push({

     

       81
       81
       +
                 rkey: entry.rkey,

     

       82
       82
       +
                 link: link.link,

     

       83
       83
       +
                 title: link.title,

     

       84
       84
       +
                 description: link.description,

     

       85
       85
       +
                 image: findImage(did, pds, link),

     

       86
       86
       +
                 alt: link.alt ?? null,

     

       87
       87
       +
                 nsfw: +(link.nsfw || 0),

     

       88
       88
       +
                 big: +(link.big || 0),

     

       89
       89
       +
                 createdAt: link.createdAt

     

       90
       90
       +
               })

     

       91
       91
       +
             }

     

       89
       92
        
       

     

       90
       90
       -
                   links = links.sort((a, b) => a.createdAt > b.createdAt ? 1 : -1)

     

       93
       93
       +
             links = links.sort((a, b) => a.createdAt > b.createdAt ? 1 : -1)

     

       91
       94
        
       

     

       92
       92
       -
                   for await (const link of links) {

     

       93
       93
       -
                       await db

     

       94
       94
       -
                           .insertInto('links')

     

       95
       95
       -
                           .values(link)

     

       96
       96
       -
                           .onConflict((conflict) => 

     

       97
       97
       -
                               conflict.column('rkey').doUpdateSet({

     

       98
       98
       -
                                   link: link.link,

     

       99
       99
       -
                                   title: link.title,

     

       100
       100
       -
                                   description: link.description,

     

       101
       101
       -
                                   tag: link.tag,

     

       102
       102
       -
                                   image: link.image,

     

       103
       103
       -
                                   alt: link.alt,

     

       104
       104
       -
                               })

     

       105
       105
       -
                           )

     

       106
       106
       -
                           .execute()

     

       107
       107
       -
                       

     

       108
       108
       -
                       logger.info(`Inserting record ${link.rkey}`)

     

       109
       109
       -
                   }

     

       95
       95
       +
             for await (const link of links) {

     

       96
       96
       +
               await db

     

       97
       97
       +
                 .insertInto('links')

     

       98
       98
       +
                 .values(link)

     

       99
       99
       +
                 .onConflict((conflict) =>

     

       100
       100
       +
                   conflict.column('rkey').doUpdateSet({

     

       101
       101
       +
                     link: link.link,

     

       102
       102
       +
                     title: link.title,

     

       103
       103
       +
                     description: link.description,

     

       104
       104
       +
                     image: link.image,

     

       105
       105
       +
                     alt: link.alt,

     

       106
       106
       +
                     nsfw: +(link.nsfw || 0),

     

       107
       107
       +
                     big: +(link.big || 0),

     

       108
       108
       +
                   })

     

       109
       109
       +
                 )

     

       110
       110
       +
                 .execute()

     

       110
       111
        
       

     

       111
       111
       -
                   if (!repoRev || repoRev === null) {

     

       112
       112
       -
                       logger.error('Backfilling error: no last pds revision found')

     

       113
       113
       -
                       return;

     

       114
       114
       -
                   }

     

       112
       112
       +
               logger.info(`Inserting record ${link.rkey}`)

     

       113
       113
       +
             }

     

       115
       114
        
       

     

       116
       116
       -
                   if (repoRev != lastRev?.rkey) {

     

       117
       117
       -
                       await db

     

       118
       118
       -
                           .insertInto('revs')

     

       119
       119
       -
                           .values({

     

       120
       120
       -
                               rkey: repoRev,

     

       121
       121
       -
                               createdAt: now.toISOString()

     

       122
       122
       -
                           })

     

       123
       123
       -
                           .execute()

     

       124
       124
       -
                   }

     

       115
       115
       +
             if (!repoRev || repoRev === null) {

     

       116
       116
       +
               logger.error('Backfilling error: no last pds revision found')

     

       117
       117
       +
               return;

     

       118
       118
       +
             }

     

       125
       119
        
       

     

       126
       126
       -
                   logger.info(`Backfilling ended`)

     

       127
       127
       -
               },

     

       120
       120
       +
             if (repoRev != lastRev?.rkey) {

     

       121
       121
       +
               await db

     

       122
       122
       +
                 .insertInto('revs')

     

       123
       123
       +
                 .values({

     

       124
       124
       +
                   rkey: repoRev,

     

       125
       125
       +
                   createdAt: now.toISOString()

     

       126
       126
       +
                 })

     

       127
       127
       +
                 .execute()

     

       128
       128
       +
             }

     

       128
       129
        
       

     

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

     

       130
       130
       -
                   const did = getUserDID()

     

       131
       131
       -
                   const pds = await findUserPDS()

     

       130
       130
       +
             logger.info(`Backfilling ended`)

     

       131
       131
       +
           },

     

       132
       132
        
       

     

       133
       133
       -
                   const jetstream = new Jetstream({

     

       134
       134
       -
                       wantedCollections: ['pet.mewsse.link'],

     

       135
       135
       -
                       wantedDids: [did]

     

       136
       136
       -
                   })

     

       133
       133
       +
           async jetstream(): Promise<Jetstream> {

     

       134
       134
       +
             const did = getUserDID()

     

       135
       135
       +
             const pds = await findUserPDS()

     

       137
       136
        
       

     

       138
       138
       -
                   jetstream.onCreate('pet.mewsse.link', async (event) => {

     

       139
       139
       -
                       if (event.commit.record.$type != "pet.mewsse.link") return

     

       137
       137
       +
             const jetstream = new Jetstream({

     

       138
       138
       +
               wantedCollections: ['pet.mewsse.link'],

     

       139
       139
       +
               wantedDids: [did]

     

       140
       140
       +
             })

     

       140
       141
        
       

     

       141
       141
       -
                       const rev = event.commit.rev

     

       142
       142
       -
                       const record = event.commit.record

     

       143
       143
       -
                       

     

       142
       142
       +
             jetstream.onCreate('pet.mewsse.link', async (event) => {

     

       143
       143
       +
               if (event.commit.record.$type != "pet.mewsse.link") return

     

       144
       144
        
       

     

       145
       145
       -
                       await db

     

       146
       146
       -
                           .insertInto('links')

     

       147
       147
       -
                           .values({

     

       148
       148
       -
                               rkey: rev,

     

       149
       149
       -
                               link: record.link,

     

       150
       150
       -
                               title: record.title,

     

       151
       151
       -
                               description: record.description ?? null,

     

       152
       152
       -
                               tag: record.tag ?? null,

     

       153
       153
       -
                               image: findImage(did, pds, record),

     

       154
       154
       -
                               alt: record.alt ?? null,

     

       155
       155
       -
                               createdAt: record.createdAt

     

       156
       156
       -
                           })

     

       157
       157
       -
                           .execute()

     

       145
       145
       +
               const rev = event.commit.rev

     

       146
       146
       +
               const record = event.commit.record

     

       158
       147
        
       

     

       159
       159
       -
                       logger.info(`Record ${rev} created`)

     

       160
       160
       -
                   })

     

       161
       148
        
       

     

       162
       162
       -
                   jetstream.onUpdate('pet.mewsse.link', async (event) => {

     

       163
       163
       -
                       if (event.commit.record.$type != "pet.mewsse.link") return

     

       149
       149
       +
               await db

     

       150
       150
       +
                 .insertInto('links')

     

       151
       151
       +
                 .values({

     

       152
       152
       +
                   rkey: rev,

     

       153
       153
       +
                   link: record.link,

     

       154
       154
       +
                   title: record.title,

     

       155
       155
       +
                   description: record.description ?? null,

     

       156
       156
       +
                   image: findImage(did, pds, record),

     

       157
       157
       +
                   alt: record.alt ?? null,

     

       158
       158
       +
                   nsfw: +(record.nsfw || 0),

     

       159
       159
       +
                   big: +(record.big || 0),

     

       160
       160
       +
                   createdAt: record.createdAt

     

       161
       161
       +
                 })

     

       162
       162
       +
                 .execute()

     

       164
       163
        
       

     

       165
       165
       -
                       const rev = event.commit.rev

     

       166
       166
       -
                       const record = event.commit.record

     

       164
       164
       +
               logger.info(`Record ${rev} created`)

     

       165
       165
       +
             })

     

       167
       166
        
       

     

       168
       168
       -
                       await db

     

       169
       169
       -
                           .updateTable('links')

     

       170
       170
       -
                           .set({

     

       171
       171
       -
                               link: record.link,

     

       172
       172
       -
                               title: record.title,

     

       173
       173
       -
                               description: record.description ?? null,

     

       174
       174
       -
                               tag: record.tag ?? null,

     

       175
       175
       -
                               image: findImage(did, pds, record),

     

       176
       176
       -
                               alt: record.alt ?? null,

     

       177
       177
       -
                               createdAt: record.createdAt

     

       178
       178
       -
                           })

     

       179
       179
       -
                           .where('rkey', '=', rev)

     

       180
       180
       -
                           .executeTakeFirstOrThrow()

     

       167
       167
       +
             jetstream.onUpdate('pet.mewsse.link', async (event) => {

     

       168
       168
       +
               if (event.commit.record.$type != "pet.mewsse.link") return

     

       169
       169
       +
       

     

       170
       170
       +
               const rev = event.commit.rev

     

       171
       171
       +
               const record = event.commit.record

     

       172
       172
       +
       

     

       173
       173
       +
               await db

     

       174
       174
       +
                 .updateTable('links')

     

       175
       175
       +
                 .set({

     

       176
       176
       +
                   link: record.link,

     

       177
       177
       +
                   title: record.title,

     

       178
       178
       +
                   description: record.description ?? null,

     

       179
       179
       +
                   image: findImage(did, pds, record),

     

       180
       180
       +
                   alt: record.alt ?? null,

     

       181
       181
       +
                   createdAt: record.createdAt

     

       182
       182
       +
                 })

     

       183
       183
       +
                 .where('rkey', '=', rev)

     

       184
       184
       +
                 .executeTakeFirstOrThrow()

     

       185
       185
       +
       

     

       186
       186
       +
               logger.info(`Record ${rev} updated`)

     

       187
       187
       +
             })

     

       181
       188
        
       

     

       182
       182
       -
                       logger.info(`Record ${rev} updated`)

     

       183
       183
       -
                   })

     

       189
       189
       +
             jetstream.onDelete('pet.mewsse.link', async (event) => {

     

       190
       190
       +
               if (event.commit.collection != "pet.mewsse.link") return

     

       184
       191
        
       

     

       185
       185
       -
                   jetstream.onDelete('pet.mewsse.link', async (event) => {

     

       186
       186
       -
                       if (event.commit.collection != "pet.mewsse.link") return

     

       187
       187
       -
                       

     

       188
       188
       -
                       await db

     

       189
       189
       -
                           .deleteFrom('links')

     

       190
       190
       -
                           .where('rkey', '=', event.commit.rkey)

     

       191
       191
       -
                           .executeTakeFirstOrThrow()

     

       192
       192
       +
               await db

     

       193
       193
       +
                 .deleteFrom('links')

     

       194
       194
       +
                 .where('rkey', '=', event.commit.rkey)

     

       195
       195
       +
                 .executeTakeFirstOrThrow()

     

       192
       196
        
       

     

       193
       193
       -
                       logger.info(`Record ${event.commit.rkey} deleted`)

     

       194
       194
       -
                   })

     

       197
       197
       +
               logger.info(`Record ${event.commit.rkey} deleted`)

     

       198
       198
       +
             })

     

       195
       199
        
       

     

       196
       196
       -
                   return jetstream

     

       197
       197
       -
               }

     

       200
       200
       +
             return jetstream

     

       198
       201
        
           }

     

       202
       202
       +
         }

     

       199
       203
        
       }

+1 -1

src/lexicons/index.ts

···

       1
       1
       -
       export * as PetMewsseLink from "./types/pet/mewsse/link.js"

     

       1
       1
       +
       export * as PetMewsseLink from "./types/pet/mewsse/link.js";

+15 -9

src/lexicons/types/pet/mewsse/link.ts

···

       1
       1
       -
       import type {} from "@atcute/lexicons"

     

       2
       2
       -
       import * as v from "@atcute/lexicons/validations"

     

       3
       3
       -
       import type {} from "@atcute/lexicons/ambient"

     

       1
       1
       +
       import type {} from "@atcute/lexicons";

     

       2
       2
       +
       import * as v from "@atcute/lexicons/validations";

     

       3
       3
       +
       import type {} from "@atcute/lexicons/ambient";

     

       4
       4
        
       

     

       5
       5
        
       const _mainSchema = /*#__PURE__*/ v.record(

     

       6
       6
        
         /*#__PURE__*/ v.tidString(),

     
···

       15
       15
        
               /*#__PURE__*/ v.stringLength(0, 3000),

     

       16
       16
        
             ]),

     

       17
       17
        
           ),

     

       18
       18
       +
           /**

     

       19
       19
       +
            * Do we need to display the link as large content ?

     

       20
       20
       +
            * @default false

     

       21
       21
       +
            */

     

       22
       22
       +
           big: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.boolean(), false),

     

       18
       23
        
           /**

     

       19
       24
        
            * Client-declared timestamp when this post was originally created.

     

       20
       25
        
            */

     
···

       37
       42
        
             /*#__PURE__*/ v.stringLength(0, 3000),

     

       38
       43
        
           ]),

     

       39
       44
        
           /**

     

       40
       40
       -
            * A tag for classify the link.

     

       45
       45
       +
            * Is the link nsfw ?

     

       46
       46
       +
            * @default false

     

       41
       47
        
            */

     

       42
       42
       -
           tag: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),

     

       48
       48
       +
           nsfw: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.boolean(), false),

     

       43
       49
        
           /**

     

       44
       50
        
            * Title of the given link.

     

       45
       51
        
            * @maxLength 3000

     
···

       48
       54
        
             /*#__PURE__*/ v.stringLength(0, 3000),

     

       49
       55
        
           ]),

     

       50
       56
        
         }),

     

       51
       51
       -
       )

     

       57
       57
       +
       );

     

       52
       58
        
       

     

       53
       53
       -
       type main$schematype = typeof _mainSchema

     

       59
       59
       +
       type main$schematype = typeof _mainSchema;

     

       54
       60
        
       

     

       55
       61
        
       export interface mainSchema extends main$schematype {}

     

       56
       62
        
       

     

       57
       57
       -
       export const mainSchema = _mainSchema as mainSchema

     

       63
       63
       +
       export const mainSchema = _mainSchema as mainSchema;

     

       58
       64
        
       

     

       59
       65
        
       export interface Main extends v.InferInput<typeof mainSchema> {}

     

       60
       66
        
       

     

       61
       67
        
       declare module "@atcute/lexicons/ambient" {

     

       62
       68
        
         interface Records {

     

       63
       63
       -
           "pet.mewsse.link": mainSchema

     

       69
       69
       +
           "pet.mewsse.link": mainSchema;

     

       64
       70
        
         }

     

       65
       71
        
       }

+111 -111

src/lib/router.ts

···

       6
       6
        
       import fs from "node:fs"

     

       7
       7
        
       

     

       8
       8
        
       interface Callback {

     

       9
       9
       -
           (req: IncomingMessage, res: ServerResponse,  params?: {[key: string]: string}): void

     

       9
       9
       +
         (req: IncomingMessage, res: ServerResponse, params?: { [key: string]: string }): void

     

       10
       10
        
       }

     

       11
       11
        
       

     

       12
       12
        
       interface Route {

     

       13
       13
       -
           method: string,

     

       14
       14
       -
           path: RegExp,

     

       15
       15
       -
           callback: Callback

     

       13
       13
       +
         method: string,

     

       14
       14
       +
         path: RegExp,

     

       15
       15
       +
         callback: Callback

     

       16
       16
        
       }

     

       17
       17
        
       

     

       18
       18
        
       export class Router {

     

       19
       19
       -
           private routes:Array<Route>

     

       20
       20
       -
           private server:Server<typeof IncomingMessage, typeof ServerResponse> | null

     

       19
       19
       +
         private routes: Array<Route>

     

       20
       20
       +
         private server: Server<typeof IncomingMessage, typeof ServerResponse> | null

     

       21
       21
        
       

     

       22
       22
       -
           readonly ROUTE_MATCHER = /(?:{([a-z0-9-_]+):([a-z]+)})/ig

     

       23
       23
       -
           readonly ROUTE_SUBSTITUTION = "(?<$1>$2)"

     

       24
       24
       -
           readonly PARAM_TYPES: {[key:string]: string} = {

     

       25
       25
       -
               all: "[a-z0-9-_]+",

     

       26
       26
       -
               number: "[0-9]+",

     

       27
       27
       -
               string: "[a-z-_]+"

     

       28
       28
       -
           }

     

       22
       22
       +
         readonly ROUTE_MATCHER = /(?:{([a-z0-9-_]+):([a-z]+)})/ig

     

       23
       23
       +
         readonly ROUTE_SUBSTITUTION = "(?<$1>$2)"

     

       24
       24
       +
         readonly PARAM_TYPES: { [key: string]: string } = {

     

       25
       25
       +
           all: "[a-z0-9-_]+",

     

       26
       26
       +
           number: "[0-9]+",

     

       27
       27
       +
           string: "[a-z-_]+"

     

       28
       28
       +
         }

     

       29
       29
        
       

     

       30
       30
       -
           readonly NON_SAFE_CHARS = /[\x00-\x1F\x20\x7F-\uFFFF]+/g

     

       31
       31
       -
           readonly ASSETS_MATCHER = /^\/assets\/([a-z0-9.-_\/]+)|\/favicon.ico$/g

     

       32
       32
       -
           readonly IGNORE_FILES = [

     

       33
       33
       -
               "assets",

     

       34
       34
       -
               "."

     

       35
       35
       -
           ]

     

       30
       30
       +
         readonly NON_SAFE_CHARS = /[\x00-\x1F\x20\x7F-\uFFFF]+/g

     

       31
       31
       +
         readonly ASSETS_MATCHER = /^\/assets\/([a-z0-9.-_\/]+)|\/favicon.ico$/g

     

       32
       32
       +
         readonly IGNORE_FILES = [

     

       33
       33
       +
           "assets",

     

       34
       34
       +
           "."

     

       35
       35
       +
         ]

     

       36
       36
        
       

     

       37
       37
       -
           constructor() {

     

       38
       38
       -
               this.routes = []

     

       39
       39
       -
               this.server = null

     

       40
       40
       -
           }

     

       37
       37
       +
         constructor() {

     

       38
       38
       +
           this.routes = []

     

       39
       39
       +
           this.server = null

     

       40
       40
       +
         }

     

       41
       41
        
       

     

       42
       42
       -
           route(method:string, path:string, callback:Callback) {

     

       43
       43
       -
               let replacedPath = `^${path.replace(this.ROUTE_MATCHER, this.ROUTE_SUBSTITUTION)}$`

     

       42
       42
       +
         route(method: string, path: string, callback: Callback) {

     

       43
       43
       +
           let replacedPath = `^${path.replace(this.ROUTE_MATCHER, this.ROUTE_SUBSTITUTION)}$`

     

       44
       44
        
       

     

       45
       45
       -
               for (let type in this.PARAM_TYPES) {

     

       46
       46
       -
                   if (replacedPath.includes(type)) {

     

       47
       47
       -
                       replacedPath = replacedPath.replace(type, this.PARAM_TYPES[type])

     

       48
       48
       -
                   }

     

       49
       49
       -
               }

     

       50
       50
       -
       

     

       51
       51
       -
               this.routes.push({

     

       52
       52
       -
                   method: method,

     

       53
       53
       -
                   path: new RegExp(replacedPath, "i"),

     

       54
       54
       -
                   callback

     

       55
       55
       -
               })

     

       45
       45
       +
           for (let type in this.PARAM_TYPES) {

     

       46
       46
       +
             if (replacedPath.includes(type)) {

     

       47
       47
       +
               replacedPath = replacedPath.replace(type, this.PARAM_TYPES[type])

     

       48
       48
       +
             }

     

       56
       49
        
           }

     

       57
       50
        
       

     

       58
       58
       -
           get(path:string, callback:Callback) {

     

       59
       59
       -
               this.route('GET', path, callback)

     

       60
       60
       -
           }

     

       51
       51
       +
           this.routes.push({

     

       52
       52
       +
             method: method,

     

       53
       53
       +
             path: new RegExp(replacedPath, "i"),

     

       54
       54
       +
             callback

     

       55
       55
       +
           })

     

       56
       56
       +
         }

     

       61
       57
        
       

     

       62
       62
       -
           handleHttpRequest() {

     

       63
       63
       -
               return async (req:IncomingMessage, res:ServerResponse) => {

     

       64
       64
       -
                   if (!req.method) {

     

       65
       65
       -
                       res.end('HTTP/1.1 400 Bad Request\r\n\r\n')

     

       66
       66
       -
                       logger.error(`400: ${req.url}`)

     

       67
       67
       -
                   }

     

       58
       58
       +
         get(path: string, callback: Callback) {

     

       59
       59
       +
           this.route('GET', path, callback)

     

       60
       60
       +
         }

     

       68
       61
        
       

     

       69
       69
       -
                   if (

     

       70
       70
       -
                       req.method && 

     

       71
       71
       -
                       req.url && 

     

       72
       72
       -
                       req.url.match(this.ASSETS_MATCHER) &&

     

       73
       73
       -
                       ['GET', 'HEAD'].includes(req.method)

     

       74
       74
       -
                   ) {

     

       75
       75
       -
                       const pathName = String(req.url)

     

       76
       76
       -
                           .replace(this.NON_SAFE_CHARS, encodeURIComponent)

     

       77
       77
       -
                           .split("/")

     

       78
       78
       -
                           .filter((part) => part.length > 0 && !this.IGNORE_FILES.includes(part))

     

       79
       79
       -
                           .join('/')

     

       80
       80
       -
                       const tryFile = path.normalize(path.join(process.cwd(), 'assets', pathName))

     

       62
       62
       +
         handleHttpRequest() {

     

       63
       63
       +
           return async (req: IncomingMessage, res: ServerResponse) => {

     

       64
       64
       +
             if (!req.method) {

     

       65
       65
       +
               res.end('HTTP/1.1 400 Bad Request\r\n\r\n')

     

       66
       66
       +
               logger.error(`400: ${req.url}`)

     

       67
       67
       +
             }

     

       81
       68
        
       

     

       82
       82
       -
                       let stat = null

     

       69
       69
       +
             if (

     

       70
       70
       +
               req.method &&

     

       71
       71
       +
               req.url &&

     

       72
       72
       +
               req.url.match(this.ASSETS_MATCHER) &&

     

       73
       73
       +
               ['GET', 'HEAD'].includes(req.method)

     

       74
       74
       +
             ) {

     

       75
       75
       +
               const pathName = String(req.url)

     

       76
       76
       +
                 .replace(this.NON_SAFE_CHARS, encodeURIComponent)

     

       77
       77
       +
                 .split("/")

     

       78
       78
       +
                 .filter((part) => part.length > 0 && !this.IGNORE_FILES.includes(part))

     

       79
       79
       +
                 .join('/')

     

       80
       80
       +
               const tryFile = path.normalize(path.join(process.cwd(), 'assets', pathName))

     

       83
       81
        
       

     

       84
       84
       -
                       try {

     

       85
       85
       -
                           stat = await fs.promises.stat(tryFile)

     

       82
       82
       +
               let stat = null

     

       86
       83
        
       

     

       87
       87
       -
                           if (!stat.isFile()) {

     

       88
       88
       -
                               throw new Error("Not a file")

     

       89
       89
       -
                           }

     

       90
       90
       -
                       } catch (error) {

     

       91
       91
       -
                           logger.error(error)

     

       92
       92
       -
                           res.end('HTTP/1.1 404 Not Found\r\n\r\n')

     

       93
       93
       -
                           return

     

       94
       94
       -
                       }

     

       84
       84
       +
               try {

     

       85
       85
       +
                 stat = await fs.promises.stat(tryFile)

     

       95
       86
        
       

     

       96
       96
       -
                       const ext = path.extname(tryFile)

     

       97
       97
       -
                       const type = mime.getType(ext) || 'application/octet-stream'

     

       87
       87
       +
                 if (!stat.isFile()) {

     

       88
       88
       +
                   throw new Error("Not a file")

     

       89
       89
       +
                 }

     

       90
       90
       +
               } catch (error) {

     

       91
       91
       +
                 logger.error(error)

     

       92
       92
       +
                 res.end('HTTP/1.1 404 Not Found\r\n\r\n')

     

       93
       93
       +
                 return

     

       94
       94
       +
               }

     

       98
       95
        
       

     

       99
       99
       -
                       res.setHeader('Content-Type', type)

     

       100
       100
       -
                       res.setHeader('Content-Length', stat.size)

     

       101
       101
       -
                       res.setHeader('Etag', `${stat.size.toString(16)}-${stat.mtime.getTime().toString(16)}`)

     

       102
       102
       -
                       res.setHeader('Last-Modified', stat.mtime.toUTCString())

     

       103
       103
       -
                       logger.info(`${req.method} ${req.url}`)

     

       96
       96
       +
               const ext = path.extname(tryFile)

     

       97
       97
       +
               const type = mime.getType(ext) || 'application/octet-stream'

     

       104
       98
        
       

     

       105
       105
       -
                       if (req.method === "HEAD") {

     

       106
       106
       -
                           res.end()

     

       107
       107
       -
                           return

     

       108
       108
       -
                       }

     

       99
       99
       +
               res.setHeader('Content-Type', type)

     

       100
       100
       +
               res.setHeader('Content-Length', stat.size)

     

       101
       101
       +
               res.setHeader('Etag', `${stat.size.toString(16)}-${stat.mtime.getTime().toString(16)}`)

     

       102
       102
       +
               res.setHeader('Last-Modified', stat.mtime.toUTCString())

     

       103
       103
       +
               logger.info(`${req.method} ${req.url}`)

     

       109
       104
        
       

     

       110
       110
       -
                       const stream = fs.createReadStream(tryFile)

     

       111
       111
       -
                       stream.pipe(res)

     

       112
       112
       -
                       

     

       113
       113
       -
                       stream.on('error', (err) => {

     

       114
       114
       -
                           logger.error(err)

     

       115
       115
       -
                           stream.destroy()

     

       116
       116
       -
                       })

     

       105
       105
       +
               if (req.method === "HEAD") {

     

       106
       106
       +
                 res.end()

     

       107
       107
       +
                 return

     

       108
       108
       +
               }

     

       109
       109
       +
       

     

       110
       110
       +
               const stream = fs.createReadStream(tryFile)

     

       111
       111
       +
               stream.pipe(res)

     

       112
       112
       +
       

     

       113
       113
       +
               stream.on('error', (err) => {

     

       114
       114
       +
                 logger.error(err)

     

       115
       115
       +
                 stream.destroy()

     

       116
       116
       +
               })

     

       117
       117
        
       

     

       118
       118
       -
                       stream.on('end', () => {

     

       119
       119
       -
                           res.end()

     

       120
       120
       -
                       })

     

       118
       118
       +
               stream.on('end', () => {

     

       119
       119
       +
                 res.end()

     

       120
       120
       +
               })

     

       121
       121
        
       

     

       122
       122
       -
                       return

     

       123
       123
       -
                   }

     

       122
       122
       +
               return

     

       123
       123
       +
             }

     

       124
       124
        
       

     

       125
       125
       -
                   for (let route of this.routes) {

     

       126
       126
       -
                       let match = req.url?.match(route.path)

     

       125
       125
       +
             for await (let route of this.routes) {

     

       126
       126
       +
               let match = req.url?.match(route.path)

     

       127
       127
        
       

     

       128
       128
       -
                       if (route.method != req.method || !match) continue

     

       128
       128
       +
               if (route.method != req.method || !match) continue

     

       129
       129
        
       

     

       130
       130
       -
                       logger.info(`${req.method} ${req.url}`)

     

       131
       131
       -
                       route.callback(req, res, match.groups)

     

       132
       132
       -
                       return

     

       133
       133
       -
                   }

     

       130
       130
       +
               logger.info(`${req.method} ${req.url}`)

     

       131
       131
       +
               await route.callback(req, res, match.groups)

     

       132
       132
       +
               return

     

       133
       133
       +
             }

     

       134
       134
        
       

     

       135
       135
       -
                   res.end('HTTP/1.1 404 Not Found\r\n\r\n')

     

       136
       136
       -
                   logger.error(`404: ${req.method} ${req.url}`)

     

       137
       137
       -
               }

     

       135
       135
       +
             res.end('HTTP/1.1 404 Not Found\r\n\r\n')

     

       136
       136
       +
             logger.error(`404: ${req.method} ${req.url}`)

     

       138
       137
        
           }

     

       138
       138
       +
         }

     

       139
       139
        
       

     

       140
       140
       -
           start(port:string) {

     

       141
       141
       -
               this.server = createServer(this.handleHttpRequest())

     

       140
       140
       +
         start(port: string) {

     

       141
       141
       +
           this.server = createServer(this.handleHttpRequest())

     

       142
       142
        
       

     

       143
       143
       -
               this.server.on('clientError', (err, socket) => {

     

       144
       144
       -
                   socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')

     

       145
       145
       -
               })

     

       143
       143
       +
           this.server.on('clientError', (err, socket) => {

     

       144
       144
       +
             socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')

     

       145
       145
       +
           })

     

       146
       146
        
       

     

       147
       147
       -
               this.server.listen(port)

     

       148
       148
       -
           }

     

       147
       147
       +
           this.server.listen(port)

     

       148
       148
       +
         }

     

       149
       149
        
       

     

       150
       150
       -
           async close() {

     

       151
       151
       -
               this.server?.close()

     

       152
       152
       -
           }

     

       150
       150
       +
         async close() {

     

       151
       151
       +
           this.server?.close()

     

       152
       152
       +
         }

     

       153
       153
        
       }

+18 -10

src/routes.ts

···

       2
       2
        
       import path from "node:path"

     

       3
       3
        
       import { Eta } from "eta"

     

       4
       4
        
       

     

       5
       5
       -
       export const createRoutes = (router:Router) => {

     

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

     

       5
       5
       +
       import type { Database } from './db.ts'

     

       7
       6
        
       

     

       8
       8
       -
           router.get('/', (req, res) => {

     

       9
       9
       -
               const body = eta.render("./main", { items: [], pages: []})

     

       7
       7
       +
       export const createRoutes = (router: Router, db: Database) => {

     

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

     

       10
       9
        
       

     

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

     

       12
       12
       -
               res.end(body)

     

       13
       13
       -
           })

     

       10
       10
       +
         router.get('/', async (req, res) => {

     

       11
       11
       +
           const links = await db

     

       12
       12
       +
             .selectFrom("links")

     

       13
       13
       +
             .selectAll()

     

       14
       14
       +
             .orderBy("createdAt", "desc")

     

       15
       15
       +
             .limit(10)

     

       16
       16
       +
             .execute()

     

       17
       17
       +
           const body = eta.render("./main", { items: links, pages: [] })

     

       14
       18
        
       

     

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

     

       16
       16
       -
               res.end()

     

       17
       17
       -
           })

     

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

     

       20
       20
       +
           res.end(body)

     

       21
       21
       +
         })

     

       22
       22
       +
       

     

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

     

       24
       24
       +
           res.end()

     

       25
       25
       +
         })

     

       18
       26
        
       }

+37 -37

src/views/main.eta

···

       1
       1
        
       <!DOCTYPE html>

     

       2
       2
        
       <html lang="en">

     

       3
       3
        
       <head>

     

       4
       4
       -
           <meta charset="UTF-8">

     

       5
       5
       -
           <meta name="robots" content="noindex">

     

       6
       6
       -
           <meta name="viewport" content="width=device-width, initial-scale=1.0">

     

       7
       7
       -
           <title>Mewsse's links<% if (it.selected > 0) { %> - page <%= it.selected + 1 %><% } %></title>

     

       8
       8
       -
           <link rel="stylesheet" href="/assets/style.css">

     

       9
       9
       -
           <link rel="icon" type="image/png" href="/assets/favicon.png">

     

       10
       10
       -
           <link rel="alternate" title="All links" type="application/atom+xml" href="/feed.atom">

     

       11
       11
       -
           <meta property="og:title" content="Mewsse's links">

     

       12
       12
       -
           <meta property="og:description" content="A collection of links I like or want to save for later.">

     

       13
       13
       -
           <meta property="og:type" content="website">

     

       14
       14
       -
           <meta property="og:url" content="https://mewsse.gay/">

     

       15
       15
       -
           <meta property="og:image" content="https://mewsse.gay/network.webp">

     

       4
       4
       +
         <meta charset="UTF-8">

     

       5
       5
       +
         <meta name="robots" content="noindex">

     

       6
       6
       +
         <meta name="viewport" content="width=device-width, initial-scale=1.0">

     

       7
       7
       +
         <title>Mewsse's links<% if (it.selected > 0) { %> - page <%= it.selected + 1 %><% } %></title>

     

       8
       8
       +
         <link rel="stylesheet" href="/assets/style.css">

     

       9
       9
       +
         <link rel="icon" type="image/png" href="/assets/favicon.png">

     

       10
       10
       +
         <link rel="alternate" title="All links" type="application/atom+xml" href="/feed.atom">

     

       11
       11
       +
         <meta property="og:title" content="Mewsse's links">

     

       12
       12
       +
         <meta property="og:description" content="A collection of links I like or want to save for later.">

     

       13
       13
       +
         <meta property="og:type" content="website">

     

       14
       14
       +
         <meta property="og:url" content="https://mewsse.gay/">

     

       15
       15
       +
         <meta property="og:image" content="https://mewsse.gay/network.webp">

     

       16
       16
        
       </head>

     

       17
       17
        
       <body>

     

       18
       18
       -
           <header>

     

       19
       19
       -
               <h1>🏳️‍🌈 Mewsse's links</h1>

     

       20
       20
       -
               <p>

     

       21
       21
       -
               A collection of links I like or want to save for later.

     

       22
       22
       -
               <a href="/feed.atom" class="atom">

     

       23
       23
       -
                   <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512">

     

       24
       24
       -
                   <path d="M0 64C0 46.3 14.3 32 32 32c229.8 0 416 186.2 416 416c0 17.7-14.3 32-32 32s-32-14.3-32-32C384 253.6 226.4 96 32 96C14.3 96 0 81.7 0 64zM0 416a64 64 0 1 1 128 0A64 64 0 1 1 0 416zM32 160c159.1 0 288 128.9 288 288c0 17.7-14.3 32-32 32s-32-14.3-32-32c0-123.7-100.3-224-224-224c-17.7 0-32-14.3-32-32s14.3-32 32-32z"/>

     

       25
       25
       -
                   </svg>

     

       26
       26
       -
               </a>

     

       27
       27
       -
               <br>

     

       28
       28
       -
               <small>You can find more infos about me on my <a href="https://mewsse.pet">website</a></small>

     

       29
       29
       -
               </p>

     

       30
       30
       -
               <p class="small">Yeah it can be NSFW, but it's blured.</p>

     

       31
       31
       -
           </header>

     

       18
       18
       +
         <header>

     

       19
       19
       +
           <h1>🏳️‍🌈 Mewsse's links</h1>

     

       20
       20
       +
           <p>

     

       21
       21
       +
           A collection of links I like or want to save for later.

     

       22
       22
       +
           <a href="/feed.atom" class="atom">

     

       23
       23
       +
             <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512">

     

       24
       24
       +
               <path d="M0 64C0 46.3 14.3 32 32 32c229.8 0 416 186.2 416 416c0 17.7-14.3 32-32 32s-32-14.3-32-32C384 253.6 226.4 96 32 96C14.3 96 0 81.7 0 64zM0 416a64 64 0 1 1 128 0A64 64 0 1 1 0 416zM32 160c159.1 0 288 128.9 288 288c0 17.7-14.3 32-32 32s-32-14.3-32-32c0-123.7-100.3-224-224-224c-17.7 0-32-14.3-32-32s14.3-32 32-32z"/>

     

       25
       25
       +
             </svg>

     

       26
       26
       +
           </a>

     

       27
       27
       +
           <br>

     

       28
       28
       +
           <small>You can find more infos about me on my <a href="https://mewsse.pet">website</a></small>

     

       29
       29
       +
           </p>

     

       30
       30
       +
           <p class="small">Yeah it can be NSFW, but it's blured.</p>

     

       31
       31
       +
         </header>

     

       32
       32
       +
       

     

       33
       33
       +
         <div class="links">

     

       34
       34
       +
           <% it.items.forEach(function (item) { %>

     

       35
       35
       +
           <%~ include("link", item) %>

     

       36
       36
       +
           <% }) %>

     

       37
       37
       +
         </div>

     

       32
       38
        
       

     

       33
       33
       -
           <div class="links">

     

       34
       34
       -
               <% it.items.forEach(function (item) { %>

     

       35
       35
       -
               <%~ include("link", item) %>

     

       36
       36
       -
               <% }) %>

     

       39
       39
       +
         <% if(it.pages.length > 1) { %>

     

       40
       40
       +
           <div class="pagination">

     

       41
       41
       +
           <%~ include("pagination", { pages: it.pages, selected: it.selected }) %>

     

       37
       42
        
           </div>

     

       38
       38
       -
       

     

       39
       39
       -
           <% if(it.pages.length > 1) { %>

     

       40
       40
       -
               <div class="pagination">

     

       41
       41
       -
               <%~ include("pagination", { pages: it.pages, selected: it.selected }) %>

     

       42
       42
       -
               </div>

     

       43
       43
       -
           <% } %>

     

       44
       44
       -
           </body>

     

       43
       43
       +
         <% } %>

     

       44
       44
       +
         </body>

     

       45
       45
        
       </html>