sleepy-serv 0.1.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "sleepy-serv",
+  "description": "A more opinionated web server for building REST-ful applications",
+  "author": "Travis J True",
+  "version": "0.1.0",
+  "exports": "./src/index.js",
+  "type": "module",
+  "keywords": [
+    "rest",
+    "serv",
+    "sleepy",
+    "web server",
+    "www"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "devDependencies": {
+    "axios": "^1.7.9",
+    "eslint": "9.20.1"
+  },
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1"
+  }
+}

package/src/errors.js

@@ -0,0 +1,412 @@
+class RequestError extends Error {
+  constructor (message) {
+    super(message)
+
+    this.name = 'RequestError'
+  }
+}
+
+// 4xx - Client Errors
+
+export class BadRequestError extends RequestError {
+  static get statusCode () { return 400 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'BadRequestError'
+  }
+}
+
+export class UnauthorizedError extends RequestError {
+  static get statusCode () { return 401 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'UnauthorizedError'
+  }
+}
+
+export class PaymentRequiredError extends RequestError {
+  static get statusCode () { return 402 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'PaymentRequiredError'
+  }
+}
+
+export class ForbiddenError extends RequestError {
+  static get statusCode () { return 403 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'ForbiddenError'
+  }
+}
+
+export class NotFoundError extends RequestError {
+  static get statusCode () { return 404 }
+
+  constructor () {
+    super('')
+
+    this.name = 'NotFoundError'
+  }
+}
+
+export class MethodNotAllowedError extends RequestError {
+  static get statusCode () { return 405 }
+
+  constructor () {
+    super('')
+
+    this.name = 'MethodNotAllowedError'
+  }
+}
+
+export class NotAcceptableError extends RequestError {
+  static get statusCode () { return 406 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'NotAcceptableError'
+  }
+}
+
+export class ProxyAuthenticationRequiredError extends RequestError {
+  static get statusCode () { return 407 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'ProxyAuthenticationRequiredError'
+  }
+}
+
+export class RequestTimeoutError extends RequestError {
+  static get statusCode () { return 408 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'RequestTimeoutError'
+  }
+}
+
+export class ConflictError extends RequestError {
+  static get statusCode () { return 409 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'ConflictError'
+  }
+}
+
+export class GoneError extends RequestError {
+  static get statusCode () { return 410 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'GoneError'
+  }
+}
+
+export class LengthRequiredError extends RequestError {
+  static get statusCode () { return 411 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'LengthRequiredError'
+  }
+}
+
+export class PreconditionFailedError extends RequestError {
+  static get statusCode () { return 412 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'PreconditionFailedError'
+  }
+}
+
+export class PayloadTooLargeError extends RequestError {
+  static get statusCode () { return 413 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'PayloadTooLargeError'
+  }
+}
+
+export class UriTooLongError extends RequestError {
+  static get statusCode () { return 414 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'UriTooLongError'
+  }
+}
+
+export class UnsupportedMediaTypeError extends RequestError {
+  static get statusCode () { return 415 }
+
+  constructor (subject) {
+    super(`Unsupported ${subject}`)
+
+    this.name = 'UnsupportedMediaTypeError'
+  }
+}
+
+export class RangeNotSatisfiableError extends RequestError {
+  static get statusCode () { return 416 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'RangeNotSatisfiableError'
+  }
+}
+
+export class ExpectationFailedError extends RequestError {
+  static get statusCode () { return 417 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'ExpectationFailedError'
+  }
+}
+
+export class ImATeapotError extends RequestError {
+  static get statusCode () { return 418 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'ImATeapotError'
+  }
+}
+
+export class MisdirectedRequestError extends RequestError {
+  static get statusCode () { return 421 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'MisdirectedRequestError'
+  }
+}
+
+export class UnprocessableContentError extends RequestError {
+  static get statusCode () { return 422 }
+
+  constructor (errors) {
+    super(JSON.stringify(errors))
+
+    this.name = 'UnprocessableContentError'
+  }
+}
+
+export class LockedError extends RequestError {
+  static get statusCode () { return 423 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'LockedError'
+  }
+}
+
+export class FailedDependencyError extends RequestError {
+  static get statusCode () { return 424 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'FailedDependencyError'
+  }
+}
+
+export class TooEarlyError extends RequestError {
+  static get statusCode () { return 425 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'TooEarlyError'
+  }
+}
+
+export class UpgradeRequiredError extends RequestError {
+  static get statusCode () { return 426 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'UpgradeRequiredError'
+  }
+}
+
+export class PreconditionRequiredError extends RequestError {
+  static get statusCode () { return 428 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'PreconditionRequiredError'
+  }
+}
+
+export class TooManyRequestsError extends RequestError {
+  static get statusCode () { return 429 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'TooManyRequestsError'
+  }
+}
+
+export class RequestHeaderFieldsTooLargeError extends RequestError {
+  static get statusCode () { return 431 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'RequestHeaderFieldsTooLargeError'
+  }
+}
+
+export class UnavailableForLegalReasonsError extends RequestError {
+  static get statusCode () { return 451 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'UnavailableForLegalReasonsError'
+  }
+}
+
+// 5xx - Server Errors
+
+export class InternalServerError extends RequestError {
+  static get statusCode () { return 500 }
+
+  constructor (message, ctx) {
+    super(message)
+
+    this.name = 'InternalServerError'
+    this.ctx = ctx
+  }
+}
+
+export class NotImplementedError extends RequestError {
+  static get statusCode () { return 501 }
+
+  constructor () {
+    super('')
+
+    this.name = 'NotImplementedError'
+  }
+}
+
+export class BadGatewayError extends RequestError {
+  static get statusCode () { return 502 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'BadGatewayError'
+  }
+}
+
+export class ServiceUnavailableError extends RequestError {
+  static get statusCode () { return 503 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'ServiceUnavailableError'
+  }
+}
+
+export class GatewayTimeoutError extends RequestError {
+  static get statusCode () { return 504 }
+
+  constructor () {
+    super('')
+
+    this.name = 'GatewayTimeoutError'
+  }
+}
+
+export class HTTPVersionNotSupportedError extends RequestError {
+  static get statusCode () { return 505 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'HTTPVersionNotSupportedError'
+  }
+}
+
+export class VariantAlsoNegotiatesError extends RequestError {
+  static get statusCode () { return 506 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'VariantAlsoNegotiatesError'
+  }
+}
+
+export class InsufficientStorageError extends RequestError {
+  static get statusCode () { return 507 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'InsufficientStorageError'
+  }
+}
+
+export class LoopDetectedError extends RequestError {
+  static get statusCode () { return 508 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'LoopDetectedError'
+  }
+}
+
+export class NotExtendedError extends RequestError {
+  static get statusCode () { return 510 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'NotExtendedError'
+  }
+}
+
+export class NetworkAuthenticationRequiredError extends RequestError {
+  static get statusCode () { return 511 }
+
+  constructor (message) {
+    super(message)
+
+    this.name = 'NetworkAuthenticationRequiredError'
+  }
+}

