instaserve 1.1.3 → 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

@@ -27,9 +27,9 @@ const args = process.argv.slice(2)
 
 // Handle generate-routes command
 if (args[0] === 'generate-routes') {
-    const routesFile = './routes.js'
+    const routesFile = path.resolve(process.cwd(), './routes.js')
     if (fs.existsSync(routesFile)) {
-        console.error(chalk.red(`Error: ${routesFile} already exists`))
+        console.error(chalk.red(`Error: routes.js already exists`))
         process.exit(1)
     }
     
@@ -59,12 +59,21 @@ 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' }
     }
 }
 `
     
     fs.writeFileSync(routesFile, sampleRoutes)
-    console.log(chalk.green(`✓ Created ${routesFile}`))
+    console.log(chalk.green(`✓ Created routes.js`))
     process.exit(0)
 }
 
@@ -87,6 +96,7 @@ for (let i = 0; i < args.length; i++) {
 
 // Load routes file
 let routes = {}
+let routesFilePath = null
 const routesFileParam = params.api || './routes.js'
 const routesFileSpecified = !!params.api
 
@@ -117,10 +127,11 @@ if (fs.existsSync(routesFile)) {
                 process.exit(1)
             }
         }
+        routesFilePath = routesFile
     } catch (e) {
         console.error(chalk.red(`Error: Could not load routes file "${routesFileParam}": ${e.message}`))
         process.exit(1)
     }
 }
 
-server(routes) 
+server(routes, params.port ? parseInt(params.port) : undefined, params.ip, routesFilePath) 

package/module.mjs

@@ -1,6 +1,7 @@
 import http from 'node:http'
 import https from 'node:https'
 import fs from 'node:fs'
+import path from 'node:path'
 
 const args = process.argv.slice(2)
 const params = {}
@@ -18,9 +19,9 @@ for (let i = 0; i < args.length; i++) {
     }
 }
 
-function public_file(r, s) {
+function public_file(r, s, publicDir) {
     if (r.url == '/') r.url = '/index.html'
-    const fn = `${params.public || './public'}${r.url.replace(/\.\./g, '')}`
+    const fn = path.resolve(publicDir, r.url.replace(/\.\./g, '').replace(/^\//, ''))
     if (fs.existsSync(fn)) {
         const content = fs.readFileSync(fn, 'utf-8')
         if (fn.match(/.js$/)) {
@@ -34,8 +35,11 @@ function public_file(r, s) {
     return false // Indicate no file was served
 }
 
-export default async function (routes, port = params.port || 3000, ip = params.ip || '127.0.0.1') {
-    const publicDir = params.public || './public'
+export default async function (routes, port = params.port || 3000, ip = params.ip || '127.0.0.1', routesFilePath = null) {
+    const publicDirParam = params.public || './public'
+    const publicDir = path.isAbsolute(publicDirParam) 
+        ? publicDirParam 
+        : path.resolve(process.cwd(), publicDirParam)
     if (publicDir.includes('..')) {
         throw new Error('Public directory path cannot contain ".."')
     }
@@ -47,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 {
@@ -64,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
                     })
@@ -73,17 +92,47 @@ export default async function (routes, port = params.port || 3000, ip = params.i
                 if(responseSent || s.writableEnded) return
 
                 // Try to serve public file
-                if(public_file(r, s)) {
+                if(public_file(r, s, publicDir)) {
                     responseSent = true
                     return
                 }
 
-                const url = rrurl.split('/')[1].split('?')[0]
-                if (routes[url]) {
-                    const resp = routes[url](r, s, data)
+                const urlParts = rrurl.split('/')
+                const url = urlParts.length > 1 ? urlParts[1].split('?')[0] : ''
+                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
                 }
@@ -105,8 +154,8 @@ export default async function (routes, port = params.port || 3000, ip = params.i
 
     let server
     if (params.secure) {
-        const certPath = './cert.pem'
-        const keyPath = './key.pem'
+        const certPath = path.resolve(process.cwd(), './cert.pem')
+        const keyPath = path.resolve(process.cwd(), './key.pem')
         
         if (!fs.existsSync(certPath) || !fs.existsSync(keyPath)) {
             throw new Error('Certificate files not found. Run ./generate-certs.sh first.')
@@ -125,7 +174,10 @@ export default async function (routes, port = params.port || 3000, ip = params.i
     server.listen(port || 3000, ip || '')
 
     const protocol = params.secure ? 'https' : 'http'
-    console.log(`started on: ${protocol}://${(process.env.ip || ip)}:${(process.env.port || port)}, public: ${publicDir}, ${Object.keys(routes).length > 0 ? `using routes: ${Object.keys(routes)}` : 'not using routes'}`)
+    const routesInfo = Object.keys(routes).length > 0 
+        ? (routesFilePath ? `using routes: ${Object.keys(routes)} (${routesFilePath})` : `using routes: ${Object.keys(routes)}`)
+        : 'not using routes'
+    console.log(`started on: ${protocol}://${(process.env.ip || ip)}:${(process.env.port || port)}, public: ${publicDir}, ${routesInfo}`)
     
     return {
         routes: routes,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "instaserve",
-    "version": "1.1.3",
+    "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 }
+    }
+}