sleepy-serv 0.5.0 → 0.6.0

package/src/index.js

@@ -2,9 +2,16 @@ import fs from 'fs'
 import path from 'path'
 import querystring from 'querystring'
 import readline from 'node:readline'
+
 import { stdin, stdout } from 'node:process'
+import { toSegments, executeMiddlewareChain } from './utils'
 
-import * as _middleware from './middleware'
+import {
+  buildSocketState,
+  buildSocketServer,
+  buildSocketHandlers,
+  buildSocketCommands,
+} from './socket'
 
 import {
   NotFoundError,
@@ -13,10 +20,13 @@ import {
 
 export * from './errors'
 
-const ALLOWED_FILES_META = [
-  'meta.js',
-  'meta.ts',
-]
+export {
+  parseJsonBody,
+  setValidationFormats,
+  validateSchemas,
+} from './middleware'
+
+const ALLOWED_FILES_META = ['meta.js', 'meta.ts']
 
 const ALLOWED_FILES_METHODS = [
   'head.js',
@@ -33,18 +43,11 @@ const ALLOWED_FILES_METHODS = [
   'delete.ts',
 ]
 
-const ALLOWED_FILES_ALL = [
-  ...ALLOWED_FILES_META,
-  ...ALLOWED_FILES_METHODS,
-]
-
 /* istanbul ignore if */
 if (process.stdin.isTTY) {
   process.stdin.setRawMode(true)
 }
 
-export const middleware = _middleware
-
 const rl = readline.createInterface({
   input: stdin,
   output: stdout,
@@ -54,18 +57,32 @@ function methodNotAllowedHandler (_req) {
   throw new MethodNotAllowedError()
 }
 
-/* TODO: add whitelist support */
-function validateDirectoryIllegalFiles (targetPath, filenames) {
-//   const hasInvalidFiles = filenames.some(filename =>
-//     !ALLOWED_FILES_ALL.includes(filename)
-//   )
-
-//   if (hasInvalidFiles) {
-//     throw new TypeError(`
-// Directory contains illegal files:
-// ${targetPath}
-//     `.trim())
-//   }
+function defaultMethodMap () {
+  return {
+    HEAD: methodNotAllowedHandler,
+    GET: methodNotAllowedHandler,
+    PUT: methodNotAllowedHandler,
+    POST: methodNotAllowedHandler,
+    PATCH: methodNotAllowedHandler,
+    DELETE: methodNotAllowedHandler,
+  }
+}
+
+function buildBunRequest (bunReq, server) {
+  const url = new URL(bunReq.url)
+  const qs = url.search.replace('?', '')
+  const json = () => bunReq.json()
+
+  return {
+    method: bunReq.method,
+    route: url.pathname,
+    headers: bunReq.headers,
+    params: bunReq.params ?? {},
+    query: querystring.parse(qs),
+    raw: bunReq,
+    server,
+    json,
+  }
 }
 
 function validateLeafDirectory (targetPath, filenames, entries) {
@@ -73,7 +90,7 @@ function validateLeafDirectory (targetPath, filenames, entries) {
 
   if (!hasDirectories) {
     const hasMethodEntry = filenames.some(filename =>
-      ALLOWED_FILES_METHODS.includes(filename)
+      ALLOWED_FILES_METHODS.includes(filename),
     )
 
     if (!hasMethodEntry) {
@@ -90,7 +107,6 @@ function validateDirectory (targetPath, entries) {
     .filter(entry => entry.stat.isFile())
     .map(entry => path.basename(entry.path))
 
-  validateDirectoryIllegalFiles(targetPath, filenames)
   validateLeafDirectory(targetPath, filenames, entries)
 }
 
@@ -109,19 +125,19 @@ function getAllFilePathsRec (targetPath, paths) {
   validateDirectory(targetPath, children)
 
   return children.reduce((accum, curr) => {
-      const result = curr.stat.isDirectory()
-        ? getAllFilePathsRec(curr.path, paths)
-        : [curr.path]
+    const result = curr.stat.isDirectory()
+      ? getAllFilePathsRec(curr.path, paths)
+      : [curr.path]
 
-      return [...accum, ...result]
-    }, [])
+    return [...accum, ...result]
+  }, [])
 }
 
 function getFilteredFilePaths (targetPath, allowedFiles) {
   const allPaths = getAllFilePathsRec(targetPath, [])
 
   return allPaths.filter(item =>
-    allowedFiles.includes(path.basename(item))
+    allowedFiles.includes(path.basename(item)),
   )
 }
 
@@ -133,8 +149,24 @@ function getMetaFilePaths (targetPath) {
   return getFilteredFilePaths(targetPath, ALLOWED_FILES_META)
 }
 
-function buildRoutesPaths (rootPath, mountPath) {
-  const metadata = getMetaFilePaths(rootPath)
+function selectMetaPaths (metadata, modulePath) {
+  return metadata
+    .filter(metaPath => modulePath.startsWith(path.dirname(metaPath)))
+    .sort((a, b) => a.length - b.length)
+}
+
+async function resolveMetaMiddleware (metaPaths) {
+  const modules = await Promise.all(metaPaths.map(item => import(item)))
+
+  return modules
+    .map(item => item.middleware)
+    .reduce((accum, curr) => [
+      ...accum,
+      ...(curr || []),
+    ], [])
+}
+
+function buildRoutePaths (rootPath, mountPath, metadata) {
   const paths = getMethodFilePaths(rootPath)
 
   return paths.map(modulePath => {
@@ -147,13 +179,7 @@ function buildRoutesPaths (rootPath, mountPath) {
       .filter(item => item)
       .join('') || '/'
 
-    const metaMiddlewarePath = metadata
-      .filter(metaPath => {
-        const metaBasePath = path.dirname(metaPath)
-
-        return modulePath.startsWith(metaBasePath)
-      })
-      .sort((a, b) => a.length - b.length)
+    const metaMiddlewarePath = selectMetaPaths(metadata, modulePath)
 
     return {
       method: segments[lastIndex].toUpperCase(),
@@ -164,19 +190,9 @@ function buildRoutesPaths (rootPath, mountPath) {
   })
 }
 
-async function buildHandlers (route, rootMiddleware) {
+async function buildChain (route, rootMiddleware) {
   const module = await import(route.modulePath)
-
-  const middlewareModules = await Promise.all(
-    route.metaMiddlewarePath.map(item => import(item))
-  )
-
-  const metaMiddleware = middlewareModules
-    .map(item => item.middleware)
-    .reduce((accum, curr) => [
-      ...accum,
-      ...(curr || []),
-    ], [])
+  const metaMiddleware = await resolveMetaMiddleware(route.metaMiddlewarePath)
 
   if (!module.default) {
     throw new ReferenceError(`
@@ -189,62 +205,87 @@ ${route.modulePath}
     ? module.default
     : [module.default]
 
-  const middlewareChain = [
-    ...rootMiddleware,
-    ...metaMiddleware,
-    ...baseChain,
-  ]
+  return {
+    method: route.method,
+    path: route.path,
+    chain: [
+      ...rootMiddleware,
+      ...metaMiddleware,
+      ...baseChain,
+    ],
+  }
+}
 
-  const handler = async req => {
-    const query = req.url.split('?')[1]
-    const res = {}
+function buildNormalRoutes (routePaths, rootMiddleware) {
+  return Promise.all(
+    routePaths.map(route => buildChain(route, rootMiddleware)),
+  )
+}
 
-    req.query = query ? querystring.parse(query) : {}
+async function buildMergedRoutes (routePaths, middleware, state, opts) {
+  const { basePath, mountPath, metadata } = opts
+  const socketRoutes = buildSocketHandlers(state)
 
-    const executeMiddleware = async (index) => {
-      const currentMiddleware = middlewareChain[index]
-      const isLastMiddleware = index === middlewareChain.length - 1
+  for (const socketRoute of socketRoutes) {
+    const mountedPath = `${mountPath}${socketRoute.path}`
 
-      const next = !isLastMiddleware ?
-        () => executeMiddleware(index + 1)
-        : null
+    const targetItem = routePaths.find(item => (
+      item.method === socketRoute.method &&
+      item.path === mountedPath
+    ))
 
-      const result = await currentMiddleware(req, res, next)
+    if (targetItem) {
+      targetItem.chain.push(socketRoute.handler)
 
-      if (result instanceof Response) {
-        return result
-      } else {
-        throw new TypeError('Handler does not return a Response object')
-      }
+      continue
     }
 
-    return executeMiddleware(0)
+    const method = socketRoute.method.toLowerCase()
+    const modulePath = path.join(basePath, socketRoute.path, `${method}.js`)
+    const metaPaths = selectMetaPaths(metadata, modulePath)
+    const metaMiddleware = await resolveMetaMiddleware(metaPaths)
+
+    routePaths.push({
+      method: socketRoute.method,
+      path: mountedPath,
+      chain: [
+        ...middleware,
+        ...metaMiddleware,
+        socketRoute.handler,
+      ],
+    })
   }
 
-  return {
-    method: route.method,
-    path: route.path,
-    handler,
-  }
+  return routePaths
 }
 
-function buildModuleRoutes (routePaths, rootMiddleware) {
-  return Promise.all(
-    routePaths.map(route => buildHandlers(route, rootMiddleware))
-  )
+function  buildSocketRoutes (mergedRoutes) {
+  return mergedRoutes.map(route => ({
+    ...route,
+    segments: toSegments(route.path),
+  }))
+}
+
+function buildModuleRoutes (routePaths) {
+  return routePaths.map(route => {
+    const handler = async (bunReq, server) => {
+      const req = buildBunRequest(bunReq, server)
+
+      return executeMiddlewareChain(req, route.chain)
+    }
+
+    return {
+      method: route.method,
+      path: route.path,
+      handler,
+    }
+  })
 }
 
 function buildServerRoutes (moduleRoutes) {
   return moduleRoutes.reduce((accum, curr) => {
     if (!accum[curr.path]) {
-      accum[curr.path] = {
-        HEAD: methodNotAllowedHandler,
-        GET: methodNotAllowedHandler,
-        PUT: methodNotAllowedHandler,
-        POST: methodNotAllowedHandler,
-        PATCH: methodNotAllowedHandler,
-        DELETE: methodNotAllowedHandler,
-      }
+      accum[curr.path] = defaultMethodMap()
     }
 
     accum[curr.path][curr.method] = curr.handler
@@ -262,43 +303,65 @@ function buildOutputRoutes (moduleRoutes) {
   }, {})
 }
 
-async function buildRoutes (rootPath, opts) {
+async function buildRoutes (rootPath, state, opts) {
   const basePath = `${rootPath}/api`
   const mountPath = opts.mountPath || ''
-  const rootMiddleware = opts.middleware || []
-  const routePaths = buildRoutesPaths(basePath, mountPath)
-  const moduleRoutes = await buildModuleRoutes(routePaths, rootMiddleware)
+  const middleware = opts.middleware || []
+  const metadata = getMetaFilePaths(basePath)
+  const routePaths = buildRoutePaths(basePath, mountPath, metadata)
+  const normalRoutes = await buildNormalRoutes(routePaths, middleware)
+
+  const routingOpts = {
+    basePath,
+    mountPath,
+    metadata,
+  }
+
+  const mergedRoutes = await buildMergedRoutes(
+    normalRoutes,
+    middleware,
+    state,
+    routingOpts,
+  )
+
+  const socketRoutes = buildSocketRoutes(mergedRoutes)
+  const moduleRoutes = buildModuleRoutes(socketRoutes)
   const serverRoutes = buildServerRoutes(moduleRoutes)
   const outputRoutes = buildOutputRoutes(moduleRoutes)
 
   return {
     server: serverRoutes,
+    socket: socketRoutes,
     output: outputRoutes,
   }
 }
 
-function buildServer (port, routes, opts) {
+function buildServer (port, routes, state, opts) {
   const hostname = opts.hostname || '0.0.0.0'
+  const websocketServer = buildSocketServer(routes.socket, state)
 
   return Bun.serve({
     port,
     hostname,
     routes: routes.server,
-    fetch (_req) {
+    websocket: websocketServer,
+    async fetch (_req, _server) {
       throw new NotFoundError()
     },
     error (err) {
       console.error(err)
 
-      return new Response(err.message, {
-        status: err.constructor.statusCode || 500,
-      })
+      const status = err.constructor.status ?? 500
+
+      return err.output !== undefined
+        ? Response.json(err.output, { status })
+        : new Response(err.message, { status })
     },
   })
 }
 
 function processIO (port, server, opts) {
-  const onClose = opts.onClose || (() => {})
+  const onClose = opts.onClose || (() => { })
 
   console.info(`Running on port: ${port}`)
   console.info('')
@@ -314,13 +377,16 @@ function processIO (port, server, opts) {
 }
 
 export async function createApp (port, rootPath, opts = {}) {
-  const routes = await buildRoutes(rootPath, opts)
-  const server = buildServer(port, routes, opts)
+  const state = buildSocketState(opts)
+  const routes = await buildRoutes(rootPath, state, opts)
+  const server = buildServer(port, routes, state, opts)
+  const commands = buildSocketCommands(state)
 
   processIO(port, server, opts)
 
   return {
     routes: routes.output,
     server,
+    commands,
   }
 }

package/src/messages.js

@@ -0,0 +1,164 @@
+import Ajv from 'ajv'
+import addFormats from 'ajv-formats'
+import crypto from 'node:crypto'
+import { formatError } from './utils'
+import { UnprocessableContentError } from './errors'
+
+export const TYPES = {
+  REQUEST: 'request',
+  RESPONSE: 'response',
+  WELCOME: 'welcome',
+  HEARTBEAT: 'heartbeat',
+  NOTIFICATION: 'notification',
+}
+
+export const TYPES_RECEIVED = [
+  TYPES.HEARTBEAT,
+  TYPES.REQUEST,
+]
+
+const ajv = new Ajv({
+  allErrors: true,
+  removeAdditional: 'all',
+})
+
+addFormats(ajv)
+
+const SCHEMA_BASE = {
+  type: 'object',
+  properties: {
+    id: {
+      type: 'string',
+      format: 'uuid',
+    },
+    clientId: {
+      type: 'string',
+      format: 'uuid',
+    },
+    type: {
+      type: 'string',
+      enum: TYPES_RECEIVED,
+    },
+    timestamp: {
+      type: 'string',
+      format: 'date-time',
+    },
+  },
+  required: [
+    'id',
+    'clientId',
+    'type',
+    'timestamp',
+  ],
+}
+
+const validateHeartbeat = ajv.compile({
+  type: 'object',
+  properties: {
+    ...SCHEMA_BASE.properties,
+    type: {
+      type: 'string',
+      const: TYPES.HEARTBEAT,
+    },
+  },
+  required: SCHEMA_BASE.required,
+})
+
+const validateRequest = ajv.compile({
+  type: 'object',
+  properties: {
+    ...SCHEMA_BASE.properties,
+    type: {
+      type: 'string',
+      const: TYPES.REQUEST,
+    },
+    method: {
+      type: 'string',
+      enum: [
+        'HEAD',
+        'GET',
+        'PUT',
+        'POST',
+        'PATCH',
+        'DELETE',
+      ],
+    },
+    route: {
+      type: 'string',
+      format: 'uri-reference',
+    },
+    headers: {
+      type: 'object',
+    },
+    query: {
+      type: 'object',
+    },
+    body: {
+      type: [
+        'boolean',
+        'number',
+        'string',
+        'object',
+        'array',
+        'null',
+      ],
+    },
+  },
+  required: [
+    ...SCHEMA_BASE.required,
+    'method',
+    'route',
+    'headers',
+    'query',
+    'body',
+  ],
+})
+
+const TYPE_VALIDATORS = {
+  [TYPES.HEARTBEAT]: validateHeartbeat,
+  [TYPES.REQUEST]: validateRequest,
+}
+
+export function createMessage (clientId, type, opts = {}) {
+  const timestamp = new Date().toISOString()
+
+  const base = {
+    id: opts.id ?? crypto.randomUUID(),
+    clientId,
+    type,
+    timestamp,
+  }
+
+  return {
+    ...opts,
+    ...base,
+  }
+}
+
+export function validateMessage (message) {
+  const validate = TYPE_VALIDATORS[message.type]
+
+  if (message.type === undefined) {
+    throw new UnprocessableContentError([
+      {
+        path: '',
+        message: `must have required property 'type'`,
+      },
+    ])
+  }
+
+  if (!TYPES_RECEIVED.includes(message.type)) {
+    throw new UnprocessableContentError([
+      {
+        path: 'type',
+        message: `must be one of: ${TYPES_RECEIVED}`,
+      },
+    ])
+  }
+
+  if (!validate(message)) {
+    const errors = validate.errors.map(item => formatError('', item))
+
+    throw new UnprocessableContentError(errors)
+  }
+}