yedra 0.17.13 → 0.18.1

package/dist/routing/app.js

@@ -146,7 +146,7 @@ class BuiltApp {
                     }
                     catch (error) {
                         if (error instanceof HttpError) {
-                            return BuiltApp.errorResponse(error.status, error.message);
+                            return BuiltApp.errorResponse(error.status, error.message, error.code);
                         }
                         console.error(error);
                         return BuiltApp.errorResponse(500, 'Internal Server Error.');
@@ -173,18 +173,29 @@ class BuiltApp {
         }
         catch (error) {
             if (error instanceof HttpError) {
-                return BuiltApp.errorResponse(error.status, error.message);
+                return BuiltApp.errorResponse(error.status, error.message, error.code);
             }
             console.error(error);
             return BuiltApp.errorResponse(500, 'Internal Server Error.');
         }
     }
-    static errorResponse(status, errorMessage) {
+    static errorResponse(status, errorMessage, code) {
+        const defaultCodes = new Map([
+            [400, 'bad_request'],
+            [401, 'unauthorized'],
+            [402, 'payment_required'],
+            [403, 'forbidden'],
+            [404, 'not_found'],
+            [405, 'method_not_allowed'],
+            [409, 'conflict'],
+            [500, 'internal_server_error'],
+        ]);
         return {
             status,
             body: {
                 status,
                 errorMessage,
+                code: code ?? defaultCodes.get(status) ?? 'unknown_error',
             },
         };
     }

package/dist/routing/errors.d.ts

@@ -3,47 +3,48 @@
  */
 export declare class HttpError extends Error {
     readonly status: number;
-    constructor(status: number, message: string);
+    readonly code: string | undefined;
+    constructor(status: number, message: string, code?: string);
 }
 /**
  * Indicates a malformed request.
  * Corresponds to HTTP status code 400 Bad Request.
  */
 export declare class BadRequestError extends HttpError {
-    constructor(message: string);
+    constructor(message: string, code?: string);
 }
 /**
  * Indicates missing or invalid credentials.
  * Corresponds to HTTP status code 401 Unauthorized.
  */
 export declare class UnauthorizedError extends HttpError {
-    constructor(message: string);
+    constructor(message: string, code?: string);
 }
 /**
  * Indicates that some kind of payment is required.
  * Corresponds to HTTP status code 402 Payment Required.
  */
 export declare class PaymentRequiredError extends HttpError {
-    constructor(message: string);
+    constructor(message: string, code?: string);
 }
 /**
  * Indicates that the user is not allowed to do something.
  * Corresponds to HTTP status code 403 Forbidden.
  */
 export declare class ForbiddenError extends HttpError {
-    constructor(message: string);
+    constructor(message: string, code?: string);
 }
 /**
  * Indicates that the requested resource does not exist.
  * Corresponds to HTTP status code 404 Not Found.
  */
 export declare class NotFoundError extends HttpError {
-    constructor(message: string);
+    constructor(message: string, code?: string);
 }
 /**
  * Indicates that the action conflicts with the current state.
  * Corresponds to HTTP status code 409 Conflict.
  */
 export declare class ConflictError extends HttpError {
-    constructor(message: string);
+    constructor(message: string, code?: string);
 }

package/dist/routing/errors.js

@@ -2,9 +2,10 @@
  * Base class for errors that will be handled as HTTP status codes.
  */
 export class HttpError extends Error {
-    constructor(status, message) {
+    constructor(status, message, code) {
         super(message);
         this.status = status;
+        this.code = code;
     }
 }
 /**
@@ -12,8 +13,8 @@ export class HttpError extends Error {
  * Corresponds to HTTP status code 400 Bad Request.
  */
 export class BadRequestError extends HttpError {
-    constructor(message) {
-        super(400, message);
+    constructor(message, code) {
+        super(400, message, code);
     }
 }
 /**
@@ -21,8 +22,8 @@ export class BadRequestError extends HttpError {
  * Corresponds to HTTP status code 401 Unauthorized.
  */
 export class UnauthorizedError extends HttpError {
-    constructor(message) {
-        super(401, message);
+    constructor(message, code) {
+        super(401, message, code);
     }
 }
 /**
@@ -30,8 +31,8 @@ export class UnauthorizedError extends HttpError {
  * Corresponds to HTTP status code 402 Payment Required.
  */
 export class PaymentRequiredError extends HttpError {
-    constructor(message) {
-        super(402, message);
+    constructor(message, code) {
+        super(402, message, code);
     }
 }
 /**
@@ -39,8 +40,8 @@ export class PaymentRequiredError extends HttpError {
  * Corresponds to HTTP status code 403 Forbidden.
  */
 export class ForbiddenError extends HttpError {
-    constructor(message) {
-        super(403, message);
+    constructor(message, code) {
+        super(403, message, code);
     }
 }
 /**
@@ -48,8 +49,8 @@ export class ForbiddenError extends HttpError {
  * Corresponds to HTTP status code 404 Not Found.
  */
 export class NotFoundError extends HttpError {
-    constructor(message) {
-        super(404, message);
+    constructor(message, code) {
+        super(404, message, code);
     }
 }
 /**
@@ -57,7 +58,7 @@ export class NotFoundError extends HttpError {
  * Corresponds to HTTP status code 409 Conflict.
  */
 export class ConflictError extends HttpError {
-    constructor(message) {
-        super(409, message);
+    constructor(message, code) {
+        super(409, message, code);
     }
 }

package/dist/routing/rest.d.ts

@@ -10,6 +10,11 @@ type ReqObject<Params, Query, Headers, Body> = {
     query: Query;
     headers: Headers;
     body: Body;
+    /**
+     * The raw request data. If the request body is
+     * streamed, this will be an empty buffer.
+     */
+    raw: Buffer<ArrayBuffer>;
 };
 type ResObject<Body> = Promise<{
     status?: number;

package/dist/routing/rest.js

@@ -26,12 +26,15 @@ class ConcreteRestEndpoint extends RestEndpoint {
     }
     async handle(req) {
         let parsedBody;
+        let rawBody;
         let parsedParams;
         let parsedQuery;
         let parsedHeaders;
         const issues = [];
         try {
-            parsedBody = await this.options.req.deserialize(req.body, req.headers['content-type'] ?? 'application/octet-stream');
+            const result = await this.options.req.deserialize(req.body, req.headers['content-type'] ?? 'application/octet-stream');
+            parsedBody = result.parsed;
+            rawBody = result.raw;
         }
         catch (error) {
             if (error instanceof SyntaxError) {
@@ -91,6 +94,8 @@ class ConcreteRestEndpoint extends RestEndpoint {
             headers: parsedHeaders,
             // biome-ignore lint/style/noNonNullAssertion: this is required to convince TypeScript that this is initialized
             body: parsedBody,
+            // biome-ignore lint/style/noNonNullAssertion: this is required to convince TypeScript that this is initialized
+            raw: rawBody,
         });
     }
     isHidden() {

package/dist/validation/body.d.ts

@@ -17,7 +17,10 @@ export declare abstract class BodyType<Provides, Accepts> {
      * @param stream - The raw stream.
      * @param contentType - The content type.
      */
-    abstract deserialize(stream: Readable, contentType: string): Promise<Provides>;
+    abstract deserialize(stream: Readable, contentType: string): Promise<{
+        parsed: Provides;
+        raw: Buffer<ArrayBuffer>;
+    }>;
     /**
      * Generate OpenAPI docs for this body.
      */

package/dist/validation/either.d.ts

@@ -3,7 +3,10 @@ import { BodyType, type Typeof, type TypeofAccepts, type TypeofProvides } from '
 declare class EitherBody<T extends [...BodyType<unknown, unknown>[]]> extends BodyType<TypeofProvides<T[number]>, TypeofAccepts<T[number]>> {
     private options;
     constructor(options: T);
-    deserialize(stream: Readable, contentType: string): Promise<Typeof<T[number]>>;
+    deserialize(stream: Readable, contentType: string): Promise<{
+        parsed: Typeof<T[number]>;
+        raw: Buffer<ArrayBuffer>;
+    }>;
     bodyDocs(): object;
 }
 /**

package/dist/validation/none.d.ts

@@ -1,7 +1,10 @@
 import type { Readable } from 'node:stream';
 import { BodyType } from './body.js';
 export declare class NoneBody extends BodyType<undefined, undefined> {
-    deserialize(_stream: Readable, _contentType: string): Promise<undefined>;
+    deserialize(_stream: Readable, _contentType: string): Promise<{
+        parsed: undefined;
+        raw: Buffer<ArrayBuffer>;
+    }>;
     bodyDocs(): object;
 }
 /**

package/dist/validation/none.js

@@ -1,7 +1,7 @@
 import { BodyType } from './body.js';
 export class NoneBody extends BodyType {
     deserialize(_stream, _contentType) {
-        return Promise.resolve(undefined);
+        return Promise.resolve({ parsed: undefined, raw: Buffer.from('') });
     }
     bodyDocs() {
         // TODO

package/dist/validation/raw.d.ts

@@ -3,7 +3,10 @@ import { BodyType } from './body.js';
 declare class RawBody extends BodyType<Buffer<ArrayBuffer>, Buffer<ArrayBufferLike>> {
     private contentType;
     constructor(contentType: string);
-    deserialize(stream: Readable, _contentType: string): Promise<Buffer<ArrayBuffer>>;
+    deserialize(stream: Readable, _contentType: string): Promise<{
+        parsed: Buffer<ArrayBuffer>;
+        raw: Buffer<ArrayBuffer>;
+    }>;
     bodyDocs(): object;
 }
 /**

package/dist/validation/raw.js

@@ -6,7 +6,11 @@ class RawBody extends BodyType {
         this.contentType = contentType;
     }
     async deserialize(stream, _contentType) {
-        return await readableToBuffer(stream);
+        const buffer = await readableToBuffer(stream);
+        return {
+            parsed: buffer,
+            raw: buffer,
+        };
     }
     bodyDocs() {
         return {

package/dist/validation/schema.d.ts

@@ -4,7 +4,10 @@ import { BodyType } from './body.js';
  * The base class for all schemas.
  */
 export declare abstract class Schema<T> extends BodyType<T, T> {
-    deserialize(stream: Readable, contentType: string): Promise<T>;
+    deserialize(stream: Readable, contentType: string): Promise<{
+        parsed: T;
+        raw: Buffer<ArrayBuffer>;
+    }>;
     bodyDocs(): object;
     /**
      * Parse the object with this schema. This throws a

package/dist/validation/schema.js

@@ -8,7 +8,7 @@ export class Schema extends BodyType {
     async deserialize(stream, contentType) {
         const buffer = await readableToBuffer(stream);
         if (buffer.length === 0) {
-            return this.parse({});
+            return { parsed: this.parse({}), raw: buffer };
         }
         if (contentType !== 'application/json') {
             throw new ValidationError([
@@ -16,7 +16,7 @@ export class Schema extends BodyType {
             ]);
         }
         const data = JSON.parse(Buffer.from(buffer).toString('utf8'));
-        return this.parse(data);
+        return { parsed: this.parse(data), raw: buffer };
     }
     bodyDocs() {
         return {

package/dist/validation/stream.d.ts

@@ -3,7 +3,10 @@ import { BodyType } from './body.js';
 declare class StreamBody extends BodyType<ReadableStream, ReadableStream> {
     private readonly contentType;
     constructor(contentType: string);
-    deserialize(stream: Readable, _contentType: string): Promise<ReadableStream>;
+    deserialize(stream: Readable, _contentType: string): Promise<{
+        parsed: ReadableStream;
+        raw: Buffer<ArrayBuffer>;
+    }>;
     bodyDocs(): object;
 }
 /**

package/dist/validation/stream.js

@@ -5,14 +5,17 @@ class StreamBody extends BodyType {
         this.contentType = contentType;
     }
     deserialize(stream, _contentType) {
-        return Promise.resolve(new ReadableStream({
-            async start(controller) {
-                for await (const chunk of stream) {
-                    controller.enqueue(chunk);
-                }
-                controller.close();
-            },
-        }));
+        return Promise.resolve({
+            parsed: new ReadableStream({
+                async start(controller) {
+                    for await (const chunk of stream) {
+                        controller.enqueue(chunk);
+                    }
+                    controller.close();
+                },
+            }),
+            raw: Buffer.from(''),
+        });
     }
     bodyDocs() {
         return {

package/package.json

@@ -1,12 +1,12 @@
 {
 	"name": "yedra",
-	"version": "0.17.13",
+	"version": "0.18.1",
 	"repository": "github:0codekit/yedra",
 	"main": "dist/index.js",
 	"devDependencies": {
-		"@biomejs/biome": "^2.2.4",
-		"@types/bun": "^1.2.23",
-		"@types/node": "^24.6.1",
+		"@biomejs/biome": "^2.3.3",
+		"@types/bun": "^1.3.1",
+		"@types/node": "^24.10.0",
 		"@types/uuid": "^11.0.0",
 		"@types/ws": "^8.18.1",
 		"typescript": "^5.9.3"