package/src/index.js

@@ -0,0 +1,301 @@
+import fs from 'fs'
+import path from 'path'
+import querystring from 'querystring'
+import readline from 'node:readline'
+import { stdin, stdout } from 'node:process'
+
+import * as _middleware from './middleware.js'
+
+import {
+  NotFoundError,
+  MethodNotAllowedError,
+} from './errors'
+
+export * from './errors'
+
+const ALLOWED_FILES_META = ['meta.js']
+
+const ALLOWED_FILES_METHODS = [
+  'head.js',
+  'get.js',
+  'put.js',
+  'post.js',
+  'patch.js',
+  'delete.js',
+]
+
+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,
+})
+
+function methodNotAllowedHandler (_req) {
+  throw new MethodNotAllowedError()
+}
+
+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 validateLeafDirectory (targetPath, filenames, entries) {
+  const hasDirectories = entries.some(entry => entry.stat.isDirectory())
+
+  if (!hasDirectories) {
+    const hasMethodEntry = filenames.some(filename =>
+      ALLOWED_FILES_METHODS.includes(filename)
+    )
+
+    if (!hasMethodEntry) {
+      throw new TypeError(`
+Directory is a leaf, but doesn't contain a method file:
+${targetPath}
+      `.trim())
+    }
+  }
+}
+
+function validateDirectory (targetPath, entries) {
+  const filenames = entries
+    .filter(entry => entry.stat.isFile())
+    .map(entry => path.basename(entry.path))
+
+  validateDirectoryIllegalFiles(targetPath, filenames)
+  validateLeafDirectory(targetPath, filenames, entries)
+}
+
+function getAllFilePathsRec (targetPath, paths) {
+  const entries = fs.readdirSync(targetPath)
+
+  const children = entries.map(item => {
+    const fullPath = path.join(targetPath, item)
+
+    return {
+      path: fullPath,
+      stat: fs.statSync(fullPath),
+    }
+  })
+
+  validateDirectory(targetPath, children)
+
+  return children.reduce((accum, curr) => {
+      const result = curr.stat.isDirectory()
+        ? getAllFilePathsRec(curr.path, paths)
+        : [curr.path]
+
+      return [...accum, ...result]
+    }, [])
+}
+
+function getFilteredFilePaths (targetPath, allowedFiles) {
+  const allPaths = getAllFilePathsRec(targetPath, [])
+
+  return allPaths.filter(item =>
+    allowedFiles.includes(path.basename(item))
+  )
+}
+
+function getMethodFilePaths (targetPath) {
+  return getFilteredFilePaths(targetPath, ALLOWED_FILES_METHODS)
+}
+
+function getMetaFilePaths (targetPath) {
+  return getFilteredFilePaths(targetPath, ALLOWED_FILES_META)
+}
+
+function buildRoutesPaths (rootPath, mountPath) {
+  const metadata = getMetaFilePaths(rootPath)
+  const paths = getMethodFilePaths(rootPath)
+
+  return paths.map(modulePath => {
+    const trimmedPath = modulePath.replace(rootPath, '')
+    const segments = trimmedPath.split('.')[0].split('/')
+    const lastIndex = segments.length - 1
+    const basePath = segments.slice(0, segments.length - 1).join('/')
+
+    const joinedPath = [mountPath, basePath]
+      .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)
+
+    return {
+      method: segments[lastIndex].toUpperCase(),
+      path: joinedPath,
+      metaMiddlewarePath,
+      modulePath,
+    }
+  })
+}
+
+async function buildHandlers (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 || []),
+    ], [])
+
+  if (!module.default) {
+    throw new ReferenceError(`
+No default export defined in:
+${route.modulePath}
+    `.trim())
+  }
+
+  const baseChain = Array.isArray(module.default)
+    ? module.default
+    : [module.default]
+
+  const middlewareChain = [
+    ...rootMiddleware,
+    ...metaMiddleware,
+    ...baseChain,
+  ]
+
+  const handler = async req => {
+    const query = req.url.split('?')[1]
+
+    req.query = query ? querystring.parse(query) : {}
+
+    for (const fn of middlewareChain) {
+      const res = await fn(req)
+
+      if (res) {
+        return res
+      }
+    }
+  }
+
+  return {
+    method: route.method,
+    path: route.path,
+    handler,
+  }
+}
+
+function buildModuleRoutes (routePaths, rootMiddleware) {
+  return Promise.all(
+    routePaths.map(route => buildHandlers(route, rootMiddleware))
+  )
+}
+
+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][curr.method] = curr.handler
+
+    return accum
+  }, {})
+}
+
+function buildOutputRoutes (moduleRoutes) {
+  return moduleRoutes.reduce((accum, curr) => {
+    accum[curr.path] = accum[curr.path] || []
+    accum[curr.path].push(curr.method)
+
+    return accum
+  }, {})
+}
+
+async function buildRoutes (rootPath, 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 serverRoutes = buildServerRoutes(moduleRoutes)
+  const outputRoutes = buildOutputRoutes(moduleRoutes)
+
+  return {
+    server: serverRoutes,
+    output: outputRoutes,
+  }
+}
+
+function buildServer (port, routes) {
+  return Bun.serve({
+    port,
+    routes: routes.server,
+    fetch (_req) {
+      throw new NotFoundError()
+    },
+    error (err) {
+      console.error(err)
+
+      return new Response(err.message, {
+        status: err.constructor.statusCode || 500,
+      })
+    },
+  })
+}
+
+function processIO (port, server, opts) {
+  const onClose = opts.onClose || (() => {})
+
+  console.info(`Running on port: ${port}`)
+  console.info('')
+  console.info('Press Ctrl+D to gracefully shutdown')
+  console.info('')
+
+  /* istanbul ignore next */
+  rl.on('close', async () => {
+    await server.stop()
+    await onClose()
+    process.exit(0)
+  })
+}
+
+export async function createApp (port, rootPath, opts = {}) {
+  const routes = await buildRoutes(rootPath, opts)
+  const server = buildServer(port, routes)
+
+  processIO(port, server, opts)
+
+  return {
+    routes: routes.output,
+    server,
+  }
+}

