dx-server 0.8.3 → 0.9.0

package/README.md

@@ -1,43 +1,126 @@
-# dx-server - modern, unopinionated, and satisfactory server
+# dx-server
+
+A modern, unopinionated, and performant Node.js server framework built on AsyncLocalStorage for elegant request/response handling without prop drilling.
+
+[![npm version](https://img.shields.io/npm/v/dx-server.svg)](https://www.npmjs.com/package/dx-server)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- 🚀 **Context-based architecture** - Access request/response from anywhere using AsyncLocalStorage
+- 🔗 **Chainable middleware** - Elegant middleware composition with [jchain](https://www.npmjs.com/package/jchain)
+- 🎯 **Type-safe** - Written in TypeScript with comprehensive type definitions
+- 🔄 **Express compatible** - Use existing Express middleware and applications
+- 📦 **Minimal dependencies** - Only one runtime dependency (`send` for static file serving, planned for removal)
+- 🛡️ **Built-in body parsing** - JSON, text, URL-encoded, and raw body parsing with size limits
+- 🗂️ **Static file serving** - Efficient static file handling with ETag support
+- 🔀 **Modern routing** - URLPattern-based routing (not Express patterns)
+
+## Installation
 
-## Install
 ```bash
+# npm
+npm install dx-server jchain
+
+# yarn
 yarn add dx-server jchain
+
+# pnpm
+pnpm add dx-server jchain
 ```
 
-## Usage
+### URLPattern Support
+
+dx-server uses the [URLPattern API](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern) for routing, which is natively supported in Node.js v19.0.0 and later.
 
-Check below sample with comment for more details.
+**For Node.js < 19.0.0**, you need to install a polyfill:
 
-Simple server
+```bash
+npm install urlpattern-polyfill
+```
+
+Then import it before using dx-server:
+
+```javascript
+// Add this at the top of your entry file
+import 'urlpattern-polyfill'
+
+// Then import dx-server
+import dxServer from 'dx-server'
+```
+
+To check if your runtime supports URLPattern natively:
+
+```javascript
+if (typeof URLPattern === 'undefined') {
+  console.log('URLPattern not supported, polyfill required')
+}
+```
+
+### Future Roadmap
+
+**Zero Dependencies**: The `send` package (currently used for static file serving) is planned for removal in a future version. This will make dx-server a true zero-dependency framework. Until then, if you don't need static file serving, the `send` dependency won't be loaded or affect your application.
+
+## Quick Start
+
+### Basic Server
 
 ```javascript
 import {Server} from 'node:http'
 import chain from 'jchain'
-import dxServer, {getReq, getRes, router, setHtml, setText,} from 'dx-server'
+import dxServer, {getReq, getRes, router, setHtml, setText} from 'dx-server'
 
 new Server().on('request', (req, res) => chain(
-		dxServer(req, res),
-		async next => {
-			try {
-				getRes().setHeader('Cache-Control', 'no-cache')
-				console.log(getReq().method, getReq().url)
-				await next()
-			} catch (e) {
-				console.error(e)
-				setHtml('internal server error', {status: 500})
-			}
-		},
-		router.get({
-			'/'() {setHtml('hello world')},
-			'/health'() {setText('ok')}
-		}),
-		() => setHtml('not found', {status: 404}),
-	)()
-).listen(3000, () => console.log('server is listening at 3000'))
+    dxServer(req, res),
+    async next => {
+        try {
+            // Access req/res from anywhere - no prop drilling!
+            getRes().setHeader('Cache-Control', 'no-cache')
+            console.log(getReq().method, getReq().url)
+            await next()
+        } catch (e) {
+            console.error(e)
+            setHtml('internal server error', {status: 500})
+        }
+    },
+    router.get({
+        '/'() {setHtml('hello world')},
+        '/health'() {setText('ok')}
+    }),
+    () => setHtml('not found', {status: 404}),
+)()).listen(3000, () => console.log('server is listening at 3000'))
+```
+
+### TypeScript Example
+
+```typescript
+import {Server} from 'node:http'
+import chain from 'jchain'
+import dxServer, {router, setJson, getJson} from 'dx-server'
+
+interface User {
+    id: number
+    name: string
+}
+
+new Server().on('request', (req, res) => chain(
+    dxServer(req, res),
+    router.post({
+        async '/api/users'() {
+            const body = await getJson<{name: string}>()
+            if (!body?.name) {
+                setJson({error: 'Name required'}, {status: 400})
+                return
+            }
+            const user: User = {id: 1, name: body.name}
+            setJson(user, {status: 201})
+        }
+    }),
+    () => setJson({error: 'Not found'}, {status: 404})
+)()).listen(3000)
 ```
 
-File server:
+### Static File Server
 
 ```javascript
 import {Server} from 'node:http'
@@ -47,15 +130,19 @@ import {resolve, dirname} from 'node:path'
 import {fileURLToPath} from 'node:url'
 
 new Server().on('request', (req, res) => chain(
-		dxServer(req, res),
-		chainStatic('/*', {root: resolve(dirname(fileURLToPath(import.meta.url)), 'public')}),
-		() => setHtml('not found', {status: 404}),
-	)()
-).listen(3000, () => console.log('server is listening at 3000'))
+    dxServer(req, res),
+    chainStatic('/*', {
+        root: resolve(dirname(fileURLToPath(import.meta.url)), 'public'),
+        index: ['index.html'],
+        dotfiles: 'deny'
+    }),
+    () => setHtml('not found', {status: 404}),
+)()).listen(3000)
 ```
 
-More complex server with express.
-This sample additionally requires: `yarn install express morgan`
+### Production-Ready Server with Express Integration
+
+This example requires: `npm install express morgan helmet cors`
 
 
 ```javascript
@@ -88,7 +175,7 @@ const authContext = makeDxContext(async () => {
 })
 
 const requireAuth = () => {
-	if (!authContext.value) throw new ServerError('unauthorized', 401, 'unauthorized')
+	if (!authContext.value) throw new ServerError('Unauthorized', 401, 'UNAUTHORIZED')
 }
 
 const serverChain = chain(
@@ -148,7 +235,7 @@ const serverChain = chain(
 	router.get('/', () => setHtml('ok')), // router.method() accepts 2 formats
 	router.get('/health', () => setText('ok')),
 	() => { // not found router
-		throw new ServerError('not found', 404, 'not_found')
+		throw new ServerError('Not found', 404, 'NOT_FOUND')
 	},
 )
 
@@ -169,196 +256,426 @@ await promisify(tcpServer.listen.bind(tcpServer))(3000)
 console.log('server is listening at 3000')
 ```
 
-## Note:
+## Core Concepts
+
+### Context-Based Architecture
+
+dx-server uses Node.js AsyncLocalStorage to provide request/response context globally, eliminating prop drilling:
+
+```javascript
+// Access request/response from anywhere
+import {getReq, getRes} from 'dx-server'
+
+function someDeepFunction() {
+    const req = getReq()  // No need to pass req through multiple layers
+    const res = getRes()
+    res.setHeader('X-Custom', 'value')
+}
+```
+
+### Lazy Body Parsing
 
-`getBuffer, getJson, getRaw, getText, getUrlEncoded, getQuery` are all asynchronous functions.
-The associated results are calculated in the first time they are called and cached for subsequent calls.
+Body parsing functions are asynchronous and cached per request:
 
-If you want to get these values synchronously, chain it, like follows:
 ```javascript
-import {getJson} from 'dx-server'
+import {getJson, getText, getBuffer, getUrlEncoded} from 'dx-server'
+
+// Async usage (lazy-loaded and cached)
+const json = await getJson()
+const text = await getText()
 
+// Sync usage (requires chaining)
 chain(
-	getJson.chain(/*option*/), // json body is parsed and stored in context in every request
-	next => {
-		console.log(getJson.value) // json body can be accessed synchronously
-		return next()
-	}
+    getJson.chain({bodyLimit: 1024 * 1024}), // 1MB limit
+    next => {
+        console.log(getJson.value) // Access synchronously
+        return next()
+    }
 )
 ```
 
-Context can be created using `makeDxContext` function:
+### Custom Contexts
+
+Create reusable context objects with `makeDxContext`:
 
 ```javascript
-import {makeDxContext} from 'dx-server'
+import {makeDxContext, getReq} from 'dx-server'
 
-const authContext = makeDxContext(() => {
-	if (getReq().headers.authorization) return {id: 1, name: 'joe (authorized)'}
+// Create auth context
+const authContext = makeDxContext(async () => {
+    const token = getReq().headers.authorization
+    if (!token) return null
+    return await validateToken(token) // Your validation logic
 })
-const requireAuth = () => {
-	if (!authContext.value) throw new Error('unauthorized')
-}
-chain(
-	authContext.chain(),
-	next => {
-		requireAuth()
-		return next()
-	}
-)
-// or await authContext() to lazy load the context and don't require chaining authContext.chain()
+
+// Use in middleware
 chain(
-	async next => {
-		console.log(await authContext())
-		return next()
-	}
+    authContext.chain(), // Initialize for all requests
+    next => {
+        if (!authContext.value) {
+            setJson({error: 'Unauthorized'}, {status: 401})
+            return
+        }
+        return next()
+    }
 )
+
 ```
 
-# API References
-All exported APIs:
+## API Reference
+
+### Main Exports
+
 ```javascript
 import dxServer, {
-	getReq, getRes, getBuffer, getJson, getRaw, getText, getUrlEncoded, getQuery,
-	setHtml, setJson, setText, setEmpty, setBuffer, setRedirect, setNodeStream, setWebStream, setFile,
-	router, connectMiddlewares, chainStatic, makeDxContext
+    // Request/Response access
+    getReq, getRes,
+    
+    // Request body parsers
+    getBuffer, getJson, getRaw, getText, getUrlEncoded, getQuery,
+    
+    // Response setters
+    setHtml, setJson, setText, setEmpty, setBuffer, setRedirect, 
+    setNodeStream, setWebStream, setFile,
+    
+    // Utilities
+    router, connectMiddlewares, chainStatic, makeDxContext
 } from 'dx-server'
-import {expressApp, expressRouter} from 'dx-server/express' // requires express installed
+
+// Express integration (requires express installed)
+import {expressApp, expressRouter} from 'dx-server/express'
+
+// Low-level helpers
 import {
-	setBufferBodyDefaultOptions,
-	bufferFromReq, jsonFromReq, rawFromReq, textFromReq, urlEncodedFromReq, queryFromReq,
+    setBufferBodyDefaultOptions,
+    bufferFromReq, jsonFromReq, rawFromReq, textFromReq, 
+    urlEncodedFromReq, queryFromReq,
 } from 'dx-server/helpers'
 ```
 
-## Basic
-```javascript
-import dxServer, {
-	getReq, getRes, getBuffer, getJson, getRaw, getText, getUrlEncoded, getQuery,
-	setHtml, setJson, setText, setEmpty, setBuffer, setRedirect, setNodeStream, setWebStream, setFile,
-	makeDxContext
-} from 'dx-server'
+### Core Functions
+
+#### Request/Response Access
+- **`getReq()`** - Get the current request object
+- **`getRes()`** - Get the current response object
+
+#### Body Parsers
+All body parsers are async, lazy-loaded, and cached per request:
+
+- **`getJson(options?)`** - Parse JSON body (requires `Content-Type: application/json`)
+- **`getText(options?)`** - Parse text body (requires `Content-Type: text/plain`)
+- **`getBuffer(options?)`** - Get raw buffer
+- **`getRaw(options?)`** - Get raw body (requires `Content-Type: application/octet-stream`)
+- **`getUrlEncoded(options?)`** - Parse URL-encoded form (requires `Content-Type: application/x-www-form-urlencoded`)
+- **`getQuery(options?)`** - Parse query string parameters
+
+Options:
+```typescript
+{
+    bodyLimit?: number      // Max body size in bytes (default: 100KB)
+    urlEncodedParser?: (search: string) => any
+    queryParser?: (search: string) => any
+}
 ```
 
-- `getReq()`, `getRes()`: get request and response objects from anywhere.
+#### Response Setters
+- **`setJson(data, {status?, headers?})`** - Send JSON response
+- **`setHtml(html, {status?, headers?})`** - Send HTML response
+- **`setText(text, {status?, headers?})`** - Send plain text
+- **`setBuffer(buffer, {status?, headers?})`** - Send buffer
+- **`setFile(path, options?)`** - Send file
+- **`setNodeStream(stream, {status?, headers?})`** - Send Node.js stream
+- **`setWebStream(stream, {status?, headers?})`** - Send Web stream
+- **`setRedirect(url, {status?, headers?})`** - Redirect response
+- **`setEmpty({status?, headers?})`** - Send empty response
+
+#### Context Management
+- **`makeDxContext(fn)`** - Create a custom context object
+  ```javascript
+  const ctx = makeDxContext(() => computeValue())
+  
+  // Access value
+  await ctx()        // Lazy load
+  ctx.value          // Sync access (after loading)
+  ctx.get(req)       // Get for specific request
+  
+  // Set value
+  ctx.value = newValue
+  ctx.set(req, newValue)
+  ```
+
+#### Middleware Utilities
+- **`connectMiddlewares(...middlewares)`** - Use Connect/Express middleware
+- **`chainStatic(pattern, options)`** - Serve static files
+  ```javascript
+  chainStatic('/public/*', {
+      root: '/path/to/files',
+      index: ['index.html'],
+      dotfiles: 'deny',
+      etag: true,
+      lastModified: true
+  })
+  ```
+
+### Routing
+
+dx-server uses [URLPattern API](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern) for routing, which differs from Express patterns:
+
+```javascript
+import {router} from 'dx-server'
+
+// Single route
+router.get('/users/:id', ({matched}) => {
+    const {id} = matched.pathname.groups
+    setJson({userId: id})
+})
 
-- `getBuffer()`, `getJson()`, `getRaw()`, `getText()`, `getUrlEncoded()`, `getQuery()`: get parsed request body, raw body, text body, url encoded body, query string from anywhere.
-These are DX context object, can be used as follows:
-	- `const json = await getJson()`: lazily load the context, once loaded, it is cached for subsequent calls.
-No chaining is required.
-  - Chain it to get the value synchronously: `chain(getJson.chain(), next => console.log(getJson.value))`. Note that the value is calculated in every request.
-- `ctx = makeDxContext(fn)`: create a DX context object.
-`fn` is called once per request to calculate the value.
-The value is cached for subsequent calls.
+// Multiple routes
+router.post({
+    '/api/users': () => { /* create user */ },
+    '/api/users/:id': ({matched}) => { /* update user */ },
+    '/api/users/:id/posts': ({matched}) => { /* get user posts */ }
+})
+
+// All HTTP methods supported
+router.get(pattern, handler)
+router.post(pattern, handler)
+router.put(pattern, handler)
+router.delete(pattern, handler)
+router.patch(pattern, handler)
+router.head(pattern, handler)
+router.options(pattern, handler)
+router.all(pattern, handler)  // Any method
+
+// Custom method
+router.method('CUSTOM', pattern, handler)
+
+// With prefix option
+router.get({
+    '/users': listUsers,
+    '/users/:id': getUser
+}, {prefix: '/api'})  // Routes become /api/users, /api/users/:id
+```
 
-- Context value can be accessed by:
+#### URLPattern vs Express Patterns
 
-	- `const value = await ctx()`: lazily load the context, once loaded, it is cached for subsequent calls.
-	- `const value = ctx.value`: get the value synchronously. Note that the value must be fetched at least once before via `await ctx()` or by chaining `chain(ctx.chain())`.
-  - `const value = ctx.get(req)`: similar condition as `ctx.value`.
+| Pattern | URLPattern | Express |
+|---------|------------|---------|
+| Wildcard | `/api/*` | `/api/*` or `/api/(.*)` |
+| Optional trailing slash | `{/}?` | `/path/?` |
+| Named params | `/:id` | `/:id` |
+| Optional params | `/:id?` | `/:id?` |
 
-- Context value can be set or overridden by:
+**Important differences:**
+- `'/foo'` matches `/foo` but NOT `/foo/`
+- `'/foo/'` matches `/foo/` but NOT `/foo`
+- Use `'/foo{/}?'` to match both
 
-	- `ctx.value = value`.
-	- `ctx.set(req, value)`.
+### Express Integration
 
-- `setHtml`, `setJson`, `setText`, `setEmpty`, `setBuffer`, `setRedirect`, `setNodeStream`, `setWebStream`, `setFile`: set response body.
+dx-server seamlessly integrates with Express applications and middleware:
 
-- `connectMiddlewares(...middlewares)`: connect middlewares. For example:
 ```javascript
-import {connectMiddlewares} from 'dx-server'
-import morgan from 'morgan'
+import {expressApp, expressRouter} from 'dx-server/express'
+import express from 'express'
 import cors from 'cors'
+import helmet from 'helmet'
 
-connectMiddlewares(
-	morgan('common'),
-	cors(),
+chain(
+    // Use entire Express app
+    await expressApp(app => {
+        app.set('trust proxy', true)
+        app.set('json spaces', 2)
+        app.use(helmet())
+        app.use('/static', express.static('public'))
+    }),
+    
+    // Or use Express router
+    expressRouter(router => {
+        router.use(cors())
+        router.get('/legacy', (req, res) => {
+            res.json({message: 'Express route'})
+        })
+    })
 )
 ```
 
-- `chainStatic(path, options)`: serve static files. For example:
+### Low-Level Helpers
+
+Pure functions for custom implementations:
+
 ```javascript
-import {chainStatic} from 'dx-server'
-import {resolve, dirname} from 'node:path'
-import {fileURLToPath} from 'node:url'
+import {
+    setBufferBodyDefaultOptions,
+    bufferFromReq, jsonFromReq, rawFromReq, 
+    textFromReq, urlEncodedFromReq, queryFromReq
+} from 'dx-server/helpers'
 
+// Set global defaults
+setBufferBodyDefaultOptions({
+    bodyLimit: 10 * 1024 * 1024, // 10MB
+    queryParser: (search) => myCustomParser(search)
+})
+
+// Use directly with req/res (no context required)
+const json = await jsonFromReq(req, {bodyLimit: 1024})
+const query = queryFromReq(req)
+```
+
+## Security Considerations
+
+### Body Size Limits
+Always set appropriate body size limits to prevent DoS attacks:
+
+```javascript
 chain(
-	chainStatic('/assets/*', {
-		root: resolve(dirname(fileURLToPath(import.meta.url)), 'public'),
-		getPathname(matched) {
-			return new URL(getReq().url, 'http://localhost').pathname.slice('/assets'.length)
-		},
-	}),
+    getJson.chain({bodyLimit: 1024 * 1024}), // 1MB limit
+    // or globally:
+    dxServer(req, res, {bodyLimit: 5 * 1024 * 1024}) // 5MB
 )
 ```
 
-## Routing
+### Error Handling
+Never expose internal errors to clients:
+
 ```javascript
-import {router} from 'dx-server'
-```
+class AppError extends Error {
+    constructor(message, status = 400, code = 'ERROR') {
+        super(message)
+        this.status = status
+        this.code = code
+    }
+}
 
-- `router.get`, `router.post`, `router.put`, `router.delete`, `router.patch`, `router.head`, `router.options`, `router.connect`, `router.trace`: create router.
-	These functions accept 2 formats:
-	- `router.get(routes: {[pattern: string]: Route}, options: RouterOptions)`: create multiple routes.
-	- `router.get(pattern: string, handler: Route, options: RouterOptions)`: create route for GET method.
+chain(
+    async next => {
+        try {
+            await next()
+        } catch (error) {
+            if (error instanceof AppError) {
+                setJson({error: error.message, code: error.code}, {status: error.status})
+            } else {
+                console.error(error) // Log for debugging
+                setJson({error: 'Internal server error'}, {status: 500})
+            }
+        }
+    }
+)
+```
 
-- `router.all(...)`: same as `router.get()` but for any method.
-- `router.method()`: create router with custom method. Similar to `router.get()`, this function accepts 2 formats.
-	- `router.method(method: string, routes: {[pattern: string]: Route}, options: RouterOptions)`: create multiple routes.
-	- `router.method(method: string, pattern: string, handler: Route, options: RouterOptions)`: create route for `method` method.
+### Input Validation
+Always validate input data:
 
-`RouterOptions` is defined as follows:
-```typescript
-interface RouterOptions {
-	prefix?: string
-}
+```javascript
+router.post('/api/users', async () => {
+    const data = await getJson()
+    
+    // Validate
+    if (!data?.email || !isValidEmail(data.email)) {
+        throw new AppError('Invalid email', 400, 'INVALID_EMAIL')
+    }
+    
+    // Process...
+})
 ```
 
-Patterns are matched using [URLPattern](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern).
-This does not always match the same as ExpressJS.
-For example, to match any path prefixed with `/api/`, use `/api/*`.
-Note the following:
-- `''` matches nothing.
-- `'/'` matches both https://example.com and https://example.com/.
-- `'/foo'` matches https://example.com/foo but not https://example.com/foo/.
-- `'/foo/'` matches https://example.com/foo/ but not https://example.com/foo.
+### Security Headers
+Use security middleware:
 
-`Route` is defined as follows:
-```typescript
-interface RouteContext {
-	matched: URLPatternResult // result returned from URLPattern.exec(). To get params: matched.pathname.groups
-	next(): any
-}
-type Route = (context: RouteContext) => any
+```javascript
+import helmet from 'helmet'
+import cors from 'cors'
+
+chain(
+    connectMiddlewares(
+        helmet(),
+        cors({
+            origin: process.env.ALLOWED_ORIGINS?.split(','),
+            credentials: true
+        })
+    )
+)
 ```
 
-## Helpers
+## Advanced Examples
+
+### File Upload with Busboy
 ```javascript
-import {
-	setBufferBodyDefaultOptions,
-	bufferFromReq, jsonFromReq, rawFromReq, textFromReq, urlEncodedFromReq, queryFromReq,
-} from 'dx-server/helpers'
+import busboy from 'busboy'
+
+router.post('/upload', () => {
+    const req = getReq()
+    const bb = busboy({headers: req.headers, limits: {fileSize: 10 * 1024 * 1024}})
+    
+    bb.on('file', (name, file, info) => {
+        // Handle file stream
+    })
+    
+    req.pipe(bb)
+})
 ```
 
-Helpers are all pure functions, and do not rely on any context.
-These functions are independent of the context and can be used anywhere, even outside of this package.
-They require request and response objects to be passed.
+### WebSocket Upgrade
+```javascript
+import {WebSocketServer} from 'ws'
+
+const wss = new WebSocketServer({noServer: true})
+
+server.on('upgrade', (request, socket, head) => {
+    if (request.url === '/ws') {
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            wss.emit('connection', ws, request)
+        })
+    }
+})
+```
 
-## ExpressJS
+### Rate Limiting
 ```javascript
-import {expressApp, expressRouter} from 'dx-server/express' // requires express installed
+import rateLimit from 'express-rate-limit'
 
 chain(
-	await expressApp(app => {// any express feature can be used. This requires express installed, with for e.g., `yarn add express`
-		app.set('trust proxy', true)
-		if (process.env.NODE_ENV !== 'production') app.set('json spaces', 2)
-		app.use('/public', express.static('public'))
-	}),
-	expressRouter(router => {
-		router.use(cors())
-	}),
+    connectMiddlewares(
+        rateLimit({
+            windowMs: 15 * 60 * 1000, // 15 minutes
+            max: 100 // limit each IP to 100 requests per windowMs
+        })
+    )
 )
 ```
 
-## Other functionalities
-- Download file: set the [Content-Disposition](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition) header.
-- Upload file: recommend [busboy](https://www.npmjs.com/package/busboy) package.
-- Cookie: recommend [cookie](https://www.npmjs.com/package/cookie) package.
+## Performance Tips
+
+1. **Use lazy body parsing** - Only parse bodies when needed
+2. **Enable compression** at reverse proxy level (nginx, CDN)
+3. **Use streaming** for large responses:
+   ```javascript
+   import {createReadStream} from 'fs'
+   setNodeStream(createReadStream('large-file.pdf'))
+   ```
+4. **Cache contexts** that are expensive to compute
+5. **Use `chainStatic` with proper cache headers** for static assets
+
+## Migration from Express
+
+```javascript
+// Express
+app.get('/users/:id', (req, res) => {
+    const {id} = req.params
+    res.json({userId: id})
+})
+
+// dx-server
+router.get('/users/:id', ({matched}) => {
+    const {id} = matched.pathname.groups
+    setJson({userId: id})
+})
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT © [Sang Tran](https://github.com/tranvansang)

package/cjs/router.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.router = void 0;
 const dx_js_1 = require("./dx.js");
-require("urlpattern-polyfill");
 const bodyHelpers_js_1 = require("./bodyHelpers.js");
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods
 const allMethods = [
@@ -44,4 +43,4 @@ exports.router = {
 };
 for (const method of allMethods)
     exports.router[method] = exports.router.method.bind(exports.router, method);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm/router.js

@@ -1,5 +1,4 @@
 import { getReq } from './dx.js';
-import 'urlpattern-polyfill';
 import { urlFromReq } from './bodyHelpers.js';
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods
 const allMethods = [
@@ -41,4 +40,4 @@ export const router = {
 };
 for (const method of allMethods)
     router[method] = router.method.bind(router, method);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dx-server",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "main": "./cjs/index.js",
   "homepage": "https://github.com/tranvansang/dx-server",
   "repository": "https://github.com/tranvansang/dx-server",
@@ -24,6 +24,9 @@
     }
   },
   "type": "module",
+  "engines": {
+    "node": ">=16.0.0"
+  },
   "scripts": {
     "prepublishOnly": "./compile.sh"
   },
@@ -34,7 +37,6 @@
     "typescript": "^5.4.5"
   },
   "dependencies": {
-    "send": "^0.18.0",
-    "urlpattern-polyfill": "^10.0.0"
+    "send": "^0.18.0"
   }
 }

package/cjs/router.d.ts

@@ -1,43 +0,0 @@
-import { Chainable } from './dx.js';
-import 'urlpattern-polyfill';
-interface URLPatternOptions {
-}
-interface RouteContext {
-    matched: URLPatternResult;
-    next(): any;
-}
-interface Route {
-    (context: RouteContext): any;
-}
-interface Routes {
-    [k: string]: Route;
-}
-interface RouterOptions extends URLPatternOptions {
-    prefix?: string;
-}
-type Router = {
-    patch(routes: Routes, options?: RouterOptions): Chainable;
-    patch(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    trace(routes: Routes, options?: RouterOptions): Chainable;
-    trace(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    options(routes: Routes, options?: RouterOptions): Chainable;
-    options(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    connect(routes: Routes, options?: RouterOptions): Chainable;
-    connect(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    delete(routes: Routes, options?: RouterOptions): Chainable;
-    delete(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    put(routes: Routes, options?: RouterOptions): Chainable;
-    put(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    post(routes: Routes, options?: RouterOptions): Chainable;
-    post(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    head(routes: Routes, options?: RouterOptions): Chainable;
-    head(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    get(routes: Routes, options?: RouterOptions): Chainable;
-    get(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    all(routes: Routes, options?: RouterOptions): Chainable;
-    all(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    method(method: string, routes: Routes, options?: RouterOptions): Chainable;
-    method(method: string, pattern: string, route: Route, options?: RouterOptions): Chainable;
-};
-export declare const router: Router;
-export {};

package/cjs/static.d.ts

@@ -1,5 +0,0 @@
-import { Chainable } from './dx.js';
-import { SendOptions } from 'send';
-export declare function chainStatic(pattern: string, { getPathname, ...options }: SendOptions & {
-    getPathname?(matched: URLPatternResult): string;
-}): Chainable;

package/esm/router.d.ts

@@ -1,43 +0,0 @@
-import { Chainable } from './dx.js';
-import 'urlpattern-polyfill';
-interface URLPatternOptions {
-}
-interface RouteContext {
-    matched: URLPatternResult;
-    next(): any;
-}
-interface Route {
-    (context: RouteContext): any;
-}
-interface Routes {
-    [k: string]: Route;
-}
-interface RouterOptions extends URLPatternOptions {
-    prefix?: string;
-}
-type Router = {
-    patch(routes: Routes, options?: RouterOptions): Chainable;
-    patch(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    trace(routes: Routes, options?: RouterOptions): Chainable;
-    trace(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    options(routes: Routes, options?: RouterOptions): Chainable;
-    options(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    connect(routes: Routes, options?: RouterOptions): Chainable;
-    connect(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    delete(routes: Routes, options?: RouterOptions): Chainable;
-    delete(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    put(routes: Routes, options?: RouterOptions): Chainable;
-    put(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    post(routes: Routes, options?: RouterOptions): Chainable;
-    post(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    head(routes: Routes, options?: RouterOptions): Chainable;
-    head(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    get(routes: Routes, options?: RouterOptions): Chainable;
-    get(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    all(routes: Routes, options?: RouterOptions): Chainable;
-    all(pattern: string, route: Route, options?: RouterOptions): Chainable;
-    method(method: string, routes: Routes, options?: RouterOptions): Chainable;
-    method(method: string, pattern: string, route: Route, options?: RouterOptions): Chainable;
-};
-export declare const router: Router;
-export {};

package/esm/static.d.ts

@@ -1,5 +0,0 @@
-import { Chainable } from './dx.js';
-import { SendOptions } from 'send';
-export declare function chainStatic(pattern: string, { getPathname, ...options }: SendOptions & {
-    getPathname?(matched: URLPatternResult): string;
-}): Chainable;