sleepy-serv 0.6.2 → 0.7.0

package/src/utils.ts

@@ -0,0 +1,204 @@
+import type { ErrorObject } from 'ajv'
+import type { BunRequest, Server as BunServer } from 'bun'
+
+export const HttpMethod = {
+  Head: 'HEAD',
+  Get: 'GET',
+  Post: 'POST',
+  Put: 'PUT',
+  Patch: 'PATCH',
+  Delete: 'DELETE',
+} as const
+
+export type HttpMethod = typeof HttpMethod[keyof typeof HttpMethod]
+
+export const StatusCode = {
+  Continue: 100,
+  SwitchingProtocols: 101,
+  Processing: 102,
+  EarlyHints: 103,
+
+  Ok: 200,
+  Created: 201,
+  Accepted: 202,
+  NonAuthoritativeInformation: 203,
+  NoContent: 204,
+  ResetContent: 205,
+  PartialContent: 206,
+  MultiStatus: 207,
+  AlreadyReported: 208,
+  ImUsed: 226,
+
+  MultipleChoices: 300,
+  MovedPermanently: 301,
+  Found: 302,
+  SeeOther: 303,
+  NotModified: 304,
+  UseProxy: 305,
+  TemporaryRedirect: 307,
+  PermanentRedirect: 308,
+
+  BadRequest: 400,
+  Unauthorized: 401,
+  PaymentRequired: 402,
+  Forbidden: 403,
+  NotFound: 404,
+  MethodNotAllowed: 405,
+  NotAcceptable: 406,
+  ProxyAuthenticationRequired: 407,
+  RequestTimeout: 408,
+  Conflict: 409,
+  Gone: 410,
+  LengthRequired: 411,
+  PreconditionFailed: 412,
+  PayloadTooLarge: 413,
+  UriTooLong: 414,
+  UnsupportedMediaType: 415,
+  RangeNotSatisfiable: 416,
+  ExpectationFailed: 417,
+  ImATeapot: 418,
+  MisdirectedRequest: 421,
+  UnprocessableContent: 422,
+  Locked: 423,
+  FailedDependency: 424,
+  TooEarly: 425,
+  UpgradeRequired: 426,
+  PreconditionRequired: 428,
+  TooManyRequests: 429,
+  RequestHeaderFieldsTooLarge: 431,
+  UnavailableForLegalReasons: 451,
+
+  InternalServerError: 500,
+  NotImplemented: 501,
+  BadGateway: 502,
+  ServiceUnavailable: 503,
+  GatewayTimeout: 504,
+  HTTPVersionNotSupported: 505,
+  VariantAlsoNegotiates: 506,
+  InsufficientStorage: 507,
+  LoopDetected: 508,
+  NotExtended: 510,
+  NetworkAuthenticationRequired: 511,
+} as const
+
+export type StatusCode = typeof StatusCode[keyof typeof StatusCode]
+
+export type ValidationError = Partial<ErrorObject>
+
+export type FormattedError = {
+  path: string
+  message: string
+}
+
+export type NextFn = (data?: unknown) => Response | Promise<Response>
+
+export type BaseRequest = {
+  method: HttpMethod
+  route: string
+  headers: Headers
+  params: Record<string, string>
+  query: Record<string, unknown>
+  json: () => Promise<unknown>
+}
+
+export type EndpointRequest = BaseRequest & {
+  raw: BunRequest
+  server: Server
+}
+
+export type WebSocketRequest = BaseRequest & {
+  id: string
+  clientId: string
+}
+
+export type Request = EndpointRequest | WebSocketRequest
+
+export type Middleware = (
+  req: Request,
+  res: unknown,
+  next: NextFn | null,
+) => unknown
+
+export type SocketOptions = {
+  disconnectThreshold?: number
+  heartbeatInterval?: number
+  maxTickets?: number
+  reclaimTtl?: number
+  ticketTtl?: number
+}
+
+export type SocketData = {
+  clientId: string
+  superseded: boolean
+  reaped: boolean
+  reaperHandle: ReturnType<typeof setTimeout> | null
+}
+
+export type Server = BunServer<SocketData>
+
+export type AppOptions = {
+  hostname?: string
+  mountPath?: string
+  middleware?: Middleware[]
+  ws?: SocketOptions
+  onClose?: () => Promise<void> | void
+}
+
+export function toSegments (pathString: string): string[] {
+  const [pathname] = String(pathString).split('?')
+  const segments = pathname.split('/')
+
+  if (pathname.startsWith('/')) {
+    segments.shift()
+  }
+
+  if (pathname.endsWith('/')) {
+    segments.pop()
+  }
+
+  return segments
+}
+
+export function formatError (
+  prefix: string,
+  input: ValidationError,
+): FormattedError {
+  const fixedPath = input.instancePath || '/'
+  const suffixPath = fixedPath.replace(/\//g, '.').replace('.', '')
+
+  return {
+    path: [prefix, suffixPath].filter(item => item).join('.'),
+    message: input.message ?? '',
+  }
+}
+
+export async function executeMiddlewareChain (
+  req: Request,
+  chain: Middleware[],
+): Promise<Response> {
+  if (!chain.length) {
+    throw new RangeError('Middleware chain is empty')
+  }
+
+  const executeMiddleware = async (
+    index: number,
+    res: unknown,
+  ): Promise<Response> => {
+    const currentMiddleware = chain[index]
+    const isLastMiddleware = index === chain.length - 1
+
+    const next = !isLastMiddleware ?
+      (data?: unknown) => executeMiddleware(index + 1, data)
+      : null
+
+    const result = await currentMiddleware(req, res, next)
+
+    if (result instanceof Response) {
+      return result
+    } else {
+      throw new TypeError('Handler does not return a Response object')
+    }
+  }
+
+  return executeMiddleware(0, null)
+}

package/src/messages.js

@@ -1,164 +0,0 @@
-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)
-  }
-}

