instaserve 1.1.4 → 1.1.6

package/README.md

@@ -107,6 +107,39 @@ export default {
 }
 ```
 
+### Method-Specific Routes
+
+Routes can be defined with HTTP method prefixes to handle different methods on the same path. Supported methods: `GET`, `POST`, `PUT`, `DELETE`.
+
+```javascript
+export default {
+    // Method-specific routes
+    'POST /users': (req, res, data) => {
+        return { message: 'Create user', data }
+    },
+    
+    'GET /users': (req, res, data) => {
+        return { message: 'Get users' }
+    },
+    
+    'PUT /users': (req, res, data) => {
+        return { message: 'Update user', data }
+    },
+    
+    'DELETE /users': (req, res, data) => {
+        return { message: 'Delete user', data }
+    },
+    
+    // Path-only routes still work (backward compatible)
+    // These match any HTTP method
+    hello: (req, res, data) => {
+        return { message: 'Hello World' }
+    }
+}
+```
+
+Method-specific routes take precedence over path-only routes. If no method-specific route matches, the server falls back to path-only route matching.
+
 ### Special Routes (Middleware)
 
 Routes starting with `_` are middleware functions that run on **every request** before the main route handler. They are useful for:
@@ -152,6 +185,25 @@ Each route function receives:
   - URL query parameters
   - Form data
 
+### Returning Status Codes
+
+Routes can return a 3-digit number (100-999) to set the HTTP status code with an empty response body:
+
+```javascript
+export default {
+    'GET /notfound': () => 404,
+    'GET /unauthorized': () => 401,
+    'GET /forbidden': () => 403,
+    'GET /teapot': () => 418, // I'm a teapot
+    'GET /created': () => 201
+}
+```
+
+Routes can also return:
+- **Strings** - Sent as plain text response
+- **Objects** - Automatically serialized as JSON
+- **Status codes** - 3-digit numbers (100-999) set HTTP status with empty body
+
 ### Example Routes File
 
 ```javascript
@@ -163,7 +215,19 @@ export default {
         return false // Continue to next route
     },
 
-    // API endpoint
+    // Method-specific routes
+    'POST /api/users': (req, res, data) => {
+        return { status: 'created', data }
+    },
+    
+    'GET /api/users': (req, res, data) => {
+        return { status: 'ok', users: [] }
+    },
+    
+    'GET /api/notfound': () => 404,
+    'GET /api/unauthorized': () => 401,
+
+    // Path-only route (matches any method)
     api: (req, res, data) => {
         return { status: 'ok', data }
     },

package/instaserve

@@ -59,6 +59,15 @@ if (args[0] === 'generate-routes') {
 
     api: (req, res, data) => {
         return { message: 'API endpoint', data }
+    },
+
+    // Method-specific routes (POST, GET, PUT, DELETE)
+    'POST /users': (req, res, data) => {
+        return { message: 'Create user', data }
+    },
+
+    'GET /users': (req, res, data) => {
+        return { message: 'Get users' }
     }
 }
 `

package/module.mjs

@@ -51,6 +51,21 @@ export default async function (routes, port = params.port || 3000, ip = params.i
         let sdata = '', rrurl = r.url || ''
         let responseSent = false
         
+        // Helper to check if value is a 3-digit HTTP status code
+        const isStatusCode = (val) => {
+            return typeof val === 'number' && val >= 100 && val <= 999 && Math.floor(val) === val
+        }
+        
+        // Helper to send response, handling status codes
+        const sendResponse = (result) => {
+            if (isStatusCode(result)) {
+                s.writeHead(result)
+                s.end()
+            } else {
+                s.end(typeof result === 'string' ? result : JSON.stringify(result))
+            }
+        }
+        
         r.on('data', (s) => sdata += s.toString().trim())
         r.on('end', (x) => {
             try {
@@ -68,7 +83,7 @@ export default async function (routes, port = params.port || 3000, ip = params.i
                         const result = routes[k](r, s, data)
                         if (result && !responseSent) {
                             responseSent = true
-                            s.end(typeof result === 'string' ? result : JSON.stringify(result))
+                            sendResponse(result)
                         }
                         return result
                     })
@@ -84,11 +99,40 @@ export default async function (routes, port = params.port || 3000, ip = params.i
 
                 const urlParts = rrurl.split('/')
                 const url = urlParts.length > 1 ? urlParts[1].split('?')[0] : ''
-                if (routes[url]) {
-                    const resp = routes[url](r, s, data)
+                const method = (r.method || 'GET').toUpperCase()
+                
+                // Try method-specific route first (e.g., "POST /endp", "GET /")
+                const methodRoute = url ? `${method} /${url}` : `${method} /`
+                let routeHandler = routes[methodRoute]
+                
+                // If no exact match, check if any method-specific route exists for this path
+                if (!routeHandler) {
+                    const methods = ['GET', 'POST', 'PUT', 'DELETE']
+                    const pathRoute = url ? `/${url}` : `/`
+                    const hasMethodSpecificRoute = methods.some(m => {
+                        const checkRoute = url ? `${m} /${url}` : `${m} /`
+                        return routes[checkRoute] !== undefined
+                    })
+                    
+                    // If method-specific route exists but for different method, return 405
+                    if (hasMethodSpecificRoute) {
+                        if (!responseSent && !s.writableEnded) {
+                            responseSent = true
+                            s.writeHead(405)
+                            s.end()
+                        }
+                        return
+                    }
+                    
+                    // Fall back to path-only route (backward compatible)
+                    routeHandler = routes[url]
+                }
+                
+                if (routeHandler) {
+                    const resp = routeHandler(r, s, data)
                     if (!responseSent && !s.writableEnded) {
                         responseSent = true
-                        s.end(typeof resp === 'string' ? resp:JSON.stringify(resp))
+                        sendResponse(resp)
                     }
                     return
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "instaserve",
-    "version": "1.1.4",
+    "version": "1.1.6",
     "description": "Instant web stack",
     "main": "module.mjs",
     "bin": "./instaserve",

package/test.js

@@ -0,0 +1,28 @@
+export default {
+    // Middleware functions (prefixed with _) run on every request
+    // Return false to continue processing, or a value to use as response
+    
+    // Example: Log all requests
+    _log: (req, res, data) => {
+        console.log(`${req.method} ${req.url}`)
+        return false // Continue to next middleware or route
+    },
+
+    // Example: Basic authentication (commented out)
+    // _auth: (req, res, data) => {
+    //     if (!data.token) {
+    //         res.writeHead(401)
+    //         return 'Unauthorized'
+    //     }
+    //     return false // Continue if authorized
+    // },
+
+    // Regular route handlers
+    hello: (req, res, data) => {
+        return { message: 'Hello World' }
+    },
+
+    api: (req, res, data) => {
+        return { message: 'API endpoint', data }
+    }
+}