sleepy-serv 0.23.0 → 0.25.0

package/src/core/utils.ts

@@ -1,6 +1,8 @@
 import type { ErrorObject } from 'ajv'
 import type { BunRequest, Server as BunServer } from 'bun'
 
+export type TimeoutHandle = ReturnType<typeof setTimeout>
+
 export const HttpMethod = {
   Head: 'HEAD',
   Get: 'GET',
@@ -94,142 +96,88 @@ export type AsyncHandlerResult = Promise<Response>
 export type HandlerResult = Response | AsyncHandlerResult
 export type NextFn = (data?: unknown) => HandlerResult
 
-export type Middleware = (
-  req: Request,
+export type Middleware<T = void> = (
+  req: Request<T>,
   res: unknown,
   next: NextFn,
 ) => HandlerResult
 
-export type Handler = (
-  req: Request,
+export type Handler<T = void> = (
+  req: Request<T>,
   res: unknown,
 ) => HandlerResult
 
-export type MiddlewareChain = (Middleware | Handler)[]
+export type MiddlewareChain<T = void> = (Middleware<T> | Handler<T>)[]
 
-export type ActiveSession = {
-  token: string
-  ws: SocketConnection
+export type CloseSignal = {
+  code: number
+  reason: string
 }
 
-export type InactiveSession = {
-  token: string
-  expiresAt: number
-  app: unknown
+export type SocketData<T = void> = {
+  clientId: string
+  superseded: boolean
+  reaped: boolean
+  reaperHandle: TimeoutHandle | null
+  data: T
 }
 
-export type ActiveSessions = ReadonlyMap<string, ActiveSession>
-export type Session = ActiveSession | InactiveSession
+export const SessionType = {
+  Active: 'active',
+  Inactive: 'inactive',
+} as const
+
+export type SessionType = typeof SessionType[keyof typeof SessionType]
+
+export const SessionFilter = {
+  Active: 'active',
+  Inactive: 'inactive',
+  All: 'all',
+} as const
+
+export type SessionFilter = typeof SessionFilter[keyof typeof SessionFilter]
 
-export type SessionEntry = {
+export type SessionEntry<T = void> = {
   clientId: string
-  app: unknown
+  type: SessionType
+  data: T
 }
 
-export type FilterFn = (
-  clientId: string,
-  data: unknown,
+export type FilterFn<T = void> = (
+  session: SessionEntry<T>,
   index: number,
 ) => boolean
 
-export type SocketCommands = {
+export type SocketCommands<T = void> = {
   broadcast: (event: string, body: unknown) => void
-  send: (event: string, body: unknown, fn: FilterFn) => void
-  drop: (signal: CloseSignal, fn: FilterFn) => void
-  query: (fn: FilterFn) => SessionEntry[]
+  send: (event: string, body: unknown, fn: FilterFn<T>) => void
+  drop: (signal: CloseSignal, fn: FilterFn<T>) => void
+  query: (fn: FilterFn<T>, filter?: SessionFilter) => SessionEntry<T>[]
 }
 
-export type BaseRequest = {
+export type BaseRequest<T = void> = {
   method: HttpMethod
   route: string
   headers: Headers
   params: Record<string, string>
   query: Record<string, unknown>
   json: () => Promise<unknown>
-  ws: SocketCommands
+  ws: SocketCommands<T>
 }
 
-export type EndpointRequest = BaseRequest & {
+export type EndpointRequest<T = void> = BaseRequest<T> & {
   raw: BunRequest
-  server: Server
+  server: Server<T>
 }
 
-export type WebSocketRequest = BaseRequest & {
+export type WebSocketRequest<T = void> = BaseRequest<T> & {
   id: string
   clientId: string
 }
 
-export type Request = EndpointRequest | WebSocketRequest
-
-export type CloseSignal = {
-  code: number
-  reason: string
-}
-
-export const InternalCloseSignal = {
-  Ok: {
-    code: 1000,
-    reason: 'ok',
-  },
-  Reaped: {
-    code: 4998,
-    reason: 'reaped',
-  },
-  Superseded: {
-    code: 4999,
-    reason: 'superseded',
-  },
-} as const
+export type Request<T = void> = EndpointRequest<T> | WebSocketRequest<T>
 
-export type SocketOptions = {
-  dropThreshold?: number
-  heartbeatInterval?: number
-  maxTickets?: number
-  reclaimTtl?: number
-  ticketTtl?: number
-  onOpen?: (clientId: string) => void
-  onClose?: (clientId: string, signal: CloseSignal) => void
-}
-
-export type SocketData = {
-  clientId: string
-  superseded: boolean
-  reaped: boolean
-  reaperHandle: ReturnType<typeof setTimeout> | null
-  app: unknown
-}
-
-export type SocketConnection = {
-  data: SocketData
-  send: (data: string) => unknown
-  close: (code?: number, reason?: string) => void
-}
-
-export type Server = BunServer<SocketData>
-
-export type RouteDefinition = {
-  method: HttpMethod
-  path: string
-  chain: Handler | MiddlewareChain
-}
-
-export type MetaEntry = {
-  path: string
-  middleware: Middleware[]
-}
-
-export type RouteConfig = {
-  routes: RouteDefinition[]
-  meta?: MetaEntry[]
-}
-
-export type AppOptions = {
-  hostname?: string
-  mountPath?: string
-  middleware?: Middleware[]
-  ws?: boolean | SocketOptions
-  onClose?: () => Promise<void> | void
-}
+export type Server<T = void> = BunServer<SocketData<T>>
 
 export function toSegments (pathString: string): string[] {
   const [pathname] = String(pathString).split('?')
@@ -259,9 +207,9 @@ export function formatError (
   }
 }
 
-export async function executeMiddlewareChain (
-  req: Request,
-  chain: MiddlewareChain,
+export async function executeMiddlewareChain<T = void> (
+  req: Request<T>,
+  chain: MiddlewareChain<T>,
 ): AsyncHandlerResult {
   if (!chain.length) {
     throw new RangeError('Middleware chain is empty')
@@ -276,8 +224,8 @@ export async function executeMiddlewareChain (
     const next = (data?: unknown) => executeMiddleware(index + 1, data)
 
     const result = isLast
-      ? await (fn as Handler)(req, res)
-      : await (fn as Middleware)(req, res, next)
+      ? await (fn as Handler<T>)(req, res)
+      : await (fn as Middleware<T>)(req, res, next)
 
     if (result instanceof Response) {
       return result

package/src/index.ts

@@ -1,8 +1,8 @@
 export * from './core'
 
-import type { App, AppOptions } from './core'
+import type { AppOptions, App } from './core'
 
-export declare function createApp (
+export declare function createApp<T = void> (
   port: number,
-  opts?: AppOptions,
-): App
+  opts?: AppOptions<T>,
+): App<T>