commit c02ae8a04f5acd40a3df1af6dea0551c658580bc · cduck.me/statusphere-example-app-fork

+2 -2

src/env.ts

···

       1
        
       import dotenv from 'dotenv'

     

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

     

       3
       -
       import { privateKeys } from '#/lib/envalid-private-keys'

     

       4
        
       

     

       5
        
       dotenv.config()

     

       6
        
       

     
···

       13
        
         PUBLIC_URL: str({}),

     

       14
        
         DB_PATH: str({ devDefault: ':memory:' }),

     

       15
        
         COOKIE_SECRET: str({ devDefault: '00000000000000000000000000000000' }),

     

       16
       -
         PRIVATE_JWKS: privateKeys({ default: undefined }),

     

       17
        
       })

···

       1
        
       import dotenv from 'dotenv'

     

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

     

       3
       +
       import { envalidJsonWebKeys } from '#/lib/jwk'

     

       4
        
       

     

       5
        
       dotenv.config()

     

       6
        
       

     
···

       13
        
         PUBLIC_URL: str({}),

     

       14
        
         DB_PATH: str({ devDefault: ':memory:' }),

     

       15
        
         COOKIE_SECRET: str({ devDefault: '00000000000000000000000000000000' }),

     

       16
       +
         PRIVATE_JWKS: envalidJsonWebKeys({ default: undefined }),

     

       17
        
       })

-17

src/lib/envalid-private-keys.ts

···

       1
       -
       import { Jwk, jwkValidator } from '@atproto/oauth-client-node'

     

       2
       -
       import { makeValidator } from 'envalid'

     

       3
       -
       import { z } from 'zod'

     

       4
       -
       

     

       5
       -
       export type PrivateKey = Jwk & { kid: string }

     

       6
       -
       

     

       7
       -
       const privateKeySchema = z.intersection(

     

       8
       -
         jwkValidator,

     

       9
       -
         z.object({ kid: z.string().nonempty() }),

     

       10
       -
       ) satisfies z.ZodType<PrivateKey>

     

       11
       -
       

     

       12
       -
       const privateKeysSchema = z.array(privateKeySchema).nonempty()

     

       13
       -
       

     

       14
       -
       export const privateKeys = makeValidator((input) => {

     

       15
       -
         const value = JSON.parse(input)

     

       16
       -
         return privateKeysSchema.parse(value)

     

       17
       -
       })

+10 -2

src/lib/http.ts

···

       19
        
         Res extends ServerResponse<Req> = ServerResponse<Req>,

     

       20
        
       > = (req: Req, res: Res, next: NextFunction) => Promise<void>

     

       21
        
       

     

       22
       -
       // Helper function for defining routes

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       23
        
       export function handler<

     

       24
        
         Req extends IncomingMessage = IncomingMessage,

     

       25
        
         Res extends ServerResponse<Req> = ServerResponse<Req>,

     

       26
        
       >(fn: Handler<Req, Res> | AsyncHandler<Req, Res>): Handler<Req, Res> {

     

       27
        
         return (req, res, next) => {

     

       28
       -
           // NodeJS prefers objects over functions for garbage collection,

     

       29
        
           const nextSafe = nextOnce.bind({ next })

     

       30
        
           try {

     

       31
        
             const result = fn(req, res, nextSafe)

     
···

       42
        
         }

     

       43
        
       }

     

       44
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       45
        
       export async function startServer(

     

       46
        
         requestListener: RequestListener,

     

       47
        
         {

···

       19
        
         Res extends ServerResponse<Req> = ServerResponse<Req>,

     

       20
        
       > = (req: Req, res: Res, next: NextFunction) => Promise<void>

     

       21
        
       

     

       22
       +
       /**

     

       23
       +
        * Wraps a request handler middleware to ensure that `next` is called if it

     

       24
       +
        * throws or returns a promise that rejects.

     

       25
       +
        */

     

       26
        
       export function handler<

     

       27
        
         Req extends IncomingMessage = IncomingMessage,

     

       28
        
         Res extends ServerResponse<Req> = ServerResponse<Req>,

     

       29
        
       >(fn: Handler<Req, Res> | AsyncHandler<Req, Res>): Handler<Req, Res> {

     

       30
        
         return (req, res, next) => {

     

       31
       +
           // Optimization: NodeJS prefers objects over functions for garbage collection

     

       32
        
           const nextSafe = nextOnce.bind({ next })

     

       33
        
           try {

     

       34
        
             const result = fn(req, res, nextSafe)

     
···

       45
        
         }

     

       46
        
       }

     

       47
        
       

     

       48
       +
       /**

     

       49
       +
        * Create an HTTP server with the provided request listener, ensuring that it

     

       50
       +
        * can bind the listening port, and returns a termination function that allows

     

       51
       +
        * graceful termination of HTTP connections.

     

       52
       +
        */

     

       53
        
       export async function startServer(

     

       54
        
         requestListener: RequestListener,

     

       55
        
         {

+17

src/lib/jwk.ts

···

       1
       +
       import { Jwk, jwkValidator } from '@atproto/oauth-client-node'

     

       2
       +
       import { makeValidator } from 'envalid'

     

       3
       +
       import { z } from 'zod'

     

       4
       +
       

     

       5
       +
       export type JsonWebKey = Jwk & { kid: string }

     

       6
       +
       

     

       7
       +
       const jsonWebKeySchema = z.intersection(

     

       8
       +
         jwkValidator,

     

       9
       +
         z.object({ kid: z.string().nonempty() }),

     

       10
       +
       ) satisfies z.ZodType<JsonWebKey>

     

       11
       +
       

     

       12
       +
       const jsonWebKeysSchema = z.array(jsonWebKeySchema).nonempty()

     

       13
       +
       

     

       14
       +
       export const envalidJsonWebKeys = makeValidator((input) => {

     

       15
       +
         const value = JSON.parse(input)

     

       16
       +
         return jsonWebKeysSchema.parse(value)

     

       17
       +
       })

+5 -1

src/lib/process.ts

···

       1
        
       const SIGNALS = ['SIGINT', 'SIGTERM'] as const

     

       2
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3
        
       export async function run<F extends (signal: AbortSignal) => unknown>(

     

       4
       -
         fn: F

     

       5
        
       ): Promise<Awaited<ReturnType<F>>> {

     

       6
        
         const killController = new AbortController()

     

       7

···

       1
        
       const SIGNALS = ['SIGINT', 'SIGTERM'] as const

     

       2
        
       

     

       3
       +
       /**

     

       4
       +
        * Runs a function with an abort signal that will be triggered when the process

     

       5
       +
        * receives a termination signal.

     

       6
       +
        */

     

       7
        
       export async function run<F extends (signal: AbortSignal) => unknown>(

     

       8
       +
         fn: F,

     

       9
        
       ): Promise<Awaited<ReturnType<F>>> {

     

       10
        
         const killController = new AbortController()

     

       11