package/src/meta.js

@@ -0,0 +1,65 @@
+export function range (count, startIndex = 0) {
+  return new Array(count).fill(0).map((_, index) => index + startIndex)
+}
+
+export function traverse (obj, onKey, includeRoot = false) {
+  const path = ['']
+
+  const fn = target => {
+    Object.entries(target).forEach(([k, v]) => {
+      path[path.length - 1] = k
+
+      const dateType = v instanceof Date
+      const clip = onKey([...path], v) === false
+      const updatedVal = getValueByPath(obj, path)
+      const nonNullObj = updatedVal !== null && typeof updatedVal === 'object'
+
+      if (!clip && !dateType && nonNullObj) {
+        path.push('')
+        fn(updatedVal)
+        path.pop()
+      }
+    })
+  }
+
+  if (includeRoot) {
+    onKey([], obj)
+  }
+
+  fn(obj)
+}
+
+export function map (obj, onKey) {
+  const result = Array.isArray(obj) ? [] : {}
+
+  traverse(obj, (keyPath, value) => {
+    const dateType = value instanceof Date
+
+    if (!dateType && value !== null && typeof value === 'object') {
+      setValueByPath(result, keyPath, Array.isArray(value) ? [] : {})
+    } else {
+      setValueByPath(result, keyPath, onKey(keyPath, value))
+    }
+  })
+
+  return result
+}
+
+export function deepCopy (obj) {
+  return map(obj, (_, value) => value)
+}
+
+export function setValueByPath (obj, keyPath, value) {
+  keyPath.reduce((subObj, key, index) => {
+    if (index === keyPath.length - 1) {
+      subObj[key] = value
+    } else {
+      return subObj[key]
+    }
+  }, obj)
+}
+
+export function getValueByPath (obj, keyPath) {
+  return keyPath.reduce((obj, key) =>
+    (typeof obj !== 'undefined' ? obj[key] : undefined), obj)
+}