package/src/meta.js

@@ -1,65 +0,0 @@
-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

@@ -1,138 +0,0 @@
-import Ajv from 'ajv'
-import addFormats from 'ajv-formats'
-
-import { formatError } from './utils'
-
-import {
-  BadRequestError,
-  UnsupportedMediaTypeError,
-  UnprocessableContentError,
-} from './errors'
-
-let _schemasCompiled = false
-let _customFormats = null
-
-async function parseBody (req) {
-  try {
-    const result = await req.json()
-
-    return result
-  } catch {
-    throw new BadRequestError('Invalid JSON')
-  }
-}
-
-function buildFormatterSchema (schema) {
-  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,
-  }
-}
-
-function compileSchemas (schemas) {
-  return Object
-    .entries(schemas)
-    .reduce((accum, [key, schema]) => {
-      const formattedSchema = key !== 'body'
-        ? buildFormatterSchema(schema)
-        : schema
-
-      return [
-        ...accum,
-        [key, formattedSchema],
-      ]
-    }, [])
-    .map(([key, schema]) => {
-      const ajv = new Ajv({
-        allErrors: true,
-        removeAdditional: 'all',
-      })
-
-      addFormats(ajv)
-
-      Object
-        .entries(_customFormats ?? [])
-        .forEach(([k, v]) => ajv.addFormat(k, v))
-
-      const validator = ajv.compile(schema)
-
-      return [key, validator]
-    })
-}
-
-export function parseJsonBody () {
-  return async (req, res, next) => {
-    const contentType = req.headers.get('content-type')
-
-    if (!contentType) {
-      return next(res)
-    }
-
-    if (!contentType.startsWith('application/json')) {
-      throw new UnsupportedMediaTypeError('content-type')
-    }
-
-    const body = await parseBody(req)
-
-    return next(body)
-  }
-}
-
-export function setValidationFormats (formats) {
-  if (_customFormats) {
-    console.warn('setValidationFormats() - already initialized')
-  }
-
-  if (_schemasCompiled) {
-    console.warn('setValidationFormats() - called after compilation')
-  }
-
-  _customFormats = formats
-}
-
-/* only for testing purposes */
-
-export function resetValidationFormatsState () {
-  _customFormats = null
-  _schemasCompiled = false
-}
-
-export function validateSchemas (schemas) {
-  const entries = compileSchemas(schemas)
-
-  _schemasCompiled = true
-
-  return (req, res, next) => {
-    const errors = entries.reduce((accum, [key, validator]) => {
-      const data = key === 'body' ? res : req[key]
-      const valid = validator(data)
-
-      return !valid
-        ? [
-          ...accum,
-          ...validator.errors.map(item => formatError(key, item)),
-        ]
-        : accum
-    }, [])
-
-    if (errors.length > 0) {
-      throw new UnprocessableContentError(errors)
-    }
-
-    return next(res)
-  }
-}

package/src/utils.js

@@ -1,49 +0,0 @@
-export function toSegments (pathString) {
-  const [pathname] = String(pathString).split('?')
-  const segments = pathname.split('/')
-
-  if (pathname.startsWith('/')) {
-    segments.shift()
-  }
-
-  if (pathname.endsWith('/')) {
-    segments.pop()
-  }
-
-  return segments
-}
-
-export 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,
-  }
-}
-
-export async function executeMiddlewareChain (req, chain) {
-  if (!chain.length) {
-    throw new RangeError('Middleware chain is empty')
-  }
-
-  const executeMiddleware = async (index, res) => {
-    const currentMiddleware = chain[index]
-    const isLastMiddleware = index === chain.length - 1
-
-    const next = !isLastMiddleware ?
-      (data) => executeMiddleware(index + 1, data)
-      : null
-
-    const result = await currentMiddleware(req, res, next)
-
-    if (result instanceof Response) {
-      return result
-    } else {
-      throw new TypeError('Handler does not return a Response object')
-    }
-  }
-
-  return executeMiddleware(0, null)
-}