sleepy-serv 0.23.0 → 0.25.0

package/src/core/index.ts

@@ -31,26 +31,26 @@ import type {
   Middleware,
   MiddlewareChain,
   EndpointRequest,
-  MetaEntry,
-  RouteConfig,
-  RouteDefinition,
-  SocketCommands,
-  SocketOptions,
-  AppOptions,
+  Handler,
   Server,
 } from './utils'
 
+import type { SocketCommands } from './utils'
+
 import type {
+  SocketOptions,
   SocketRoute,
   SocketState,
 } from './socket'
 
 export * from './errors'
+export { ServerCloseSignals } from './socket'
 
 export {
   StatusCode,
   HttpMethod,
-  InternalCloseSignal,
+  SessionType,
+  SessionFilter,
 } from './utils'
 
 export {
@@ -59,27 +59,31 @@ export {
   validateSchemas,
 } from './middleware'
 
-export type { FilterFn, SessionEntry, SocketCommands } from './utils'
+export type {
+  ActiveSession,
+  ActiveSessions,
+  InactiveSession,
+  SocketConnection,
+  SocketOptions,
+} from './socket'
 
 export type {
-  AppOptions,
   AsyncHandlerResult,
   BaseRequest,
   CloseSignal,
   EndpointRequest,
+  FilterFn,
   FormattedError,
   Handler,
-  MetaEntry,
+  HandlerResult,
   Middleware,
   MiddlewareChain,
   NextFn,
-  HandlerResult,
   Request,
-  RouteConfig,
-  RouteDefinition,
   Server,
-  SocketConnection,
-  SocketOptions,
+  SessionEntry,
+  SocketCommands,
+  SocketData,
   WebSocketRequest,
 } from './utils'
 
@@ -89,38 +93,64 @@ export type {
   ValidationSchemas,
 } from './middleware'
 
+export type RouteDefinition<T = void> = {
+  method: HttpMethod
+  path: string
+  chain: Handler<T> | MiddlewareChain<T>
+}
+
+export type MetaEntry<T = void> = {
+  path: string
+  middleware: Middleware<T>[]
+}
+
+export type RouteConfig<T = void> = {
+  routes: RouteDefinition<T>[]
+  meta?: MetaEntry<T>[]
+}
+
+export type AppOptions<T = void> = {
+  hostname?: string
+  mountPath?: string
+  middleware?: Middleware<T>[]
+  ws?: boolean | SocketOptions
+  onClose?: () => Promise<void> | void
+}
+
 type OutputRoutes = Record<string, string[]>
-type ServerRoutes = Record<string, Record<string, EndpointHandler>>
 
-type EndpointHandler = (
+type ServerRoutes<T = void> =
+  Record<string, Record<string, EndpointHandler<T>>>
+
+type EndpointHandler<T = void> = (
   bunReq: BunRequest,
-  server: Server,
+  server: Server<T>,
 ) => AsyncHandlerResult
 
-type ChainRoute = {
+type ChainRoute<T = void> = {
   method: HttpMethod
   path: string
-  chain: MiddlewareChain
+  chain: MiddlewareChain<T>
 }
 
-type ModuleRoute = {
+type ModuleRoute<T = void> = {
   method: HttpMethod
   path: string
-  handler: EndpointHandler
+  handler: EndpointHandler<T>
 }
 
-type AppRoutes = {
-  server: ServerRoutes
+type AppRoutes<T = void> = {
+  server: ServerRoutes<T>
   output: OutputRoutes
-  socket: SocketRoute[]
+  socket: SocketRoute<T>[]
 }
 
 type CloseFn = (force?: boolean) => Promise<void>
 
-export type App = {
-  server: Server
+export type App<T = void> = {
+  server: Server<T>
   routes: OutputRoutes
-  ws: SocketCommands
+  ws: SocketCommands<T>
   close: CloseFn
 }
 
@@ -128,7 +158,7 @@ function methodNotAllowedHandler (_req: unknown): never {
   throw new MethodNotAllowedError()
 }
 
-function defaultMethodMap (): Record<string, EndpointHandler> {
+function defaultMethodMap<T> (): Record<string, EndpointHandler<T>> {
   return {
     HEAD: methodNotAllowedHandler,
     GET: methodNotAllowedHandler,
@@ -153,11 +183,11 @@ function resolveSocketOptions (
   return ws
 }
 
-function buildEndpointRequest (
+function buildEndpointRequest<T> (
   bunReq: BunRequest,
-  server: Server,
-  ws: SocketCommands,
-): EndpointRequest {
+  server: Server<T>,
+  ws: SocketCommands<T>,
+): EndpointRequest<T> {
   const url = new URL(bunReq.url)
   const qs = url.search.replace('?', '')
 
@@ -184,7 +214,7 @@ function buildEndpointRequest (
   }
 }
 
-function normalizeChain (route: RouteDefinition): ChainRoute {
+function normalizeChain<T> (route: RouteDefinition<T>): ChainRoute<T> {
   const chain = Array.isArray(route.chain)
     ? route.chain
     : [route.chain]
@@ -196,13 +226,13 @@ function normalizeChain (route: RouteDefinition): ChainRoute {
   }
 }
 
-function buildMergedRoutes (
-  routePaths: ChainRoute[],
-  middleware: Middleware[],
-  meta: MetaEntry[],
-  state: SocketState,
+function buildMergedRoutes<T> (
+  routePaths: ChainRoute<T>[],
+  middleware: Middleware<T>[],
+  meta: MetaEntry<T>[],
+  state: SocketState<T>,
   mountPath: string,
-): ChainRoute[] {
+): ChainRoute<T>[] {
   const socketRoutes = buildSocketHandlers(state)
 
   for (const socketRoute of socketRoutes) {
@@ -238,19 +268,21 @@ function buildMergedRoutes (
   return routePaths
 }
 
-function buildSocketRoutes (mergedRoutes: ChainRoute[]): SocketRoute[] {
+function buildSocketRoutes<T> (
+  mergedRoutes: ChainRoute<T>[],
+): SocketRoute<T>[] {
   return mergedRoutes.map(route => ({
     ...route,
     segments: toSegments(route.path),
   }))
 }
 
-function buildModuleRoutes (
-  socketRoutes: SocketRoute[],
-  ws: SocketCommands,
-): ModuleRoute[] {
+function buildModuleRoutes<T> (
+  socketRoutes: SocketRoute<T>[],
+  ws: SocketCommands<T>,
+): ModuleRoute<T>[] {
   return socketRoutes.map(route => {
-    const handler: EndpointHandler = async (bunReq, server) => {
+    const handler: EndpointHandler<T> = async (bunReq, server) => {
       const req = buildEndpointRequest(bunReq, server, ws)
 
       return executeMiddlewareChain(req, route.chain)
@@ -264,11 +296,13 @@ function buildModuleRoutes (
   })
 }
 
-function buildServerRoutes (moduleRoutes: ModuleRoute[]): ServerRoutes {
-  return moduleRoutes.reduce<ServerRoutes>(
+function buildServerRoutes<T> (
+  moduleRoutes: ModuleRoute<T>[],
+): ServerRoutes<T> {
+  return moduleRoutes.reduce<ServerRoutes<T>>(
     (accum, curr) => {
       if (!accum[curr.path]) {
-        accum[curr.path] = defaultMethodMap()
+        accum[curr.path] = defaultMethodMap<T>()
       }
 
       accum[curr.path][curr.method] = curr.handler
@@ -277,7 +311,7 @@ function buildServerRoutes (moduleRoutes: ModuleRoute[]): ServerRoutes {
     }, {})
 }
 
-function buildOutputRoutes (moduleRoutes: ModuleRoute[]): OutputRoutes {
+function buildOutputRoutes<T> (moduleRoutes: ModuleRoute<T>[]): OutputRoutes {
   return moduleRoutes.reduce<OutputRoutes>((accum, curr) => {
     accum[curr.path] = accum[curr.path] || []
     accum[curr.path].push(curr.method)
@@ -286,12 +320,12 @@ function buildOutputRoutes (moduleRoutes: ModuleRoute[]): OutputRoutes {
   }, {})
 }
 
-function buildRoutes (
-  config: RouteConfig,
-  state: SocketState | null,
-  ws: SocketCommands,
-  opts: AppOptions,
-): AppRoutes {
+function buildRoutes<T> (
+  config: RouteConfig<T>,
+  state: SocketState<T> | null,
+  ws: SocketCommands<T>,
+  opts: AppOptions<T>,
+): AppRoutes<T> {
   const mountPath = opts.mountPath || ''
   const middleware = opts.middleware || []
   const meta = config.meta || []
@@ -330,13 +364,13 @@ function buildRoutes (
   }
 }
 
-function buildServer (
+function buildServer<T> (
   port: number,
-  routes: AppRoutes,
-  state: SocketState | null,
-  ws: SocketCommands,
-  opts: AppOptions,
-): Server {
+  routes: AppRoutes<T>,
+  state: SocketState<T> | null,
+  ws: SocketCommands<T>,
+  opts: AppOptions<T>,
+): Server<T> {
   const hostname = opts.hostname || '0.0.0.0'
 
   const websocket = state
@@ -360,10 +394,10 @@ function buildServer (
 
       return Response.json(httpError.output, { status })
     },
-  }) as Server
+  }) as Server<T>
 }
 
-function processIO (server: Server, opts: AppOptions): CloseFn {
+function processIO<T> (server: Server<T>, opts: AppOptions<T>): CloseFn {
   const onClose = opts.onClose || (() => {})
 
   console.info(`Running on port: ${server.port}`)
@@ -400,20 +434,20 @@ function processIO (server: Server, opts: AppOptions): CloseFn {
   }
 }
 
-export function createApp (
+export function createApp<T = void> (
   port: number,
-  config: RouteConfig,
-  opts: AppOptions = {},
-): App {
+  config: RouteConfig<T>,
+  opts: AppOptions<T> = {},
+): App<T> {
   const socketOpts = resolveSocketOptions(opts.ws)
 
   const state = socketOpts
-    ? buildSocketState(socketOpts)
+    ? buildSocketState<T>(socketOpts)
     : null
 
   const ws = state
-    ? buildSocketCommands(state)
-    : buildDisabledSocketCommands()
+    ? buildSocketCommands<T>(state)
+    : buildDisabledSocketCommands<T>()
 
   const routes = buildRoutes(config, state, ws, opts)
   const server = buildServer(port, routes, state, ws, opts)

package/src/core/middleware.ts

@@ -39,7 +39,7 @@ export type SchemaKey = keyof ValidationSchemas
 let _schemasCompiled = false
 let _customFormats: Record<string, Format> | null = null
 
-async function parseBody (req: Request): Promise<unknown> {
+async function parseBody<T> (req: Request<T>): Promise<unknown> {
   try {
     const result = await req.json()
 
@@ -117,9 +117,9 @@ function compileSchemas (
     })
 }
 
-export function parseJsonBody (): Middleware {
+export function parseJsonBody<T = void> (): Middleware<T> {
   return async (
-    req: Request,
+    req: Request<T>,
     res: unknown,
     next: NextFn,
   ): AsyncHandlerResult => {
@@ -158,8 +158,8 @@ export function resetValidationFormatsState (): void {
   _schemasCompiled = false
 }
 
-function buildValidationSource (
-  req: Request,
+function buildValidationSource<T> (
+  req: Request<T>,
   res: unknown,
 ): Record<SchemaKey, unknown> {
   return {
@@ -170,13 +170,15 @@ function buildValidationSource (
   }
 }
 
-export function validateSchemas (schemas: ValidationSchemas): Middleware {
+export function validateSchemas<T = void> (
+  schemas: ValidationSchemas,
+): Middleware<T> {
   const entries = compileSchemas(schemas)
 
   _schemasCompiled = true
 
   return (
-    req: Request,
+    req: Request<T>,
     res: unknown,
     next: NextFn,
   ): HandlerResult => {