galbe 0.1.0

package/src/util.ts

@@ -0,0 +1,12 @@
+const METHOD_COLOR: Record<string, string> = {
+  get: '\x1b[32m',
+  post: '\x1b[34m',
+  put: '\x1b[36m',
+  patch: '\x1b[33m',
+  delete: '\x1b[31m',
+  options: ''
+}
+export const logRoute = (r: { method: string; path: string }) => {
+  let color = METHOD_COLOR?.[r.method] || ''
+  console.log(`    [${color}${`${r.method.toUpperCase()}\x1b[0m]`.padEnd(12, ' ')} ${r.path}`)
+}

package/src/validator.ts

@@ -0,0 +1,117 @@
+import type { TProperties, TSchema } from '@sinclair/typebox'
+
+import { Kind, Optional } from '@sinclair/typebox'
+
+export const validate = (elt: any, schema: TSchema, parse = false): any => {
+  type ValidationError = string | string[] | { [key: string]: ValidationError }
+  const errors: ValidationError[] = []
+  const iElt = elt
+
+  if (schema[Kind] === 'Boolean') {
+    if (parse && typeof elt === 'string') elt = elt === 'true' ? true : elt === 'false' ? false : null
+    if (elt !== true && elt !== false) throw `${iElt} is not a valid boolean. Should be 'true' or 'false'`
+  } else if (schema[Kind] === 'Integer') {
+    if (parse && typeof elt === 'string') elt = Number(elt)
+    if (!Number.isInteger(elt)) throw `${iElt} is not a valid integer`
+    schemaValidation(elt, schema)
+  } else if (schema[Kind] === 'Number') {
+    if (parse && typeof elt === 'string') elt = Number(elt)
+    if (!Number.isFinite(elt)) throw `${iElt} is not a valid number`
+    schemaValidation(elt, schema)
+  } else if (schema[Kind] === 'String') {
+    if (!(typeof elt === 'string')) throw `${iElt} is not a valid string`
+    schemaValidation(elt, schema)
+  } else if (schema[Kind] === 'Literal') {
+    if (elt !== schema.const) throw `${iElt} is not a valid value`
+  } else if (schema[Kind] === 'Object') {
+    if (parse && typeof elt === 'string') {
+      try {
+        elt = JSON.parse(elt)
+      } catch {
+        throw `${iElt} is not a valid object`
+      }
+    }
+    if (typeof elt !== 'object') throw `${iElt} is not a valid object`
+    if (Array.isArray(elt)) throw `Expected an object, not an array`
+    const err: ValidationError = {}
+    Object.entries(schema.properties as TProperties).forEach(([k, s]) => {
+      if (!(k in elt)) {
+        if (!s[Optional]) err[k] = 'Required'
+        return
+      }
+      try {
+        validate(elt[k], s, parse)
+      } catch (e) {
+        err[k] = e as ValidationError
+      }
+    })
+    if (Object.keys(err).length) errors.push(err)
+  } else if (schema[Kind] === 'Array') {
+    if (parse && typeof elt === 'string') {
+      try {
+        elt = JSON.parse(elt)
+      } catch (error) {
+        throw 'Not a valid array'
+      }
+    }
+    if (!Array.isArray(elt)) throw 'Not a valid array'
+    schemaValidation(elt, schema)
+  } else if (schema[Kind] === 'ByteArray') {
+    if (parse && typeof elt === 'string') elt = Uint8Array.from(elt, c => c.charCodeAt(0))
+    else if (parse && Array.isArray(elt)) elt = new Uint8Array(elt)
+    if (!(elt instanceof Uint8Array)) throw 'Not a valid ByteArray'
+  } else if (schema[Kind] === 'Union') {
+    const union = Object.values(schema.anyOf)
+    let valid = false
+    for (const u of union) {
+      try {
+        elt = validate(elt, u as TSchema, parse)
+        valid = true
+        break
+      } catch (err) {
+        continue
+      }
+    }
+    // @ts-ignore
+    if (!valid) throw `${elt} could not be parsed to any of: ${union.map(u => u?.const ?? u[Kind]).join(', ')}`
+  } else if (schema[Kind] === 'Any') {
+  } else {
+    throw `Unsupported schema type ${schema[Kind]}`
+  }
+
+  if (Object.keys(errors).length === 1) throw errors[0]
+  if (Object.keys(errors).length > 1) throw errors
+
+  return elt
+}
+
+const schemaValidation = (value: any, schema: TSchema) => {
+  const errors = []
+  if (schema[Kind] === 'Integer' || schema[Kind] === 'Number') {
+    if (schema.exclusiveMinimum !== undefined)
+      if ((value as number) <= schema.exclusiveMinimum)
+        errors.push(`${value} is less or equal to ${schema.exclusiveMinimum}`)
+    if (schema.exclusiveMaximum !== undefined)
+      if ((value as number) >= schema.exclusiveMaximum)
+        errors.push(`${value} is greater or equal to ${schema.exclusiveMaximum}`)
+    if (schema.minimum !== undefined)
+      if ((value as number) < schema.minimum) errors.push(`${value} is less than ${schema.minimum}`)
+    if (schema.maximum !== undefined)
+      if ((value as number) > schema.maximum) errors.push(`${value} is greater than ${schema.maximum}`)
+  } else if (schema[Kind] === 'String') {
+    if (schema.minLength !== undefined && (value as string).length < schema.minLength)
+      errors.push(`${value} length is too small (${schema.minLength} char min)`)
+    if (schema.maxLength !== undefined && (value as string).length > schema.maxLength)
+      errors.push(`${value} length is too large (${schema.maxLength} char max)`)
+    if (schema.pattern !== undefined && !(value as string).match(new RegExp(schema.pattern)))
+      errors.push(`${value} does not match pattern ${schema.pattern}`)
+  } else if (schema[Kind] === 'Array') {
+    if (schema.minItems !== undefined && (value as any[]).length < schema.minItems)
+      errors.push(`Must contain at least ${schema.minItems} item${schema.minItems > 1 ? 's' : ''}`)
+    if (schema.maxItems !== undefined && (value as any[]).length > schema.maxItems)
+      errors.push(`Must contain at most (${schema.maxItems} item${schema.maxItems > 1 ? 's' : ''}`)
+    if (schema.uniqueItems === true && new Set(value as any[]).size !== (value as any[]).length)
+      errors.push(`Has duplicate values`)
+  }
+  if (errors.length) throw Array.isArray(errors) && errors.length === 1 ? errors[0] : errors
+}

