@techiev2/vajra 1.2.0 → 1.3.0

package/examples/api.js

@@ -5,26 +5,39 @@ async function getUsers(query = {}) {
   return (await fetch(`https://jsonplaceholder.typicode.com/users?${encode(query)}`)).json()
 }
 
-const { get, post, use, start, setProperty, log } = Vajra.create();
+const { get, post, put, use, start, setProperty, log } = Vajra.create();
 
 setProperty({ viewRoot: `${import.meta.dirname}/views` })
 
-use((req, res, next) => {
-  log(`${req.method} ${req.url}`)
-  next();
-});
+// use((req, res, next) => {
+//   log(`${req.method} ${req.url}`)
+//   next();
+// });
 
-get('/', (req, res) => {
+get('/', ({ query = {} }, res) => {
+  const { version } = query
   res.cookie('session', 'abc');
   res.cookie('theme', 'dark');
   res.cookie('user', 'test');
-  res.writeMessage('Hello from Vajra ⚡');
+  res.writeMessage(version ? `Hello from Vajra (v${version}) ⚡` : 'Hello from Vajra ⚡');
+});
+
+get('/query', ({ query, params }, res) => {
+  return res.json({ query, params, now: new Date().getTime() })
 });
 
 post('/upload', (req, res) => {
   res.json({ received: true, filesCount: req.files.length, files: req.files, body: req.body });
 });
 
+post('/post', ({ body, query, params }, res) => {
+  return res.json({ query, params, body, now: new Date().getTime() })
+})
+
+put('/users/:id', ({ params, query, body }, res) => {
+  return res.json({ params, query, body, now: new Date().getTime() })
+})
+
 start({ port: 4002 }, () => {
   console.log('Ready at http://localhost:4002');
 });

package/index.js

@@ -1,5 +1,5 @@
 import { createServer } from 'node:http'
-import { readFile, access } from 'fs/promises'
+import { readFile, access } from 'node:fs/promises'
 
 const BLOCK_MATCHER=/{{\s*#\s*(?<grpStart>\w+)\s*}}\s*(?<block>.*?)\s*{{\s*\/\s*(?<grpEnd>\w+)\s*}}/gmsi; const INNER_BLOCK_MATCHER = /{\s*(.*?)\s*}/gmsi
 const LOOP_MATCHER=/({\s*\w+@\s*})/gmis
@@ -88,12 +88,11 @@ export default class Vajra {
         req.cookies = Object.fromEntries((req.headers.Cookie || req.headers.cookie || '').split(/;\s*/).map((k) => k.split('=')).map(([k, v]) => [k.trim(), decodeURIComponent(v).trim()]))
       })
       async function handleRoute() {
-        let match_; const directHandler = (Vajra.#straightRoutes[req.url] || {})[req.method.toLowerCase()]
+        let _url = req.url.split('?')[0]; if (_url.endsWith('/')) _url = _url.split('/').slice(0, -1).join('/')
+        let match_; const directHandler = (Vajra.#straightRoutes[_url] || Vajra.#straightRoutes[`${_url}/`] || {})[req.method.toLowerCase()]
         if (directHandler) { try { await directHandler(req, res); if (!res.sent && !res.writableEnded) res.end() } catch (error) { return default_500(req, res, error) }; return }
         Object.entries(Vajra.#routes).map(([route, handler]) => {
-          if (match_) { return }
-          if (route === '/' && route !== req.url.split('?')[0]) { return } // FIXME: The case of a bare '/' is not handled right due to the pattern addition.
-          const match = new RegExp(route).exec(req.url); if (!!match && handler[req.method.toLowerCase()]) { match_ = handler; Object.assign(req.params, match.groups); return }
+          if (match_) { return }; const match = new RegExp(route).exec(req.url); if (!!match && handler[req.method.toLowerCase()]) { match_ = handler; Object.assign(req.params, match.groups); return }
         })
         if (!match_) { return default_404(req, res) }
         if (!match_[req.method.toLowerCase()]) { return default_405(req, res) }
@@ -106,13 +105,11 @@ export default class Vajra {
       const paramMatcher = /.*?(?<param>\:[a-zA-Z]{1,})/g; let pathMatcherStr = path
       path.matchAll(paramMatcher).forEach(match => pathMatcherStr = pathMatcherStr.replace(match.groups.param, `{0,1}(?<${match.groups.param.slice(1)}>\\w{1,})`))
       if (path !== '/' && pathMatcherStr.endsWith('/')) { pathMatcherStr = pathMatcherStr.replace(/(\/)$/, '/?') }
-      /*pathMatcherStr = `^${pathMatcherStr}$`; */Vajra.#routes[pathMatcherStr] = Object.assign(Vajra.#routes[pathMatcherStr] || {}, {[method]: handler})
-      if (!paramMatcher.exec(path)?.groups) { Vajra.#straightRoutes[pathMatcherStr] = Object.assign(Vajra.#straightRoutes[pathMatcherStr] || {}, {[method]: handler}) }
-      return defaults
+      if (!paramMatcher.exec(path)?.groups) { Vajra.#straightRoutes[pathMatcherStr] = Object.assign(Vajra.#straightRoutes[pathMatcherStr] || {}, { [method]: handler }); return }
+      Vajra.#routes[pathMatcherStr] = Object.assign(Vajra.#routes[pathMatcherStr] || {}, {[method]: handler}); return defaults
     }
     function use(fn) {
-      if (typeof fn !== "function") { throw new Error(`${fn} is not a function. Can't use as middleware`) }
-      Vajra.#middlewares.push(fn);  return defaults
+      if (typeof fn !== "function") { throw new Error(`${fn} is not a function. Can't use as middleware`) }; Vajra.#middlewares.push(fn);  return defaults
     }
     const defaults = Object.freeze(Object.assign({}, { use, setProperty, start, log }, Object.fromEntries('get__post__put__patch__delete__head__options'.split('__').map((method) => [method, (...args) => register(method, ...args)])))); return Object.assign({}, { start }, defaults)
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techiev2/vajra",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Blazing-fast, zero-dependency Node.js server with routing, middleware, multipart uploads, and templating. 111 lines · ~95k req/s · ~52 MB idle.",
   "keywords": [
     "http-server",
@@ -38,6 +38,6 @@
     "test": "tests"
   },
   "scripts": {
-    "test": "tests/tests.js"
+    "test": "node --watch tests/tests.js"
   }
 }

package/tests/tests.js

@@ -1,55 +1,58 @@
 import assert from 'node:assert';
 import { encode } from 'node:querystring';
+import pkg from '../package.json' with {type: 'json'}
 import { suite, test } from 'node:test';
 
-async function getJSON(url, method = 'GET', body) {
+async function getResponse(url, method = 'GET', body) {
   return (await fetch(url, !!body ?
     { method, headers: {'Content-Type': 'application/json'}, body: JSON.stringify(body) }
     : { method, headers: {'Content-Type': 'application/json'} }
-  )).json()
+  ))
+}
+
+async function getJSON(url, method = 'GET', body) {
+  return (await getResponse(url, method, body)).json()
 }
 
-suite('Test HTTP API at port 4000', () => {  
-  const BASE_URL = 'http://localhost:4000'
+suite('Test HTTP API at port 4002', () => {
+  const BASE_URL = 'http://localhost:4002'
   suite('Test HTTP GET', () => {
     test('Basic HTTP GET to respond with a now and empty query/params', async () => {
-      const { now, query: res_query, params: res_params } = await getJSON(BASE_URL)
-      assert.equal(!!now, true)
-      assert.deepEqual(res_query, {})
-      assert.deepEqual(res_params, {})
+      assert.deepEqual((await (await getResponse(BASE_URL)).text()), 'Hello from Vajra ⚡')
+    })
+    test('Basic HTTP GET to respond with custom message given version query param', async () => {
+      const { version } = pkg
+      assert.deepEqual((await (await getResponse(`${BASE_URL}?${encode({ version })}`)).text()), `Hello from Vajra (v${version}) ⚡`)
     })
     test('Basic HTTP GET to respond with a now, and query params', async () => {
       const query = { id: 1, user: 'test' }
-      const { now, query: res_query, params: res_params } = await getJSON(`${BASE_URL}?${encode(query)}`)
+      const { now, query: res_query, params: res_params } = await getJSON(`${BASE_URL}/query?${encode(query)}`)
       assert.equal(!!now, true)
       assert.deepEqual(res_query, query)
       assert.deepEqual(res_params, {})
     })
   })
   suite('Test HTTP POST', () => {
-    // test('Basic HTTP POST to respond with a now and body', async () => {
-    //   const query = { id: 1, user: 'test' }
-    //   const body = { name: 'user' }
-    //   const { now, query: res_query, body: res_body } =  await getJSON(`${BASE_URL}`, 'POST', body)
-    //   assert.equal(!!now, true)
-    //   assert.deepEqual(res_query, query)
-    //   assert.deepEqual(res_body, body)
-    // })
-    test('Basic HTTP POST with a param shoudl return a 404', async () => {
-      // const { now, query: res_query, body: res_body } = 
+    test('Basic HTTP POST to respond with a now and body', async () => {
+      const body = { name: 'user' }
+      const json = await getJSON(`${BASE_URL}/post`, 'POST', body)
+      const { now, body: res_body } = json
+      assert.equal(!!now, true)
+      assert.deepEqual(res_body, body)
+    })
+    test('Basic HTTP POST with a param (unmapped route) should return a 404', async (done) => {
+      const query = { test: 'random' }
       const body = { name: 'test' }
-      const json = await getJSON(`${BASE_URL}/users/1?test=random`, 'POST', body)
-      console.log(json)
-      // assert.equal(!!now, true)
-      // assert.deepEqual(res_query, query)
-      // assert.deepEqual(res_body, body)
+      const response = await getResponse(`${BASE_URL}/post/1/?${encode(query)}`, 'POST', body)
+      assert.equal(response.status, 404)
     })
   })
   suite('Test HTTP PUT', () => {
     test('Basic HTTP PUT to respond with a now, query, params, and body', async () => {
       const params = { id : 1 }
       const body = { name: 'user' }
-      const { now, params: res_params, body: res_body} = await getJSON(`${BASE_URL}/users/${params.id}`, 'PUT', body)
+      const json = await getJSON(`${BASE_URL}/users/${params.id}`, 'PUT', body)
+      const { now, params: res_params, body: res_body} = json
       assert.equal(!!now, true)
       assert.deepEqual(res_params, params)
       assert.deepEqual(res_body, body)