@vyckr/tachyon 1.2.0 → 1.3.0

package/README.md

@@ -12,13 +12,14 @@ Tachyon is a **polyglot, file-system-routed full-stack framework for [Bun](https
 - **Hot Module Replacement** — watches `routes/` and `components/` and reloads on change
 - **Custom 404 page** — drop a `404.html` in your project root to override the default
 - **Schema validation** — per-route request/response validation via `OPTIONS` files
+- **Status code routing** — map response schemas to HTTP status codes; the framework picks the code automatically
 - **Auth** — built-in Basic Auth and JWT decoding
 - **Streaming** — SSE responses via `Accept: text/event-stream`
 
 ## Installation
 
 ```bash
-npm install @vyckr/tachyon
+bun add @vyckr/tachyon
 ```
 
 ## Quick Start
@@ -172,6 +173,28 @@ Place an `OPTIONS` file in any route directory to enable validation:
 
 Nullable fields are suffixed with `?`. Set `VALIDATE=true` in your `.env` to enable.
 
+### Status Code Routing
+
+Instead of `res`/`err`, you can key response schemas by HTTP status code. Tachyon matches the handler's JSON output against each schema in ascending order — the first match determines the response status code.
+
+```json
+{
+  "POST": {
+    "req": { "name": "string" },
+    "201": { "id": "string", "name": "string" },
+    "400": { "detail": "string" },
+    "503": { "detail": "string", "retryAfter": 0 }
+  },
+  "DELETE": {
+    "204": {}
+  }
+}
+```
+
+Handlers write their normal JSON to stdout — no changes required. The framework determines the status code from whichever schema the output matches. If no numeric schemas are defined, the default behaviour applies (stdout → 200, stderr → 500).
+
+When `VALIDATE=true` is set, the matched schema is also used for strict validation.
+
 ## Front-end Pages (Yon)
 
 Create an `HTML` file inside any route directory to define a front-end page:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vyckr/tachyon",
-    "version": "1.2.0",
+    "version": "1.3.0",
     "description": "A polyglot, file-system-routed full-stack framework for Bun",
     "author": "Chidelma",
     "license": "MIT",

package/src/server/process-executor.ts

@@ -170,15 +170,19 @@ export default class Tach {
 
         const { body, status } = await Tach.getResponse([handler], stdin, context, config)
 
+        const matchedStatus = body ? Validate.matchStatusCode(handler, body) : null
+        const finalStatus   = matchedStatus ?? status
+
         if (process.env.VALIDATE !== undefined) {
+            const ioKey = matchedStatus ? String(matchedStatus) : (status === 200 ? "res" : "err")
             try {
-                await Validate.validateData(handler, status === 200 ? "res" : "err", body!)
+                await Validate.validateData(handler, ioKey, body!)
             } catch (e) {
                 return Response.json({ detail: (e as Error).message }, { status: 422, headers: Router.headers })
             }
         }
 
-        return new Response(body, { status, headers: Router.headers })
+        return new Response(body, { status: finalStatus, headers: Router.headers })
     }
 
     /**

package/src/server/route-handler.ts

@@ -140,7 +140,8 @@ export default class Router {
         const blob = await request.blob()
 
         if (blob.size > 0) {
-            stdin.body = blob.type.endsWith('json') ? await blob.json() : await blob.text()
+            const contentType = request.headers.get('content-type') ?? ''
+            stdin.body = contentType.includes('json') ? await blob.json() : await blob.text()
         }
 
         const searchParams = new URL(request.url).searchParams

package/src/server/schema-validator.ts

@@ -122,9 +122,52 @@ export default class Validate {
      * populated during `validateRoutes()` — instead of re-reading OPTIONS
      * files from disk.
      */
+    /**
+     * Tries to match `body` against each numeric status-code schema defined for
+     * the route/method in the OPTIONS file. Returns the first matching code, or
+     * `null` if no numeric schemas are defined or none match.
+     */
+    static matchStatusCode(handler: string, body: string): number | null {
+        const parts        = handler.split('/')
+        const method       = parts.pop()!
+        const absoluteDir  = parts.join('/')
+        const relativeRoute = absoluteDir.replace(Router.routesPath, '') || '/'
+
+        const schema = Router.routeConfigs[relativeRoute] as unknown as Record<string, Record<string, Record<string, unknown>>>
+        if (!schema) return null
+
+        const methodSchema = schema[method]
+        if (!methodSchema) return null
+
+        const statusCodes = Object.keys(methodSchema)
+            .filter(k => /^\d{3}$/.test(k))
+            .map(Number)
+            .sort((a, b) => a - b)
+
+        if (statusCodes.length === 0) return null
+
+        let parsed: Record<string, unknown>
+        try {
+            const p = JSON.parse(body)
+            if (typeof p !== 'object' || p === null || Array.isArray(p)) return null
+            parsed = p
+        } catch {
+            return null
+        }
+
+        for (const code of statusCodes) {
+            try {
+                Validate.validateObject({ ...parsed }, methodSchema[String(code)], relativeRoute, relativeRoute)
+                return code
+            } catch {}
+        }
+
+        return null
+    }
+
     static async validateData(
         route: string,
-        io:    'req' | 'err' | 'res',
+        io:    string,
         data:  Record<string, unknown> | string,
     ) {
         const parts        = route.split('/')