package/src/middleware.js

@@ -0,0 +1,101 @@
+import Ajv from 'ajv'
+import addFormats from 'ajv-formats'
+
+import {
+  UnsupportedMediaTypeError,
+  UnprocessableContentError,
+} from './errors'
+
+const SCHEMA_EMPTY = {
+  type: 'object',
+  properties: {},
+}
+
+let _customFormats = {}
+
+function formatError (prefix, input) {
+  const fixedPath = input.instancePath || '/'
+  const suffixPath = fixedPath.replace(/\//g, '.').replace('.', '')
+
+  return {
+    path: [prefix, suffixPath].filter(item => item).join('.'),
+    message: input.message,
+  }
+}
+
+function buildFormatterSchema (schema) {
+  if (!schema) {
+    return SCHEMA_EMPTY
+  }
+
+  const properties = Object
+    .entries(schema)
+    .map(([key, config]) => [key, {
+        type: 'string',
+        [config.type]: config.value,
+      },
+    ])
+    .reduce((accum, [key, value]) => ({
+      ...accum,
+      [key]: value,
+    }), {})
+
+  return {
+    type: 'object',
+    properties,
+  }
+}
+
+export async function parseJson (req) {
+  const contentType = req.headers.get('content-type')
+
+  if (req.method !== 'GET' && contentType !== 'application/json') {
+    throw new UnsupportedMediaTypeError('content-type')
+  }
+
+  req.parsedBody = await req.json()
+}
+
+export function setValidationFormats (formats) {
+  _customFormats = formats
+}
+
+export function validateSchema (schemas) {
+  return function (req) {
+    const formattedSchemas = {
+      headers: buildFormatterSchema(schemas.headers),
+      params: buildFormatterSchema(schemas.params),
+      query: buildFormatterSchema(schemas.query),
+      parsedBody: schemas.parsedBody || SCHEMA_EMPTY,
+    }
+
+    const ajv = new Ajv({
+      allErrors: true,
+      removeAdditional: 'all',
+    })
+
+    addFormats(ajv)
+
+    Object
+      .entries(_customFormats)
+      .forEach(([k, v]) => ajv.addFormat(k, v))
+
+    const errors = Object
+      .entries(formattedSchemas)
+      .reduce((accum, [key, schema]) => {
+        const data = req[key]
+        const valid = schema ? ajv.validate(schema, data) : true
+
+        return !valid
+          ? [
+            ...accum,
+            ...ajv.errors.map(item => formatError(key, item)),
+          ]
+          : accum
+      }, [])
+
+    if (errors.length > 0) {
+      throw new UnprocessableContentError(errors)
+    }
+  }
+}