package/test/hooks.test.ts

@@ -0,0 +1,177 @@
+import { expect, test, describe } from 'bun:test'
+import { Galbe } from '../src'
+
+const port = 7360
+
+describe('hooks', async () => {
+  const galbe = new Galbe()
+  await galbe.listen(port)
+
+  test('hooks, empty', async () => {
+    galbe.get('/hooks/empty', [], () => 'handled')
+
+    let resp = await fetch(`http://localhost:${port}/hooks/empty`, {
+      method: 'GET'
+    })
+    expect(resp.status).toBe(200)
+    expect(await resp?.text()).toBe('handled')
+  })
+
+  test('hooks, void', async () => {
+    galbe.get('/hooks/void', [(_ctx, _next) => {}], () => 'handled')
+
+    let resp = await fetch(`http://localhost:${port}/hooks/void`, {
+      method: 'GET'
+    })
+    expect(resp.status).toBe(200)
+    expect(await resp?.text()).toBe('handled')
+  })
+
+  test('hooks, called without next', async () => {
+    let hookCalled = 0
+    galbe.get(
+      '/hooks/called',
+      [
+        _ => {
+          hookCalled++
+        }
+      ],
+      () => 'handled'
+    )
+    expect(hookCalled).toBe(0)
+    let resp = await fetch(`http://localhost:${port}/hooks/called`, {
+      method: 'GET'
+    })
+    expect(hookCalled).toBe(1)
+    expect(resp.status).toBe(200)
+    expect(await resp?.text()).toBe('handled')
+  })
+
+  test('hooks, called with next', async () => {
+    let hookCalled = 0
+    galbe.get(
+      '/hooks/called',
+      [
+        async (_, next) => {
+          hookCalled++
+          await Bun.sleep(10)
+          await next()
+        }
+      ],
+      () => 'handled'
+    )
+    expect(hookCalled).toBe(0)
+    let resp = await fetch(`http://localhost:${port}/hooks/called`, {
+      method: 'GET'
+    })
+    expect(hookCalled).toBe(1)
+    expect(resp.status).toBe(200)
+    expect(await resp?.text()).toBe('handled')
+  })
+
+  test('hooks, wrapper hook', async () => {
+    let before = 0
+    let after = 0
+    galbe.get(
+      '/hooks/called',
+      [
+        async (_, next) => {
+          before++
+          await Bun.sleep(10)
+          await next()
+          after++
+        }
+      ],
+      () => {
+        expect(before).toBe(1)
+        expect(after).toBe(0)
+        return 'handled'
+      }
+    )
+    expect(before).toBe(0)
+    expect(after).toBe(0)
+    let resp = await fetch(`http://localhost:${port}/hooks/called`, {
+      method: 'GET'
+    })
+    expect(before).toBe(1)
+    expect(after).toBe(1)
+    expect(resp.status).toBe(200)
+    expect(await resp?.text()).toBe('handled')
+  })
+
+  test('hooks, nested wrappers', async () => {
+    let before1 = 0
+    let after1 = 0
+    let before2 = 0
+    let after2 = 0
+    galbe.get(
+      '/hooks/called',
+      [
+        async (_, next) => {
+          before1++
+          await Bun.sleep(10)
+          await next()
+          after1++
+        },
+        async (_, next) => {
+          before2++
+          await Bun.sleep(10)
+          await next()
+          after2++
+        }
+      ],
+      () => {
+        expect(before1).toBe(1)
+        expect(before2).toBe(1)
+        expect(after1).toBe(0)
+        expect(after2).toBe(0)
+        return 'handled'
+      }
+    )
+    expect(before1).toBe(0)
+    expect(before2).toBe(0)
+    expect(after1).toBe(0)
+    expect(after2).toBe(0)
+    let resp = await fetch(`http://localhost:${port}/hooks/called`, {
+      method: 'GET'
+    })
+    expect(before1).toBe(1)
+    expect(before2).toBe(1)
+    expect(after1).toBe(1)
+    expect(after2).toBe(1)
+    expect(resp.status).toBe(200)
+    expect(await resp?.text()).toBe('handled')
+  })
+
+  test('hooks, linear chaining', async () => {
+    let hook1 = 0
+    let hook2 = 0
+    galbe.get(
+      '/hooks/called',
+      [
+        async _ => {
+          hook1++
+          await Bun.sleep(10)
+        },
+        async _ => {
+          hook2++
+          await Bun.sleep(10)
+        }
+      ],
+      () => {
+        expect(hook1).toBe(1)
+        expect(hook2).toBe(1)
+        return 'handled'
+      }
+    )
+    expect(hook1).toBe(0)
+    expect(hook2).toBe(0)
+    let resp = await fetch(`http://localhost:${port}/hooks/called`, {
+      method: 'GET'
+    })
+    expect(hook1).toBe(1)
+    expect(hook2).toBe(1)
+    expect(resp.status).toBe(200)
+    expect(await resp?.text()).toBe('handled')
+  })
+})