yedra 0.12.13 → 0.13.1

package/dist/routing/app.d.ts

@@ -17,7 +17,11 @@ export declare class Yedra {
      * @param req - The HTTP request.
      * @returns The HTTP response.
      */
-    handle(req: Request): Promise<Response>;
+    fetch(url: URL | string, options?: {
+        method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+        body?: string | Buffer;
+        headers?: Record<string, string>;
+    }): Promise<Response>;
     /**
      * Generate OpenAPI documentation for the app.
      */

package/dist/routing/app.js

@@ -1,12 +1,12 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { extname, join } from 'node:path';
+import mime from 'mime';
 import { WebSocketServer } from 'ws';
 import { HttpError } from './errors.js';
 import { Path } from './path.js';
-import { createServer } from 'node:http';
 import { RestEndpoint } from './rest.js';
 import { WsEndpoint } from './websocket.js';
-import { extname, join } from 'node:path';
-import { readdir, readFile, stat } from 'node:fs/promises';
-import mime from 'mime';
 class Context {
     constructor(server) {
         this.server = server;
@@ -71,19 +71,21 @@ export class Yedra {
      * @param req - The HTTP request.
      * @returns The HTTP response.
      */
-    async handle(req) {
-        const url = new URL(req.url).pathname;
-        if (req.method !== 'GET' &&
-            req.method !== 'POST' &&
-            req.method !== 'PUT' &&
-            req.method !== 'DELETE') {
-            return Yedra.errorResponse(405, `Method '${req.method}' not allowed.`);
+    async fetch(url, options) {
+        const parsedUrl = typeof url === 'string' ? new URL(url, 'http://localhost') : url;
+        const method = options?.method ?? 'GET';
+        if (method !== 'GET' &&
+            method !== 'POST' &&
+            method !== 'PUT' &&
+            method !== 'DELETE') {
+            return Yedra.errorResponse(405, `Method '${method}' not allowed.`);
         }
-        const match = this.matchRestRoute(url, req.method);
+        const match = this.matchRestRoute(parsedUrl.pathname, method);
         if (!match.result) {
-            if (req.method === 'GET') {
+            if (method === 'GET') {
                 // try returning a static file
-                const staticFile = this.staticFiles.get(url) ?? this.staticFiles.get('__fallback');
+                const staticFile = this.staticFiles.get(parsedUrl.pathname) ??
+                    this.staticFiles.get('__fallback');
                 if (staticFile !== undefined) {
                     return new Response(staticFile.data, {
                         headers: {
@@ -93,12 +95,12 @@ export class Yedra {
                 }
             }
             if (match.invalidMethod) {
-                return Yedra.errorResponse(405, `Method '${req.method}' not allowed for path '${url}'.`);
+                return Yedra.errorResponse(405, `Method '${method}' not allowed for path '${parsedUrl.pathname}'.`);
             }
-            return Yedra.errorResponse(404, `Path '${url}' not found.`);
+            return Yedra.errorResponse(404, `Path '${parsedUrl.pathname}' not found.`);
         }
         try {
-            return await match.result.endpoint.handle(req, match.result.params);
+            return await match.result.endpoint.handle(parsedUrl.pathname, options?.body ?? '', match.result.params, Object.fromEntries(parsedUrl.searchParams), options?.headers ?? {});
         }
         catch (error) {
             if (error instanceof HttpError) {
@@ -138,14 +140,14 @@ export class Yedra {
             });
             req.on('end', async () => {
                 const body = chunks.length > 0 ? Buffer.concat(chunks) : undefined;
-                const response = await this.handle(new Request(url, {
+                const response = await this.fetch(url, {
                     method: req.method,
                     body: req.method === 'POST' || req.method === 'PUT' ? body : undefined,
-                    headers: Object.entries(req.headers).map(([key, value]) => [
+                    headers: Object.fromEntries(Object.entries(req.headers).map(([key, value]) => [
                         key,
                         Array.isArray(value) ? value.join(',') : (value ?? ''),
-                    ]),
-                }));
+                    ])),
+                });
                 res.writeHead(response.status, Object.fromEntries(response.headers));
                 res.end(Buffer.from(await response.arrayBuffer()));
                 const duration = Date.now() - begin;

package/dist/routing/rest.d.ts

@@ -31,7 +31,7 @@ type EndpointOptions<Params extends Record<string, Schema<unknown>>, Query exten
 };
 export declare abstract class RestEndpoint {
     abstract get method(): 'GET' | 'POST' | 'PUT' | 'DELETE';
-    abstract handle(req: Request, params: Record<string, string>): Promise<Response>;
+    abstract handle(pathname: string, body: string | Buffer, params: Record<string, string>, query: Record<string, string>, headers: Record<string, string>): Promise<Response>;
     abstract documentation(): object;
 }
 declare class ConcreteRestEndpoint<Params extends Record<string, Schema<unknown>>, Query extends Record<string, Schema<unknown>>, Headers extends Record<string, Schema<unknown>>, Req extends BodyType<unknown>, Res extends BodyType<unknown>> extends RestEndpoint {
@@ -42,7 +42,7 @@ declare class ConcreteRestEndpoint<Params extends Record<string, Schema<unknown>
     private headersSchema;
     constructor(method: 'GET' | 'POST' | 'PUT' | 'DELETE', options: EndpointOptions<Params, Query, Headers, Req, Res>);
     get method(): 'GET' | 'POST' | 'PUT' | 'DELETE';
-    handle(req: Request, params: Record<string, string>): Promise<Response>;
+    handle(url: string, body: string | Buffer, params: Record<string, string>, query: Record<string, string>, headers: Record<string, string>): Promise<Response>;
     documentation(): object;
 }
 export declare class Get<Params extends Record<string, Schema<unknown>>, Query extends Record<string, Schema<unknown>>, Headers extends Record<string, Schema<unknown>>, Res extends BodyType<unknown>> extends ConcreteRestEndpoint<Params, Query, Headers, NoneBody, Res> {

package/dist/routing/rest.js

@@ -1,5 +1,5 @@
 import { paramDocs } from '../util/docs.js';
-import { ValidationError } from '../validation/error.js';
+import { Issue, ValidationError } from '../validation/error.js';
 import { NoneBody, none } from '../validation/none.js';
 import { object } from '../validation/object.js';
 import { BadRequestError } from './errors.js';
@@ -17,32 +17,72 @@ class ConcreteRestEndpoint extends RestEndpoint {
     get method() {
         return this._method;
     }
-    async handle(req, params) {
+    async handle(url, body, params, query, headers) {
         let parsedBody;
         let parsedParams;
         let parsedQuery;
         let parsedHeaders;
-        const url = new URL(req.url);
+        const issues = [];
         try {
-            parsedBody = this.options.req.deserialize(Buffer.from(await req.arrayBuffer()), req.headers.get('content-type') ?? 'application/octet-stream');
-            parsedParams = this.paramsSchema.parse(params);
-            parsedQuery = this.querySchema.parse(Object.fromEntries(url.searchParams));
-            parsedHeaders = this.headersSchema.parse(Object.fromEntries(req.headers));
+            parsedBody = this.options.req.deserialize(typeof body === 'string' ? Buffer.from(body) : body, headers['content-type'] ?? 'application/octet-stream');
         }
         catch (error) {
             if (error instanceof SyntaxError) {
-                throw new BadRequestError(error.message);
+                issues.push(new Issue('invalidSyntax', ['body'], 'JSON', error.message));
+            }
+            else if (error instanceof ValidationError) {
+                issues.push(...error.withPrefix('body'));
+            }
+            else {
+                throw error;
+            }
+        }
+        try {
+            parsedParams = this.paramsSchema.parse(params);
+        }
+        catch (error) {
+            if (error instanceof ValidationError) {
+                issues.push(...error.withPrefix('params'));
+            }
+            else {
+                throw error;
+            }
+        }
+        try {
+            parsedQuery = this.querySchema.parse(query);
+        }
+        catch (error) {
+            if (error instanceof ValidationError) {
+                issues.push(...error.withPrefix('query'));
+            }
+            else {
+                throw error;
             }
+        }
+        try {
+            parsedHeaders = this.headersSchema.parse(headers);
+        }
+        catch (error) {
             if (error instanceof ValidationError) {
-                throw new BadRequestError(error.format());
+                issues.push(...error.withPrefix('headers'));
+            }
+            else {
+                throw error;
             }
-            throw error;
+        }
+        if (issues.length > 0) {
+            const error = new ValidationError(issues);
+            throw new BadRequestError(error.format());
         }
         const response = await this.options.do({
-            url: url.pathname,
+            url,
+            // biome-ignore lint/style/noNonNullAssertion: this is required to convince TypeScript that this is initialized
             params: parsedParams,
+            // biome-ignore lint/style/noNonNullAssertion: this is required to convince TypeScript that this is initialized
             query: parsedQuery,
+            // biome-ignore lint/style/noNonNullAssertion: this is required to convince TypeScript that this is initialized
             headers: parsedHeaders,
+            // biome-ignore lint/style/noNonNullAssertion: this is required to convince TypeScript that this is initialized
             body: parsedBody,
         });
         if (response.body instanceof Uint8Array) {

package/dist/routing/websocket.d.ts

@@ -1,7 +1,7 @@
+import type { WebSocket as NodeWebSocket } from 'ws';
 import type { Typeof } from '../validation/body.js';
 import { type ObjectSchema } from '../validation/object.js';
 import type { Schema } from '../validation/schema.js';
-import type { WebSocket as NodeWebSocket } from 'ws';
 type MessageCb = (message: Buffer) => Promise<void> | void;
 type CloseCb = (code: number | undefined, reason: string | undefined) => Promise<void> | void;
 declare class YedraWebSocket {

package/dist/validation/error.d.ts

@@ -1,4 +1,4 @@
-type IssueCode = 'invalidType' | 'tooSmall' | 'tooBig' | 'tooShort' | 'tooLong' | 'invalidPattern' | 'missingProperty' | 'invalidContentType';
+type IssueCode = 'invalidSyntax' | 'invalidType' | 'tooSmall' | 'tooBig' | 'tooShort' | 'tooLong' | 'invalidPattern' | 'missingProperty' | 'invalidContentType';
 export declare class Issue {
     readonly code: IssueCode;
     readonly path: string[];

package/dist/validation/error.js

@@ -1,4 +1,5 @@
 const issueMessages = {
+    invalidSyntax: '${actual}',
     invalidType: "Expected '${expected}' but got '${actual}'",
     tooSmall: "Must be at least '${expected}' but was '${actual}'",
     tooBig: "Must be at most '${expected}' but was '${actual}'",

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "yedra",
-  "version": "0.12.13",
+  "version": "0.13.1",
   "repository": "github:0codekit/yedra",
   "main": "dist/index.js",
   "devDependencies": {
-    "@biomejs/biome": "^1.9.3",
-    "@types/node": "^22.7.5",
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^22.8.0",
     "@types/uuid": "^10.0.0",
     "typescript": "^5.6.3"
   },